110 KiB
Cette fois il s'agit de tracer des fractales, issues des mathématiques et non de la nature comme pour les Lsystem.
Gaston Maurice JULIA est un mathématicien du début du XX eme siècle. Il a travaillé sur les itérations de fonctions complexes.
Remarque: Il ne disposait pas alors d'ordinateur avec écran graphique pour représenter son travail ;-)
Dans les années 1970, Benoît MANDELBROT c'est intéressé aux travaux de JULIA et a inventé le terme de fractale.
Voir: https://fr.wikipedia.org/wiki/Ensemble_de_Mandelbrot
En résumé:
\Rightarrow Écrire un script permettant à partir d'une équation donnée par l'utilisateur, de préciser si cette équation a des solutions et leurs valeurs.
'''Résolution de l'équation du 2° degré '''
from math import sqrt
def solve(a, b, c):
d = b**2 - 4*a*c
if d<0:
return set()
return {(-b-sqrt(d))/(2*a), (-b+sqrt(d))/(2*a)}
a,b,c = (float(x.strip()) for x in input("aX² + bX + c = 0. Entrer a, b, c [format: 'a,b,c']").split(','))
print(f"L'ensemble des solutions est {solve(a,b,c)}.")L'ensemble des solutions est {2.6666666666666665, -5.0}.
'''Les nombres complexes avec Python'''
a = int(input('Saisir la partie réelle du nombre complexe z: '))
b = int(input('Saisir la partie imaginaire du nombre complexe z: '))
z = complex(a,b)
print(f'z = {z} \n')
print(f'La partie réelle de z est : {z.real}')
print(f'La partie imaginaire de z est : {z.imag}i \n')
print(f'Le module de z est : {abs(z)}')Ce qu'il faut retenir :
\Rightarrow Il existe un ensemble \mathbb{C} appelé ensemble des complexes, dans lequel l'ensemble des réels \mathbb{R} est inclus
Un complexe est définit par deux nombres réels :
le premier représente la partie réel du complexe, le deuxième sa partie imaginaire à laquelle est associée à la lettre i (ou j) : z = -2 + 3i ou encore z = -2 + 3j
Propriété de l'imaginaire i : ~i^2 = -1 (ou encore : ~j^2 = -1).
C'est cette dernière propriété qui permet de résoudre le cas \Delta < 0 pour les équations du 2° degré :
Puisque d'un nombre complexe est constitué de deux parties (partie réelle et partie imaginaire), il est tentant de lui associé un point du plan de tel sorte que :
- sa partie réelle est portée par l'axe des abscisses (Ox)
- sa partie imaginaire est portée par l'axe des ordonnées (Oy).
Ainsi au nombre complexe z = a + bi correspond le point M de coordonnées a et b : M(a, b).
On dit que : z est l'affixe du point M.
Application: Utiliser le logiciel Geogebra (sélectionner le mode Tableur => voir menu Affichage) pour représenter dans le plan complexe les points d'affixe :
z_1 = 2 + 3i; ~ z_2 = 1; ~ z_3 = -1i = -i (ne pas oublier de cocher dans Géogebra : Afficher l'objet).
On constate que la distance du point M (affixe de z) à l'origine est donnée par : \sqrt{a^2 + b^2}.
Cette distance représente aussi le module du nombre complexe ~z = a + ib :
|z| = \sqrt{a^2 + b^2}
'''Résolution d'une équation du second degré dans l'ensemble des complexes'''
from cmath import sqrt
def solve(a, b, c):
d = b**2 - 4*a*c
return {(-b-sqrt(d))/(2*a), (-b+sqrt(d))/(2*a)}
solve(1, -1, -1){(-0.6180339887498949+0j), (1.618033988749895+0j)}def codage_lSystem(chaine: str, ordre: int) -> str:
"""
Prends en entrée une chaîne initiale (l'axiome) et l'ordre souhaité
Retourne la chaîne obtenue après n applications du L-system
"""
for n in range(ordre): # Itérer le lSystem jusqu'à l'ordre n
chaine = lSystem_convert(chaine)
return chaine
def lSystem_convert(chaine: str) -> str:
"""
Prends en entrée une chaîne de caractères
Retourne la chaîne obtenue après application des règles du L-System
"""
rules = {'A': 'AB', 'B': 'A'} # A compléter : règles
return ''.join([rules[car] for car in chaine ])
axiome = 'A'
for k in range (5): # Pour affichage des générations jusqu'à l'ordre n
print(f'ordre {k} => {codage_lSystem(axiome, k)}')ordre 0 => A ordre 1 => AB ordre 2 => ABA ordre 3 => ABAAB ordre 4 => ABAABABA
def suiteJulia(z: complex, c: complex) -> complex :
"""
Calcul de la suite de Julia:
En entrée: z et c sont des complexes.
Retourne un complexe.
"""
u = z
print(f'u0 = {(u.real)} + {(u.imag)} i')
for i in range (20):
u = u **2 + c
print(u)
z = complex(0, 0)
suiteJulia(z, complex(-0.5, 0.6))u0 = 0.0 + 0.0 i (-0.5+0.6j) (-0.61+0j) (-0.1279+0.6j) (-0.84364159+0.44652j) (0.012351021977728305-0.1534056855336j) (-0.5233807566101395+0.596210566012932j) (-0.5815396226356586-0.024090274277615786j) (-0.1623920086195465+0.6280188980251884j) (-0.8680365718132812+0.396029499397311j) (0.09664812561246894-0.08753617798754354j) (-0.49832172227226335+0.5830795849484489j) (-0.5916572634952607+0.018877554013384867j) (-0.1502980445988279+0.5776619161019134j) (-0.8111037871043028+0.42635708714134046j) (-0.02389101230070656-0.091639696078201j) (-0.5078270534285525+0.6043787302124746j) (-0.6073853333393171-0.013839739437382148j) (-0.13127459523198132+0.6168121095030072j) (-0.8632241590762293+0.43805647998161634j) (0.05326246915897892-0.1562818731200477j)
" Saisir ici le code précédent, adapté pour générer un fichier : Julia.dat => et l'importer dans Géogebra "
def suiteJuliaFichier(z: complex, c: complex) -> complex :
"""
Calcul de la suite de Julia:
En entrée: z et c sont des complexes.
Retourne un complexe.
"""
with open('Julia.dat', 'w') as file:
u = z
print(f'u_0 = {(u.real)} + {(u.imag)} i', file=file)
for i in range (20):
u = u **2 + c
print(f'u_{i+1} = {(u.real)} + {(u.imag)} i', file=file)
return z
z = complex(0, 0)
suiteJuliaFichier(z, complex(-0.5, 0.6))0j
"Représentation des point dans le plan complexe, avec Matplotlib :"
import matplotlib.pyplot as plt
def suiteJulia(u: complex, c: complex) -> 'list[complex]' :
"""
Calcul de la suite de Julia:
En entrée: z et c sont des complexes.
Retourne une liste de complexes.
"""
u = z
s = [u]
print(f'u0 = {(u.real)} + {(u.imag)} i')
for i in range (20):
u = u **2 + c
s.append(u)
return s
def tracer_les_points(listePoints):
"Pour tracer les points :"
plt.figure(figsize=(10,10))
plt.xlim([-2, 2])
plt.ylim([-2, 2])
plt.scatter([z.real for z in listePoints], [z.imag for z in listePoints])
plt.show()
plt.close()
u = complex(0, 0)
tracer_les_points(suiteJulia(u, complex(-0.5, 0.6)))u0 = 0.0 + 0.0 i
"Savoir si un point z appartient à l'ensemble de Julia J(c) :"
import matplotlib.pyplot as plt
def suiteJulia(u: complex, c: complex) -> 'list[complex]' :
"""
Calcul de la suite de Julia:
En entrée: z et c sont des complexes.
Retourne une liste de complexes.
"""
u = z
s = [u]
print(f'u0 = {(u.real)} + {(u.imag)} i')
for i in range (20):
u = u **2 + c
s.append(u)
return s
def tracer_les_points(listePoints):
"Pour tracer les points :"
plt.figure(figsize=(10,10))
plt.xlim([-2, 2])
plt.ylim([-2, 2])
plt.scatter([z.real for z in listePoints], [z.imag for z in listePoints])
cercle = plt.Circle((0, 0), 2,fill=False)
plt.gcf().gca().add_artist(cercle)
plt.show()
plt.close()
"""
def cercle_limite():
cercle = plt.Circle((0, 0), 2,fill=False)
plt.gcf().gca().add_artist(cercle) #gca = Get Current Axis
plt.show()
plt.close()
"""
u = complex(0, 0)
suiteJulia(u, complex(-0.5, 0.6))
tracer_les_points(suiteJulia(u, complex(-0.5, 0.6)))u0 = 0.0 + 0.0 i u0 = 0.0 + 0.0 i
'''Modifier le code de la fonction suite de Julia afin d'afficher 20 itérations du module de u => abs(u)
Ceci pour les valeurs suivantes de la suite :
z = 0 + 0i et c = -0.5 + 0.6i
z = 0.239 + 0.2i et c = -0.5 + 0.6i
z = 0.25 + 0.2i et c = -0.5 + 0.6i
'''
def suiteJulia(z: complex, c: complex) -> complex :
"""
Calcul de la suite de Julia:
En entrée: z et c sont des complexes.
Retourne un complexe.
"""
u = z
print(f'u0 = {(u.real)} + {(u.imag)} i')
for i in range (20):
u = u **2 + c
print(abs(u))
z = complex(0, 0)
suiteJulia(z, complex(-0.5, 0.6))u0 = 0.0 + 0.0 i 0.7810249675906654 0.61 0.6134805701894722 0.9545214731883868 0.15390208607399739 0.7933438443797638 0.5820383784682888 0.6486747264540702 0.9541105042909015 0.13039724936159686 0.7670113045268956 0.5919583427000827 0.5968942884001868 0.9163349383334626 0.0947027685237214 0.789406084171619 0.6075429874036964 0.6306268292602768 0.9680131344495009 0.16510879590991473
def ensembleJulia (z: complex, c: complex) -> int :
'''Prend une suite de Julia et un point d'affixe z :
Retourne => -1 si le point est dans l'ensemble J(c): le module de tous les termes est < 2
Retourne l'indice i du premier terme ayant un module supérieur à 2
'''
u = z
print(f'u0 = {(u.real)} + {(u.imag)} i')
for i in range (20):
u = u **2 + c
if abs(u) > 2:
return i
return -172/ Changement de repère :
Puisqu'il s'agit de tracer une image à l'écran, nous allons faire en sorte que les points M (de la suite de Julia) appartiennent à l'écran de l'ordinateur. Donc le plan complexe sera représenté par l'écran de l'ordinateur.
L'écran est constitué de pixels ayant x et y pour coordonnées. Les dimensions de l'image de la fractale seront comprises entre 0 et 400 pixels pour x et pour y.
Les ensembles de Julia intéressant sont pour z = a + ib ayant une partie réelle a et une partie imaginaire b comprises entre -1.25 et +1.25.
Un changement de repère est donc nécessaire pour faire correspondre la partie du plan complexe pertinente (-1.25 -> +1.25) avec les pixels de notre image fractale (0 -> 400).
Établir les équations pour passer de l'image en pixel, à la valeur de z, et écrire la fonction convert correspondante :
def convert(x:int, y:int) ->complex :
"Convertit un point du plan (de l'image) de coordonnées x, y en un nombre complexe z = re + img*j"
return complex(x/160 - 1.25, y/160 - 1.25)from PIL import Image
from math import log10, sqrt
from random import randint
def colorise(img, taille):
"Colorise un carré de pixel, avec des bandes, selon les formules proposées ci-dessus :"
for x in range(400):
for y in range(400):
n = int(sqrt((x-200)**2 + (y-200)**2)) # essayer de faire un truc joli
if n == -1:
img.putpixel((x, y), (0,0,0))
else:
img.putpixel((x, y), (4*n%256, 2*n, 6*n%256))
# Faire appel aux méthodes :
# putpixel(); save() et show()
# Voir : #https://info.blaisepascal.fr/pillow
taille = 400
img = Image.new('RGB',(taille,taille),(255,255,255))
colorise(img, taille)
img.show()from PIL import Image
from math import log10
#***Déclaration des constantes :***
taille = 1000
reMax = -0.5
reMin = 0.5
imgMax = -0.5
imgMin = 0.5
#***Déclaration des fonction locales :***
def ensembleJulia (z: complex, c: complex) -> int :
'''Prend une suite de Julia et un point d'affixe z :
Retourne => -1 si le point est dans l'ensemble J(c): le module de tous les termes est < 2
Retourne l'indice i du premier terme ayant un module supérieur à 2
'''
u = z
for i in range (20):
u = u **2 + c
if abs(u) > 2:
return i
return -1
def convert(x:int, y:int, taille:int) ->complex :
"Convertit un point du plan (de l'image) de coordonnées x, y en un nombre complexe z = re + img*j"
return complex(x*(reMax-imgMin)/taille - (reMax-reMin)/2, y*(imgMax-imgMin)/taille - (imgMax-imgMin)/2)
def dessineFractale(img, taille, c):
"Construit la fractale à partir d'une carré de pixels à colorer en fonction de la valeur de n :"
for x in range(taille):
for y in range(taille):
n = ensembleJulia(convert(x, y, taille), c)
if n == -1:
img.putpixel((x, y), (0,0,0))
else:
img.putpixel((x, y), (4*n%256, 2*n, 6*n%256))
#*** Programme principal :***
"Tester les fractales pour le paramètre c = -0.5+0.6j; -0.8-0.18j; 0-0.8j; 0.285+0.013j "
img = Image.new('RGB',(taille,taille),(255,255,255))
dessineFractale(img, taille, 0-0.8j)
img.show()