L’ensemble de Mandelbrot et comment le dessiner

Les instructions While et For de Mathematica
samedi 29 mars 2008
par  Jean-Pierre Trang
popularité : 1%

L’ensemble de Mandelbrot a été créé par Benoît Mandelbrot et consiste en un ensemble de points dans le plan complexe. Il s’agit de plusieurs répétitions de formes identiques ; bien sûr, les répétitions ne sont pas à chaque fois les mêmes car sinon, l’ensemble ne pourrait pas être dessiné puisqu’on appliquerait toujours la même forme au même endroit.
En itérant cela de nombreuses fois, nous obtenons à la fin un ensemble très complexe : celui de Mandelbrot.

L’ensemble de Mandelbrot, comme dit précédemment, est un ensemble très riche et très complexe. Ainsi, nous sommes dans l’obligation d’utiliser un programme informatique afin de dessiner cet ensemble, nous nous servirons plus précisément de Mathematica. Grâce à la programmation, il est très simple d’effectuer les nombreuses itérations nécessaires. Pour cela, il est préférable de demander à Mathematica d’effectuer des boucles avec des fonctions bien connues des programmateurs, qui sont également présentes dans d’autres langages de programmation.

Les boucles

Une boucle, c’est le fait de répéter les mêmes instructions un certain nombre de fois. Voici le schéma d’une fonction boucle :

Le programme lit d’abord de haut en bas et applique les instructions suivant leur ordre de lecture, puis revient au tout début ; voilà donc une boucle, qui peut être répétée un nombre indéfini de fois tant que la condition est remplie. Cette condition, c’est l’utilisateur qui la fixe. Elle permet de faire répéter la boucle tant que la condition est vraie, si le résultat ne la respecte plus, la boucle s’arrête. Attention, l’ordinateur est capable de répéter cette boucle un nombre infini de fois, entraînant donc un bug.

Il existe deux façon de dire à Mathematica de faire une boucle. La première est appelée la fonction while. Voici comment construire cette boucle :

While[condition, instructions à répéter]

Très simple d’utilisation, while fait répéter l’instruction donnée tant que la condition est vraie (autrement dit, l’ordinateur reçoit la valeur true ou bien 1 ; dans le cas contraire, l’ordinateur renvoie (pour lui-même) la valeur 0 ou false si le résultat est faux).

La deuxième manière de faire une boucle est la fonction for. Très similaire à while (et pour cause, elles font la même chose !), elle est également simple d’utilisation :

For[valeur initiale, condition, incrémentation, instructions]

On voit que cette dernière demande des arguments plus précis, mais les informations requises sont de toute façon les mêmes pour les deux fonctions. Valeur initiale fixe la valeur initiale de la variable à incrémenter. L’incrémentation, c’est le fait d’augmenter la valeur de la variable de 1.

Voilà des exemples :

  • x = 0;
    While[x<10, Print[x]; x++]
  • For[x=0, x<10, x++, Print[x]]

Les deux fonctions renvoient le même résultat, c’est-à-dire l’affichage des chiffres de 0 à 9.
Comment cela marche-t-il ? C’est simple, dans le premier cas, nous avons fixé une valeur à la variable x en dehors de la fonction et dans le deuxième cas, nous avons fixé cette valeur à l’intérieur car cette dernière fonction demande cela.
Ensuite, la condition est posée dans l’emplacement qu’il faut pour chaque fonction ; ici, nous avons dit à Mathematica d’effectuer la boucle tant que x est strictement plus petit que 10.
Vient alors l’incrémentation. Le plus simple est d’utiliser la typographie des exemples : x++. Elle demande au programme d’incrémenter la valeur de x de 1.
Finalement vient l’instruction, ici Print[x]. Print[x] est une instruction demandant l’affichage du résultat, qui est normalement renvoyé à l’ordinateur qui le garde jalousement pour lui-même.
Petite conclusion : nous avons d’abord fixé la valeur initiale de la variable pour ensuite l’incrémenter. Tant que la condition est respectée, le système continuera d’incrémenter la valeur, elle fera donc autant de boucle que nécessaire. En même temps, à chaque boucle est effectuée l’instruction qui a été tapée dans la fonction. Notons que l’instruction Print[x] est effectuée avant la boucle, les valeurs affichées débutent donc à 0 et finissent à 9.

