Bonjour,
J’ai hier développé un simple programme qui me permettait d’afficher l’ensemble de Mandelbrot en Python. Aujourd’hui, j’ai envie de reprendre ce programme afin de le transformer en quelque chose qui m’afficherai selon c une fractale de Julia. Alors, pour premier jet, même si ça ne marche pas, voilà ce que ça donne:
import numpy as np
import matplotlib.pyplot as plt
def create_complex_matrix(x1, x2, y1, y2, quality):
x = np.linspace(x1, x2, int((x2 - x1) * quality))
y = np.linspace(y1, y2, int((y2 - y1) * quality))
return x[np.newaxis, :] + y[:, np.newaxis] * 1j
def julia(c, i):
z = c
z_list = []
for _ in range(i):
z = z ** 2 + c
z_list.append(z)
return z_list
plan = create_complex_matrix(-2, 0.5, -1.5, 1.5, quality=1000)
mask = julia(complex(-0.1, 0.651), i=30)
plt.imshow(plan[mask], cmap="binary")
plt.show()
Ce programme, fonctionne de la sorte:
- Nous importons la librairie
numpy
ainsi quematplotlib.pyplot
qui nous servirons respectivement à créer des matrices et à afficher ces matrices. - Nous définissons une fonction
create_complex_matrix
qui prend en entrée x1, x2, y1 et y2. A partir de ceux-ci il créé deux matrice unidimensionnel et ressort la "fusion" de ces dernières en une matrice bidimensionnel qui nous permet donc d’avoir une matrice ayant des nombres flottants, et négatif (ce qui n’est pas permis nativement). - Nous définissons la fonction
julia
qui prend en argument c eti
. "c" correspond au nombre complexe à partir duquel nous voulons que la fractale s’organise.i
n’est qu’une simple valeur qui déterminera le nombre de fois que nous ferons Zn+1 (le "+1" s’applique à n mais je n’ai pas réussi à le mettre à l’échelle), donc, déterminera la complexité de la fractale rendue (puisque il détermine en soit le nombre de pixel de la fractale). Le fonctionnement interne de la fonction est relativement simple:- nous affectons
c
àz
et non pas0
pour gagner un tour ; - nous définissons la liste
z_list
qui correspond à Z (rappelez-vous, la suite pour Zn) ; - nous entrons dans une boucle
for
qui bouclerai
fois ; - nous appliquons la formule z=z²+c ;
- affectons la valeur (Zn) à la liste
z_list
(Z) ; - puis retournons la liste
z_list
.
- nous affectons
Ensuite, nous créons une matrice bidimensionnelle qui correspond aux normes de la surface nécessaires nativement à Mandelbrot, créons une variable mask
qui contient la suite Z pour c=−0.1+0.651i (pris arbitrairement) et enfin, appliquons se masque à la matrice bidimensionnelle plan
afin de n’afficher uniquement les nombres de ce dernier qui matcheraient avec le masque.
Or ce programme ne fonctionne pas et renvoie d’ailleurs une erreur:
plt.imshow(plan[mask], cmap="binary")
IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices
En plus de ça, je me doute qu’il à un pépin dans la logique de mon code, et j’attend vos retours quand au remaniement de ce programme.
Cordialement.