Tigriss's WebNest

Histoire de commencer à remplir ce blog tranquillement, je me lance dans une série de trois billets sur les fractales de type Markus-Lyapunov, communément appelées Fractales Lyapunov.

Au menu (les liens seront complétés au fur et à mesure) :

- Partie théorique
Il est question des bases théoriques sur les Lyapunov, suivie d'une partie décrivant l'algorithme, lui-même commenté.

- Partie application
Il sera question des différents moyens de générer ces fracales. Et j'y mettrait mon propre programme de génération, en C.

- Partie construction
Il sera question des problèmes posés par ces fractales, à savoir le temps de calcul, les problèmes de précisions de calcul, les méthodes de coloration et des astuces d'amélioration du rendu.
Et ptet un ptit cadeau à la fin



Un peu d'histoire récente pour commencer.

En septembre 1991, la revue Scientific American montrait à ses lecteurs quatre images très impressionnantes dans un article d'A. K. Dewdney intitulé « Leaping into Lyapunov Space ». Ces images furent obtenues grâce à un algorithme presque aussi simple que ceux des ensembles de Mandelbrot ou de Julia.


Cet algorithme est dérivé d'une formule appelée « Lyapunov », nommée d'après le mathématicien Aleksandr M. Lyapunov. Cette formule permet d'obtenir ce qui s'apelle « l'exposant de Lyapunov », qui permet de savoir si le système étudié (la formule sera donnée plus bas) est stable ou chaotique.
Si le résultat est négatif, c'est que le système est stable, et inversement. Cette formule, utilisée en boucle sur ses propres résultats, permet d'étudier basiquement l'évolution probable de la fécondité d'une populations d'individus.

En 1991, donc, un certain Mario Markus, du Max Planck Institute for Nutrition, travaille en tandem avec Benno Hess sur des simulations mathématiques permettant d'étudier comment des enzymes dégradent les carbohydrates.
Durant ses travaux, Markus construit son modèle avec une paire de paramètres de base, qui une fois lancés dans son modèle dérivé de la formule de Lyapunov donnent un exposant final, ayant les même propriétés que l'exposant « classique ».
Le principe est simple, au lieu de faire évoluer son modèle Lyapunov sur un seul paramètre de base qui est recalculé sur lui même à chaque itération, Markus force l'utilisation de deux paramètres selon l'itération en court. Par exemple, si le paramètre 1 est A et le second est B, et que l'ordre des paramètres utilisés est ABBA, alors les itération ressembleront à ceci :

It. 1 -> A, le paramètre de départ du calcul est donc A
It. 2 -> B, ici le paramètre est B
It. 3 -> B
It. 4 -> A
It. 5 -> A
Et ainsi de suite. Notez donc que si la séquence était ABBAABBA, cela reviendrait bien évidement au même.

Si A et B représentent l'abscisse et l'ordonnée, alors chaque point représente un couple de données A-B. Si on applique des règles de coloration des points selon les résultats, on obtient alors une de ces fameuses images Markus-Lyapunov.



Passons à l'algorithme proprement dit.

Cette suite de code logique provient du manuel d'utilisation de Z-Lyapunov, un freeware de Georges Rosset, donc je parlerais plus en détail dans le second billet.

# Notez que r contient soit A, soit B, à chaque boucle du for principal, selon la séquence (exemple : ABBA) choisie. Pour des raisons de simplicité évidente, la partie de programme qui fait la permutation n'est pas indiquée ici.

# Cette constante indique le nombre d'itérations d'initialisation. Elles permettent de « stabiliser » le calcul avant que la partie qui sera graphique commence
WarmItera = 1000

#Le nombre d'itérations « utiles »
FinalItera = 2000

# Ici, on initialise la variable X. Cette valeur est définie arbitrairement. Communément, les Markus-Lyapunov utilisent X = 0.5
x = 0.5

# Ici commence la boucle à proprement parler. Selon le nombre total d'itérations à faire
for i = 1 to WarmItera + FinaItera

# x est modifié
x = (1.0-x)*r * x

# Si on est dans la partie « utile » des itérations, alors le véritable calcul est fait
if i > WarmItera
sum = sum + Log2(r-2.0*r*x)

# On divise le total par le nombré d'itérations utiles
Result = sum / FinaItera

# Le cycle recommence
endfor

# Une fois le nombre total d'itérations atteint, Result contient l'exposant de Lyapunov final.

Comme vous pouvez le constater, cette fractale est extrêmement simple.


Pour clore ce premier billet, j'aimerais préciser que tout ceci a été largement adapté pour être un poil plus visible par tout le monde, aussi, pour ceux qui vont plus loin, pardonnez moi les raccourcis et imprécision, voir des erreurs/oublis « volontaires »
Pour ceux qui seraient intéressés, le dernier billet contiendra un certain nombre de liens tous plus intéressants les uns que les autres, expliquant tout ceci en détail, et de façon précise.

A bientôt pour la suite !