Comment programmer une fractale?

La programmation du Mandelbrot est facile.
Mon code quick-n-dirty est ci-dessous (non garanti sans bug, mais un bon aperçu).

Voici le contour: L’ensemble de Mandelbrot se trouve dans la grid complexe complètement dans un cercle de rayon 2.

Commencez donc par numériser chaque sharepoint cette zone rectangular. Chaque point représente un nombre complexe (x + yi). Itérer ce nombre complexe:

[new value] = [old-value]^2 + [original-value] tout en gardant une trace de deux choses:

1.) le nombre d’itérations

2.) la distance de [nouvelle valeur] par rapport à l’origine.

Si vous atteignez le nombre maximum d’itérations, vous avez terminé. Si la distance par rapport à l’origine est supérieure à 2, vous avez terminé.

Une fois terminé, colorez le pixel d’origine en fonction du nombre d’itérations effectuées. Ensuite, passez au pixel suivant.

  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. } } } 

Certains détails laissés de côté sont:

1.) Apprenez exactement ce qu'est le carré d’un complexe et comment le calculer.

2.) Découvrez comment traduire la région rectangular (-2,2) en coordonnées d'écran.

Vous devriez en effet commencer par l’ ensemble de Mandelbrot et comprendre ce que c’est vraiment.

L’idée derrière cela est relativement simple. Vous commencez avec une fonction de variable complexe

f (z) = z ^ 2 + C

où z est une variable complexe et C une constante complexe. Maintenant, vous l’itérez à partir de z = 0, c’est-à-dire que vous calculez z1 = f (0), z2 = f (z1), z3 = f (z2) et ainsi de suite. L’ensemble de ces constantes C pour lesquelles l’enchaînement z1, z2, z3, … est borné , c’est-à-dire qu’il ne va pas à l’infini, est l’ensemble de Mandelbrot (le noir dans la figure sur la page Wikipedia).

En pratique, pour dessiner l’ensemble de Mandelbrot, vous devez:

• Choisissez un rectangle dans le plan complexe (par exemple, du point -2-2i au point 2 + 2i).
• Couvrir le rectangle avec une grid rectangular appropriée de points (disons 400×400 points), qui sera mappée aux pixels sur votre moniteur.
• Pour chaque point / pixel, soit C ce point, calculons, disons, 20 termes de la séquence itérée correspondante z1, z2, z3, … et vérifions s’il “va à l’infini”. En pratique, vous pouvez vérifier, en effectuant une itération, si la valeur absolue de l’un des 20 termes est supérieure à 2 (si l’un des termes le fait, les termes suivants sont garantis illimités). Si z_k le fait, la séquence “va à l’infini”; sinon, vous pouvez le considérer comme borné.
• Si la séquence correspondant à un certain point C est bornée, tracez le pixel correspondant sur l’image en noir (car il appartient à l’ensemble de Mandelbrot). Sinon, dessinez-le dans une autre couleur. Si vous voulez vous amuser et produire de belles plots, dessinez-le en différentes couleurs en fonction de la magnitude des abdos (20ème terme).

Ce qui est surprenant à propos des fractales, c’est que nous pouvons obtenir un ensemble extrêmement complexe (en particulier, la frontière de l’ensemble de Mandelbrot) à partir de critères simples et apparemment anodins.

Prendre plaisir!

Si les nombres complexes vous donnent mal à la tête, il existe un large éventail de fractales qui peuvent être formulées en utilisant un système-L. Cela nécessite quelques couches d’interaction, mais chacune est intéressante en soi.

D’abord, vous avez besoin d’une tortue. Avant, Arrière, Gauche, Droite, Pen-up, Pen-down. Il y a beaucoup de formes amusantes à réaliser avec des graphismes de tortue en utilisant la géomésortinge de la tortue, même sans le système L. Recherchez “Graphiques LOGO” ou “Graphiques Tortues”. Un système LOGO complet est en fait un environnement de programmation Lisp utilisant une syntaxe Cambridge Polish non paramétrable. Mais vous n’êtes pas obligé d’aller aussi loin pour obtenir de jolies photos en utilisant le concept de la tortue.

Ensuite, vous avez besoin d’une couche pour exécuter un système en L. Les systèmes L sont liés aux systèmes Post-systèmes et Semi-Thue et, comme les virus, ils chevauchent la frontière de la complétude Turing. Le concept est la réécriture de chaînes . Il peut être implémenté sous la forme d’une macro-expansion ou d’une procédure définie avec des contrôles supplémentaires pour limiter la récursivité. Si vous utilisez une macro-expansion (comme dans l’exemple ci-dessous), vous aurez toujours besoin d’un ensemble de procédures pour mapper les symboles aux commandes tortue et d’une procédure pour parcourir la chaîne ou le tableau pour exécuter le programme tortue codé. Pour un ensemble de procédures de récurrence limitée ( par exemple. ), Vous incorporez les commandes tortue dans les procédures et ajoutez des vérifications au niveau de la récursivité à chaque procédure ou intégrez-les à une fonction de gestionnaire.

Voici un exemple d’arbre de Pythagoras dans Postscript utilisant une macro-expansion et un ensemble très abrégé de commandes de tortue. Pour quelques exemples en python et mathematica, voir mon défi de golf de code .