Explication du code pour l’ensemble de Mandelbrot

Voici le code pour l’ensemble de Mandelbrot, à taper sous Mathematica :

mandelbrotC =
   Compile[{x, y, lim},
      Module[{c, i = 0},
       c = x + I*y;
       While[Abs[c] < 2.0 && i <= lim,
         c = c^2 + (x + I*y);
         i++];
       i]];

- Expliquez ce que fait l’instruction While dans la fonction mandelbrotC.

La boucle while répéte ici l’instruction c = c^2+(x+I*y), c’est-à-dire qu’à chaque boucle, on applique la valeur de c dans l’équation c^2+(x+I*y), ce qui renverra une valeur à l’ordinateur. Si la valeur respecte encore la condition, qui est ici Abs[c] < 2.0 && i <= lim "valeur absolue de c doit être strictement plus petite que 2 ET i doit être égale ou plus petite que lim", alors i sera incrémentée de 1, ce qui donnera une nouvelle valeur pour l’équation et ainsi de suite jusqu’à ce que la condition ne soit plus remplie. On notera que I (majuscule) signifie le nombre imaginaire $\sqrt{-1}$.

- Quels sont les tests utilisés par While dans cette fonction ?

Comme mentionné plus haut, while teste si la valeur absolue de c est strictement plus petite que 2 ET si i est égale ou plus petite que lim.

- Combien d’arguments la fonction mandelbrotC reçoit-elle ? A quoi correspondent ces arguments ?

La fonction mandelbrotC reçoit 4 arguments, qui se retrouvent dans différentes fonctions :

  • La fonction while compte déjà 2 arguments :
    • la condition (Abs[c] < 2.0 && i <= lim)
    • et l’instruction (c = c^2 + (x + I*y) ; i++).
  • La fonction Module compte aussi 2 arguments.
    • le premier étant (c, i=0)
    • et le deuxième (c = x + I*y ; While[Abs[c] < 2.0 && i <= lim, c = c^2 + (x + I*y) ; i++] ; i).
      Nous avons ici 3 arguments en tout, car dans son second argument, la boucle while comprend aussi 2 arguments.
  • La fonction Compile comprend également 2 arguments.
    • Le premier est (x, y, lim)
    • le second est (Module[c, i = 0, c = x + I*y ; While[Abs[c] < 2.0 && i <= lim, c = c^2 + (x + I*y) ; i++] ; i]).

Nous avons donc 4 arguments, car Compile comprend 2 arguments, dont le dernier qui en possède 3.
$1+3 = 4$ CQFD.

- Comment pourrait-on utiliser la fonction mandelbrotC pour dessiner l’ensemble de Mandelbrot ?

Il est possible de dessiner cet ensemble en 3 dimensions grâce à la fonction Plot3D :

Plot3D[mandelbrotC[x, y, 50], {x, -1, 1}, {y, -1, 1}]

Ce qui donne :

- Que font les instructions Compile et Module ?

Compile, comme son nom l’indique, compile l’expression concernée avec le premier argument. Sa syntaxe est la suivante :
Compile[{x1, x2, &#8230; }, expr]
Mathematica compile donc l’expression avec x1, x2, x3, ...

Module spécifie que les variables x, y, ... dans l’expression doivent être traitées comme locales, ainsi, les valeurs prises par ces variables n’affectent pas le code Mathematica entier.
Module[{x, y, ... }, expr]

Conclusion :

Grâce au progrès technologique, l’univers informatique a énormément progressé. Cela a permis beaucoup de choses, notamment l’utilisation d’ordinateurs pour calculer des fonctions très complexes. Avec les boucles while et for, les répétitions devinrent faciles à réaliser, permettant ainsi de calculer et dessiner l’ensemble de Mandelbrot très facilement.



Source & référence utilisées : article 136 de owl-spip, mentionné plus haut. Owl-Spip


Commentaires  forum ferme