Versión 1.0 - julio de 2005

julia.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.
*/

/* 
julia.c	 y sus derivados. 
Un punto del plano complejo pertenece al conjunto de 
Julia 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
Elegimos un valor para c y comprobamos si un punto z pertenece al conjunto.
Si es así le damos un color.

Puntos c interesantes: 
0+0I   círculo
0.1+0.1I   -0.5+0.5I	-1.1+0.1I    -0.2+0.75I  0.25+0.52I  
0.25+0.5I	0+I			0.66+I		1+I

El resultado también queda bien 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 Julia y tendrán un color, pero con más no, y 
se quedan con ese color. Sin embargo los puntos que realmente son de 
Julia 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 del conjunto de Mandelbrot se produce para muchos puntos 
overflow. Puede que en Julia también ocurra (no lo comprobé).
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, c;
	
/*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-512;
			jd=j-347;
/* Variamos la escala de -512, 512 a -1.75, 1.75. Igual para el eje y*/
			id=(id*3.5)/1024;
			jd=(jd*3.5)/1024;
			z=(id+jd*I);
/* Puntos interesantes: 
0+0I   círculo
0.1+0.1I   -0.5+0.5I	-1.1+0.1I    -0.2+0.75I  0.25+0.52I  
0.25+0.5I	0+I			0.66+I		1+I
*/
			
			c=(0.25+0.52*I);	
			for (n=1;n<=500
				;n++) z=z*z+c;	
			if (cabs(z)<=2) putpixel(screen,i,j,rojo);
		
		}
	}
	do {} while (!keypressed());
    return 0;
}
END_OF_MAIN();