Il y a un bon livre intitulé Chaos and Fractals qui contient un exemple simple de code à la fin de chaque chapitre qui implémente une fractale ou un autre exemple. Il y a longtemps, lorsque j’ai lu ce livre, j’ai converti chaque exemple de programme (dans certains dialectes de base) en une applet Java exécutée sur une page Web. Les applets sont ici: http://hewgill.com/chaos-and-fractals/

L’un des échantillons est une simple implémentation de Mandelbrot.

Un autre excellent fractal à apprendre est la Fractale Sierpinski Triangle.

Fondamentalement, dessinez trois coins d’un sortingangle (une équilatérale est préférable, mais tout sortingangle fonctionnera), puis commencez un point P à l’un de ces coins. Déplacez P à mi-chemin de l’un des 3 coins au hasard et tracez un point là. De nouveau déplacez P à mi-chemin vers un coin quelconque, dessinez et répétez.

On pourrait penser que le mouvement aléatoire créerait un résultat aléatoire, mais ce n’est vraiment pas le cas.

Référence: http://en.wikipedia.org/wiki/Sierpinski_sortingangle

Le sortingangle de Sierpinski et la courbe de Koch sont des types spéciaux de fractales de flamme. Les fractales de flamme sont un type de système de fonction itéré très généralisé, car elles utilisent des fonctions non linéaires.

Un algorithme pour IFS: es sont les suivants:

Start with a random point.

Répétez les étapes suivantes plusieurs fois (un million au moins, selon la taille de l’image finale):

Apply one of N predefined transformations (masortingx 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 le point est en dehors de l’écran, choisissez au hasard un nouveau à l’intérieur de l’écran.

Si vous voulez de belles couleurs, laissez la couleur dépendre de la dernière transformation utilisée.

Je commencerais par quelque chose de simple, comme un flocon de neige Koch . C’est un processus simple de prendre une ligne et de le transformer, puis de répéter le processus de manière récursive jusqu’à ce qu’il soit propre.

Quelque chose de très simple comme prendre 2 points (une ligne) et append un 3ème point (faire un coin), puis répéter sur chaque nouvelle section créée.

 fractal(p0, p1){ Pmid = midpoint(p0,p1) + moved some distance perpendicular to p0 or p1; fractal(p0,Pmid); fractal(Pmid, p1); } 

J’ai un ensemble de tutoriels et de codes écrits en C # sur mon blog pour générer pas mal de fractales, y compris les fractales de Mandelbrot, Julia, Sierpinski, Plasma, Fern et Newton-Rhapson. J’ai également la source complète de toutes les fractales mentionnées dans les didacticiels téléchargeables au même endroit.

Je pense que vous pourriez ne pas voir les fractales comme un algorithme ou quelque chose à programmer. Les fractales est un concept! C’est un concept mathématique de modèle détaillé qui se répète.

Par conséquent, vous pouvez créer une fractale de plusieurs manières, en utilisant différentes approches, comme illustré ci-dessous.

Choisissez une approche, puis étudiez comment la mettre en œuvre. Ces quatre exemples ont été implémentés à l’aide de Marvin Framework . Les codes sources sont disponibles ici

L’ensemble de mandelbrot est généré en évaluant de manière répétée une fonction jusqu’à ce qu’elle déborde (une limite définie), puis vérifie le temps qu’il vous a fallu pour déborder.

Pseudocode:

 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. 

Remarques:

valeur est un nombre complexe. un nombre complexe (a + b i) est mis au carré pour donner (a a-b * b + 2 * a b i). Vous devrez utiliser un type complexe ou inclure ce calcul dans votre boucle.

Voici un code simple et facile à comprendre en Java pour mandelbrot et autres exemples de fractales

http://code.google.com/p/gaima/wiki/VLFImages

Il suffit de télécharger le fichier BuildFractal.jar pour le tester en Java et de l’exécuter avec la commande:

java -Xmx1500M -jar BuildFractal.jar 1000 1000 MANDELBROT par défaut

Le code source est également gratuit pour télécharger / explorer / modifier / développer.

Eh bien, simple et graphiquement attrayant ne va pas vraiment de pair. Si vous envisagez sérieusement de programmer des fractales, je vous suggère de lire les systèmes de fonctions itérés et les progrès réalisés dans leur rendu.

http://flam3.com/flame_draves.pdf

Les personnes ci-dessus utilisent les points médians de recherche pour sierpinski et Koch. Je vous recommanderais beaucoup de copier les formes, de les mettre à l’échelle et de les traduire pour obtenir l’effet “fractal”. Le pseudo-code en Java pour sierpinski ressemblerait à ceci:

 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 } 

Parfois, je programme des fractales pour le plaisir et comme un défi. Vous pouvez les trouver ici . Le code est écrit en Javascript à l’aide de la bibliothèque P5.js et peut être lu directement à partir du code source HTML.

Pour ceux que j’ai vu, les algorithmes sont assez simples, il suffit de trouver l’élément central et de le répéter encore et encore. Je le fais avec des fonctions récursives, mais peut être fait différemment.