Rappel

Les TD sont à rendre via Moodle avant vendredi soir, minuit. Tout TD non rendu entraîne un 0 immédiatement.

Ces TDs sont à réaliser sous linux. Il faut donc allumer (ou redémarrer) votre machine de TP et la faire redémarrer sous Linux. Les TDs sont à retourner via Moodle sous forme d’une archive tar.gz.

Vous devez faire le maximum du TP dans le terminal, la liste des commandes tapées seront accessibles pour les correcteurs (si tout se passe bien).

Les questions avec des (*) sont facultatives et bien plus difficiles. Le nombre d’étoiles indique la difficulté de la question.

À tout moment vous pouvez consulter le manuel d’une commande en tapant man nom_de_commande.

Préparation du dossier TD9

Créez un dossier TD9 dans votre dossier CRI, ainsi qu’un fichier réponses

Partie 1: boîte à outils sur les complexes

0. Introduction sur les paires

Dans la suite on considère qu’un nombre complexe est une paire de nombres réels (partie réelle et partie imaginaire). En Python, une paire s’écrit simplement (3,4) par exemple.

Créez un fichier test.py contenant les lignes suivantes.

x = (3, 4)
print(x)
print(x[0])
print(x[1])

y = (4,5)
print(x + y)

En déduire dans le fichier réponses le fonctionnement des paires en Python et la signification de l’opération [0] et [1], de l’opérateur +. Que ce passe t’il quand on multiplie deux paires ensemble? Quand on multiplie une paire par un nombre entier?

Nous allons écrire un module complexe.py qui contient plusieurs opérations sur les nombres complexes. Pour les définitions sur les nombres complexes vous pouvez vous référer à l’article de Wikipédia ou à votre cours de mathématiques.

1. Addition

Écrire dans le module complexe.py une fonction addition qui prend deux nombres complexes (représentés par une paire) et qui retourne leur addition.

2. Multiplication

Écrire dans le module complexe.py une fonction multiplication qui prend deux nombres complexes (représentés par une paire) et qui retourne leur multiplication.

Vérifier que le nombre complexe \(i\) représenté par la paire (0,1) a bien un carré égal à (-1, 0).

3. Module complexe

Écrire dans le module complexe.py une fonction module_complexe qui prend un nombre complexe (représenté par une paire) et qui retourne son module complexe.

4. Exponentiel complexe

Écrire dans le module complexe.py une fonction qui prend exp_complexe en argument un angle \(x\) et qui retourne la valeur de la fonction \(x\mapsto e^{2i\pi x}\). Vous pouvez utiliser pour cela les fonctions cos et sin du module math ainsi que l’égalité \(e^{2i\pi x} = \cos(2\pi x) + i\sin(2\pi x)\).

Dessiner dans le plan complexe

0. arange

En regardant l’exécution du script suivant ainsi que la documentation de la fonction arange, indiquez ce que fait, le code suivant.

from numpy import arange
for x in arange(-1,1,0.1):
    print(x)

1. Un premier dessin

Télécharger le module dessin. Il contient une fonction dessin_pixel qui prend un nombre complexe dont les parties réelle et imaginaire sont comprises entre \(-1\) et \(1\) et dessine un petit carré de la couleur voulue à cette position.

Voici un exemple d’utilisation de ce module, utilisant les fonction de module précédant:

import dessin_svg
import complexe
from numpy import arange
print(dessin_svg.head())
for x in arange(0, 1, 0.0001):
    z1 = complexe.exp_complexe(4*x)
    z = complexe.multiplication((x,0), z1)
    print(dessin_svg.dessin_pixel(z, "black"))
print(dessin_svg.foot())

Vérifiez que ce script fait bien ce qu’il faut avec vos modules. Vous devriez obtenir une image qui ressemble à ça:

2. Couleurs

Dans le module dessin_svg.py, vous trouverez une fonction couleur_bleu qui prend en argument un nombre réel entre 0 et 1 et qui retourne une couleur bleu en hexadécimal telle que 0 est associé à noir et 1 associé à la couleur #0000FF.

On peut ainsi tracer le module de la fonction \(z\mapsto z^2\) sur la boule unité à l’aide du code suivant:

import dessin_svg
import complexe
from numpy import arange
print(dessin_svg.head())
pas = 0.01
for x in arange(-1, 1, pas):
    for y in arange(-1, 1, pas):
        if complexe.module_complexe((x,y)) <=1:
            z = complexe.multiplication((x,y), (x,y))
            couleur = dessin_svg.couleur_bleu(complexe.module_complexe(z))
            print(dessin_svg.dessin_pixel(z, couleur))
print(dessin_svg.foot())

Vous devriez obtenir l’image suivante:

Vérifiez que tous marche bien et ajoutez la documentation dans les fonctions du module dessin_svg.

La suite de Julia

1. Suites de Julia

La suite de Julia est une suite complexe définie par la relation de récurrence suivante: \(z_{n+1} = z_n^2 + c\). Pour chaque valeur initiale de la suite \(z_0\) et chaque valeur de \(c\), nous obtenons une suite de Julia différente.

Pour \(z_0\) et \(c\) donné, on peut calculer le ratio de Julia à l’ordre \(n\) comme le nombre \(\frac{i}{n}\) pour \(i\) le plus petit entier entre \(0\) et \(n\) tel que le module de \(z_i\) est plus grand que \(2\). Si cette module est plus petite que \(2\) pour tout \(i\) entre \(0\) et \(n\), alors le ratio de Julia à l’ordre \(n\) vaut \(1\).

Dans un module julia.py écrire une fonction ratio_julia qui prend en argument un nombre complexe z0, un nombre complexe c et un nombre entier n et qui retourne le ratio de Julia à l’ordre \(n\) de la suite défini par z0 et c.

2. Quelques dessins

Pour une constante \(c\) fixée, il est possible de dessiner le ratio à l’ordre \(n\) des suites de Julia en faisant varier \(z_0=x+iy\). En vous inspirant du dessin de la fonction \(z\mapsto z^2\) de l’exercice précédant, tracer les ratio de Julia quand \(x\) et \(y\) varient entre \(-1\) et \(1\) avec un pas de \(0.01\).

Dessinez le ratio de Julia pour les valeurs de \(c\) suivante (pour n = 100):

• c = 0.285 + 0.013 i
• c = 0.285 + 0.01 i
• c = −0.4 + 0.6 i

Essayez en d’autres et trouvez de jolis dessins !

3. Mandelbrot

En lisant l’article de Wikipédia sur la fractale de Mandelbrot, adaptez le code précédant pour la tracer.

Compiled the: dim. 07 janv. 2024 23:18:50 CET