Versión 1.0 - julio de 2005

mandelbrot.c

/*
Compilar con la opcion c99:
* gcc -std=c99 -c filename.c -o filename.o
*
* Enlazar con la opcion de librerías matematicas y con allegro:
* gcc  -lm -o filename filename.o `allegro-config --libs`
*
* En Anjuta, ejecutar en terminal allegro-config --libs,
* y su salida son las librerías que tenemos que pasar 
al gcc. Así que vamos a Opciones-> Comandos -> Construir 
Archivo y le ponemos ahí todas las opciones.
*/

/* 
mandelbrot.c y sus derivados
Un punto del plano complejo pertenece al conjunto de 
Mandelbrot si su distancia al origen después de realizar infinitas 
iteraciones es menor o igual que 2. 
La iteración es: z=z**2+c
Inicialmente z siempre vale: z=0+0I y c es el punto a evaluar. 
El resultado queda mejor si evaluamos 25 iteraciones y si pertenece al
conjunto le damos un color. A continuación realizamos 25 iteraciones más
y si pertenece le damos otro color. Y repetimos esto una tercera vez.
Así vemos mejor el fractal en su límite, porque hay puntos que con pocas 
iteraciones pertenecen a Mandelbrot y tendrán un color, pero con más no, y 
se quedan con ese color. Sin embargo los puntos que realmente son de 
Mandelbrot pasarán por los tres colores pero se quedarán con el último.
Por lo anterior no podemos dibujar el fractal pintando los puntos que no 
pertenecen al conjunto ( en vez de los que pertenecen) porque entonces todos
los puntos en la frontera se quedarán al final con el mismo color.

En la iteración se produce para muchos puntos overflow. Tal como está escrito
el programa no hay problema. Hay problema si ponemos:
if (cabs(z)>2) putpixel(screen,i,j,azul); porque un punto overflow no dirá que
	sea mayor que dos. Si ponemos printf("%e\n",cabs(z)); nos mostrará nan, 
que quiere decir not a number, vaya que es el overflow.
Una manera por tanto de saber cuáles son los mayores de 2 es poner:
if (cabs(z)<2) putpixel(screen,i,j,azul);
else {
aquí están los mayores de 2
}
Si queremos poner directamente if (cabs(z)>2)  tendremos que poner un control
en el bucle for con un break:
if (cabs(z)>1e30) break;
*/

#include "allegro.h"
#include 
#include 
int main(void)
{
	PALETTE palette;
	int   i,j,n;
	int amarillo,verde, rojo, azul;
	double x, y ,a,id,jd;
	_Complex double  z;
	
/*Iniciar modo grafico*/
	if (allegro_init() != 0)
    	return 1;
	install_keyboard(); 
	set_color_depth(16);
	if (set_gfx_mode(GFX_AUTODETECT, 1024, 768, 0, 0) != 0) {
    	if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) != 0) {
			allegro_message("Error setting graphics mode\n%s\n", allegro_error);
	 		return 1;
      	}
	}
	set_palette(black_palette);
	set_palette(palette);
	amarillo=makecol(255,255,50);
	verde=makecol(0,255,0);
	azul=makecol(0,0,255);
	rojo=makecol(255,0,0);
	 
/* Código del fractal*/
	
	
/* Para una monitor de 1024 por 768 píxeles*/
	for (i=0; i<=1024;i++) {
		for (j=0; j<=768; j++) {
		
/* Le restamos 512 y 384 para que el punto (0,0) del plano complejo quede
en la mitad de la pantalla. O le restamos otras cantidades para que esté 
en otro sitio.
*/
			id=i-712;
			jd=j-368;
/* Variamos la escala de -512, 512 a -1.5, 1.5. Igual para el eje y*/
			id=(id*3)/1024;
			jd=(jd*3)/1024;
			z=(0+0*I);
			for (n=1;n<=25 ;n++) z=z*z+(id+jd*I);	
			if (cabs(z)<=2) putpixel(screen,i,j,rojo);
			for (n=1;n<=25 ;n++) z=z*z+(id+jd*I);
			if (cabs(z)<=2) putpixel(screen,i,j,azul);
			for (n=1;n<=25 ;n++) z=z*z+(id+jd*I);
			if (cabs(z)<=2) putpixel(screen,i,j,amarillo);
		}
	}
	do {} while (!keypressed());
    return 0;
}
END_OF_MAIN();