Nous allons découvrir dans cette activité un ensemble fascinant : l'ensemble de Mandelbrot. Cet ensemble est un ensemble fractal découvert à la fin des années 70. Il a la propriété d'offrir de superbes images quelque soit le niveau de zoom que l'on opère sur lui, et ce, à l'infini.
Ce qui est encore plus étonnant, c'est que cette complexité infinie du graphisme est issue d'une formule mathématique des plus simples ! Pour construire cet ensemble extraordinaire, revenons sur les nombres complexes en introduisant la notion de *module* :
Soit $z\in \mathbb C$ un nombre complexe. On appelle *module* de $z$ le nombre réel défini par
$$|z|=\sqrt{a^2+b^2}$$Où $z=a+ib$ est l'écriture algébrique de $z$.
Géométriquement, le module de $z$ n'est autre que la distance d'un point d'affixe $z$ à l'origine.
Si $z\in\mathbb R$, $|z|$ coïncide avec la valeur absolue que vous conaissez. La valeur absolue peut aussi s'interpréter sur la droite des réels comme la distance d'un point d'abscisse $z\in\mathbb R$ à l'origine
Calculer $|3-2i|$ puis vérifiez en validant la cellule ci-dessous. Vous remarquerez au passage que Python s'accomode très bien nativement des nombres complexes, à ceci près que le nombre imaginaire est noté $j$ comme en physique ...
La fonction pour calculer les modules est *abs()* ce qui et cohérent car le module coïncide avec la valeur absolue sur les réels.
abs(3-2j)
Soit $c\in \mathbb C$ un nombre complexe.
On considère pour un nombre $a\in\mathbb C$ donné la suite à valeurs complexes $(z_n)$ définie par $$\left \{\begin{array}{rcl} z_0 &=& a\\ z_{n+1}&=&z_n^2+c \end{array}\right.$$ On s'intéresse à l'ensemble $\mathscr J_c$ des points du plan d'affixe $a$ pour lesquels la suite $(|z_n|)$ est bornée.
On suppose dans cette section que c = −1
Répondez dans cette cellule ...
On considère l'algorithme suivant :
a et c sont des nombres complexes donnés
n prend la valeur 0
z prend la valeur a
tant que |z|<2 et n<100 Faire
n prend la valeur ...
z prend la valeur ...
Fin Tantque
Si n=100 Alors retourner -1
Sinon retourner n
Votre réponse ici ...
Programmer cet algorithme dans la fonction Julia ci-dessous
def Julia(a,c):
n=...
z=...
while ... and ... :
...
...
if ... :
return ...
else :
return ...
Tester votre fonction avec les points $O$ et $A$ de la section précédente.
# Testez votre fonction ici
print("Test du point O : ",Julia(...,...))
print("Test du point A : ",Julia(...,...))
En utilisant votre fonction Julia, Testez si le point $B\left(\dfrac 1 2 ; \dfrac 1 2 \right)\in \mathscr J_{-0.47+0.15i}$
# Testez votre fonction ici
print("Test du point B : ",Julia(...,...))
Tapez votre conclusion ici :
Les jolis dessins vont apparaître quand pour chaque point $A$ d'affixe $a$ on associera
C'est le rôle du programme suivant. Essayez d'en comprendre les grandes lignes grâce aux commentaires. Il n'y a rien à modifier.
%pylab inline
########## Le programme commence ici : ##########
w,h=320,240 # On définit la résolution de l'image
xMin,xMax=-2,2 # Paramétrage de l'échelle.
yCentre=0 # A modifier si besoin pour zoomer sur des zones
# On règle automatiquement l'échelle sur y
yMin=yCentre-(xMax-xMin)*h/w/2 # On conserve le ration largeur/longueur
yMax=yCentre+(xMax-xMin)*h/w/2 # en fonciton de la résolution
pasX=(xMax-xMin)/w # pas sur x
pasY=(yMax-yMin)/h # pas sur y
c=-1 # paramètre de l'ensemble de Julia
# On fabrique une grille de 320x240 contenant la sortie de notre fonction Julia
grille=[]
y=yMax # On commence par la ligne du haut
for ligne in range(h):
x=xMin # On se replace à gauche
ligne_grille=[]
for colonne in range(w):
## C'est ici que tout se joue !!! ##
a=x+1j*y # On calcule l'affixe du point A(x+iy)
ligne_grille.append(Julia(a,c)) # On ajoute le résultat de Julia dans la ligne
x+=pasX
y-=pasY
grille.append(ligne_grille) # On ajoute notre ligne à la grille
Les commentaires intégrés à ce programme expliquent les grandes lignes des actions effectuées. Les manipulations sont assez simples mais ne vous seront pas familières si vous n'avez pas suivi la spécialité ISN. Les ISN, en revanche, reconnaîtront le même algorithme que celui utilisé pour créer la grille de démineur !!
Nous avons donc un tableau de 320x240 entiers. Chaque entrée de ce tableau est un pixel d'une image. Appelons la fonction *imshow* pour visualiser l'image qui ressort. Tadaaaaa !!!!
plt.imshow(grille)
Whaou ! que c'est beau les maths !
La partie bleue centrale correspond aux valeurs -1 retournées par la fonction Julia. C'est donc l'ensemble $\mathscr J_c$.
Zoomons un peu ... Vous choisirez
# Copiez coller votre code ici :
Le lapin de douady dont il est fait référence dans les vidéos d'introduction au chapitre des complexes correspond à la valeur $c \approx -0.123 + 0.745 i$
Modifiez le programme ci-dessus pour afficher le lapin. Vous choisirez
# Copiez coller votre code ici :
On considère pour un nombre $a\in\mathbb C$ donné la suite à valeurs complexes $(z_n)$ définie par
$$\left \{\begin{array}{rcl} z_0 &=& a\\ z_{n+1}&=&z_n^2+a \end{array}\right.$$On s'intéresse à l'ensemble $\mathscr M$ des points du plan d'affixe $a$ pour lesquels la suite $(|z_n|)$ est bornée.
Dans la cellule ci-dessous, recopiez en la modifiant la fonction Julia afin qu'elle teste l'appartenance à l'ensemble de Mandelbrot
# Votre nouvelle fonciton ici
Tracez à présent cet ensemble avec les paramètres d'échelle suivants :
# Copiez coller votre code ici :
Vous voulez voir les éléphants du départ ? ils sont ici :
# Copiez coller votre code ici :