theory - propiedades - Cómo programar un fractal?
propiedades de los fractales (14)
A veces programo fractales por diversión y como desafío. Puedes encontrarlos here . El código está escrito en Javascript utilizando la biblioteca P5.js y se puede leer directamente desde el código fuente HTML.
Para aquellos que he visto los algoritmos son bastante simples, solo busca el elemento central y luego repítelo una y otra vez. Lo hago con funciones recursivas, pero se puede hacer de manera diferente.
No tengo ninguna experiencia con la programación de fractales. Por supuesto que he visto las famosas imágenes de Mandelbrot y tal.
¿Puedes proporcionarme algoritmos simples para fractales?
El lenguaje de programación no importa realmente, pero estoy más familiarizado con actionscript, C #, Java.
Sé que si googleo fractales, obtengo mucha información (complicada) pero me gustaría comenzar con un algoritmo simple y jugar con él.
También son bienvenidas las sugerencias para mejorar el algoritmo básico, por ejemplo, cómo hacerlas con esos preciosos colores y cosas por el estilo.
Aquí hay un código simple y fácil de entender en Java para mandelbrot y otros ejemplos fractales
http://code.google.com/p/gaima/wiki/VLFImages
Simplemente descarga BuildFractal.jar para probarlo en Java y ejecutarlo con el comando:
java -Xmx1500M -jar BuildFractal.jar 1000 1000 predeterminado MANDELBROT
El código fuente también es gratis para descargar / explorar / editar / expandir.
Bueno, simple y gráficamente atractivo realmente no van de la mano. Si se toma en serio la programación de fractales, le sugiero que lea sobre los sistemas de funciones iteradas y los avances que se han logrado en su representación.
Comenzaría con algo simple, como Koch Snowflake . Es un proceso simple de tomar una línea y transformarla, luego repetir el proceso recursivamente hasta que se vea nítido.
Algo súper simple como tomar 2 puntos (una línea) y agregar un 3er punto (hacer una esquina), luego repetir en cada nueva sección que se crea.
fractal(p0, p1){
Pmid = midpoint(p0,p1) + moved some distance perpendicular to p0 or p1;
fractal(p0,Pmid);
fractal(Pmid, p1);
}
Creo que es posible que no veas los fractales como un algoritmo o algo para programar. Fractales es un concepto! Es un concepto matemático de patrón detallado que se repite a sí mismo.
Por lo tanto, puede crear un fractal de muchas maneras, utilizando diferentes enfoques, como se muestra en la imagen a continuación.
Elija un enfoque y luego investigue cómo implementarlo. Estos cuatro ejemplos fueron implementados usando Marvin Framework . Los códigos fuente están disponibles here
Deberías comenzar con el conjunto de Mandelbrot y entender lo que realmente es.
La idea detrás de esto es relativamente simple. Empiezas con una función de variable compleja
f (z) = z ^ 2 + C
donde z es una variable compleja y C es una constante compleja. Ahora itera desde z = 0, es decir, calcula z1 = f (0), z2 = f (z1), z3 = f (z2) y así sucesivamente. El conjunto de esas constantes C para las cuales la secuencia z1, z2, z3, ... está acotada , es decir, no va al infinito, es el conjunto de Mandelbrot (el conjunto negro en la figura en la página de Wikipedia).
En la práctica, para dibujar el conjunto de Mandelbrot, debes:
- Elija un rectángulo en el plano complejo (por ejemplo, del punto -2-2i al punto 2 + 2i).
- Cubra el rectángulo con una cuadrícula rectangular adecuada de puntos (por ejemplo, 400x400 puntos), que se asignará a píxeles en su monitor.
- Para cada punto / píxel, deje que C sea ese punto, calcule, digamos, 20 términos de la secuencia iterada correspondiente z1, z2, z3, ... y verifique si "va al infinito". En la práctica, puede verificar, mientras itera, si el valor absoluto de uno de los 20 términos es mayor que 2 (si uno de los términos lo hace, se garantiza que los términos subsiguientes serán ilimitados). Si algo z_k hace, la secuencia "va al infinito"; de lo contrario, puede considerarlo limitado.
- Si la secuencia correspondiente a un cierto punto C está acotada, dibuje el píxel correspondiente en la imagen en negro (ya que pertenece al conjunto de Mandelbrot). De lo contrario, dibujalo en otro color. Si quieres divertirte y producir dibujos bonitos, dibuja en diferentes colores dependiendo de la magnitud de los abdominales (20º término).
El hecho sorprendente sobre los fractales es cómo podemos obtener un conjunto tremendamente complejo (en particular, la frontera del conjunto de Mandelbrot) a partir de requisitos fáciles y aparentemente inofensivos.
¡Disfrutar!
El conjunto de mandelbrot se genera evaluando repetidamente una función hasta que se desborde (un límite definido), y luego verifica cuánto tardó en desbordarse.
Pseudocódigo:
MAX_COUNT = 64 // if we haven''t escaped to infinity after 64 iterations,
// then we''re inside the mandelbrot set!!!
foreach (x-pixel)
foreach (y-pixel)
calculate x,y as mathematical coordinates from your pixel coordinates
value = (x, y)
count = 0
while value.absolutevalue < 1 billion and count < MAX_COUNT
value = value * value + (x, y)
count = count + 1
// the following should really be one statement, but I split it for clarity
if count == MAX_COUNT
pixel_at (x-pixel, y-pixel) = BLACK
else
pixel_at (x-pixel, y-pixel) = colors[count] // some color map.
Notas:
el valor es un número complejo. un número complejo (a + b i) se cuadra para dar (a a-b * b + 2 * a b i). Tendrá que usar un tipo complejo o incluir ese cálculo en su ciclo.
El triángulo de Sierpinski y la curva de Koch son tipos especiales de fractales de llamas. Los fractales de llama son un tipo muy generalizado de sistema de función iterada, ya que utiliza funciones no lineales.
Un algoritmo para IFS: es son los siguientes:
Start with a random point.
Repita lo siguiente muchas veces (un millón al menos, dependiendo del tamaño de la imagen final):
Apply one of N predefined transformations (matrix transformations or similar) to the point. An example would be that multiply each coordinate with 0.5. Plot the new point on the screen.
Si el punto está fuera de la pantalla, elija al azar uno nuevo dentro de la pantalla.
Si quieres colores agradables, deja que el color dependa de la última transformación utilizada.
Existe un gran libro llamado Caos y Fractales que tiene un código de ejemplo simple al final de cada capítulo que implementa algún fractal u otro ejemplo. Hace mucho tiempo, cuando leí ese libro, convertí cada programa de muestra (en algún dialecto básico) en un applet de Java que se ejecuta en una página web. Los applets están aquí: http://hewgill.com/chaos-and-fractals/
Una de las muestras es una implementación simple de Mandelbrot.
La gente de arriba está usando la búsqueda de puntos medios para sierpinski y Koch, recomiendo mucho más copiar formas, escalarlas y luego traducirlas para lograr el efecto "fractal". El seudocódigo en Java para sierpinski se vería así:
public ShapeObject transform(ShapeObject originalCurve)
{
Make a copy of the original curve
Scale x and y to half of the original
make a copy of the copied shape, and translate it to the right so it touches the first copied shape
make a third shape that is a copy of the first copy, and translate it halfway between the first and second shape,and translate it up
Group the 3 new shapes into one
return the new shape
}
La programación de Mandelbrot es fácil.
Mi código quick-n-dirty está por debajo (no se garantiza que esté libre de errores, pero sí un buen esquema).
Aquí está el esquema: El conjunto de Mandelbrot se encuentra en la cuadrícula compleja completamente dentro de un círculo con radio 2.
Por lo tanto, comience escaneando cada punto en ese área rectangular. Cada punto representa un número complejo (x + yi). Iterar ese número complejo:
[new value] = [old-value]^2 + [original-value] mientras realiza un seguimiento de dos cosas:
1.) el número de iteraciones
2.) la distancia de [nuevo-valor] desde el origen.
Si alcanzas la cantidad máxima de iteraciones, ya terminaste. Si la distancia desde el origen es mayor que 2, ya terminaste.
Cuando termine, coloree el píxel original según la cantidad de iteraciones que haya realizado. Luego pasa al siguiente píxel.
public void MBrot()
{
float epsilon = 0.0001; // The step size across the X and Y axis
float x;
float y;
int maxIterations = 10; // increasing this will give you a more detailed fractal
int maxColors = 256; // Change as appropriate for your display.
Complex Z;
Complex C;
int iterations;
for(x=-2; x<=2; x+= epsilon)
{
for(y=-2; y<=2; y+= epsilon)
{
iterations = 0;
C = new Complex(x, y);
Z = new Complex(0,0);
while(Complex.Abs(Z) < 2 && iterations < maxIterations)
{
Z = Z*Z + C;
iterations++;
}
Screen.Plot(x,y, maxColors % iterations); // depending on the number of iterations, color a pixel.
}
}
}
Algunos detalles omitidos son:
1.) Aprenda exactamente qué es el cuadrado de un número complejo y cómo calcularlo.
2.) Descubre cómo traducir la región rectangular (-2,2) a las coordenadas de la pantalla.
Otro fractal excelente para aprender es el Fractal Triángulo de Sierpinski.
Básicamente, dibuje tres esquinas de un triángulo (se prefiere un equilátero, pero cualquier triángulo funcionará), luego comience un punto P en una de esas esquinas. Mueva P a medio camino a cualquiera de las 3 esquinas al azar, y dibuje un punto allí. De nuevo mueva P hasta la mitad hacia cualquier esquina al azar, dibuje y repita.
Uno pensaría que el movimiento aleatorio crearía un resultado aleatorio, pero realmente no lo hace.
Referencia: http://en.wikipedia.org/wiki/Sierpinski_triangle
Si los números complejos te dan un dolor de cabeza, hay una amplia gama de fractales que se pueden formular usando un L-system. Esto requiere un par de capas interactuando, pero cada una es interesante por derecho propio.
Primero necesitas una tortuga. Adelante, Atrás, Izquierda, Derecha, Pen-up, Pen-down. Hay muchas formas divertidas para hacer con gráficos de tortuga utilizando geometría de tortuga incluso sin un sistema L que lo maneje. Busque "LOGO graphics" o "Turtle graphics". Un sistema LOGO completo es, de hecho, un entorno de programación Lisp utiliza una sintaxis polaca de Cambridge sin traducción. Pero no tienes que ir tan lejos para obtener fotos bonitas usando el concepto de tortuga.
Entonces necesitas una capa para ejecutar un L-system. Los sistemas L están relacionados con Post-systems y Semi-Thue , y al igual que virii, se encuentran a ambos lados del límite de la Totalidad de Turing. El concepto es la reescritura de cadenas . Se puede implementar como una macro-expansión o un procedimiento establecido con controles adicionales para vincular la recursión. Si utiliza la macro-expansión (como en el ejemplo a continuación), aún necesitará un procedimiento establecido para asignar símbolos a los comandos de tortuga y un procedimiento para iterar a través de la cadena o matriz para ejecutar el programa de tortuga codificada. Para un conjunto de procedimientos de recursión acotada ( eg. ), Inserta los comandos de tortuga en los procedimientos y agrega verificaciones de recursividad a cada procedimiento o factorizarlos en una función de controlador.
Aquí hay un ejemplo de un Árbol de Pitágoras en postscript usando macro-expansión y un conjunto muy abreviado de comandos de tortuga. Para ver algunos ejemplos en python y mathematica, vea el desafío de mi código de golf .
Tengo un conjunto de tutoriales y códigos escritos en C # en mi blog para generar bastantes fractales, incluidos los fractales de Mandelbrot, Julia, Sierpinski, Plasma, Fern y Newton-Rhapson. También tengo la fuente completa de todos los fractales mencionados en los tutoriales disponibles para descargar desde la misma ubicación.