Bonjour,

j'ai un projet en informatique, je doit coder un petit programme qui affiche les ensembles de Julia.

Étant un énorme boulet en math je n'arrive pas a saisir (malgres mes nombreuses recherche et pages lu sur internet) qu'est ce que, clairement et simplement, un ensemble de Julia ? Si vous auriez un exemple pour illustrer votre réponse ça serait vraiment top !

Merci !

Bonjour,

Ça tombe bien, j'ai codé un script très simple y'a quelques semaines en Python 3 que j'ai publié sur Wikipédia - on me la retiré parce que les tutos ne sont pas acceptés (c'est pas grave, tant pis ! ).

Voici le lien de ma modification : https://fr.wikipedia.org/w/index.php?title=Ensemble_de_Julia&oldid=154246401#Programmation

#!/usr/bin/env python3
# Auteur : Yarflam - Licence Creative Commons Zero
import matplotlib.pyplot as plt
import numpy as np

def julia (args):
  img = []
  # Calcul des dimensions du graphe
  dx, dy = args['axeX'][0], args['axeY'][0]
  mx, my = args['axeX'][1], args['axeY'][1]
  lx, ly = (mx-dx)/args['zoom'], (my-dy)/args['zoom'] # espace de rendu / zoom
  dx, dy = dx/args['zoom']+args['dxy'][0], dy/args['zoom']+args['dxy'][1] # décalage / zoom
  args['q'] *= args['zoom'] # qualité * zoom
  # Largeur et hauteur du canvas
  w = int(lx * args['q']) # rendu en x * qualité
  h = int(ly * args['q']) # rendu en y * qualité
  if w < 0 or h < 0: return img
  # Calcul de la fractale
  for y in range(0,h):
    img.append([])
    for x in range(0,w):
      # Définition des nombres complexes
      z = [ (lx/w) * x + dx, (ly/h) * y + dy ] # position x et y sur le plan
      c = [ args['c'][0], args['c'][1] ] # paramètres de Julia
      # Calcul de la limite
      i = 0
      while i < args['imax'] and (z[0]*z[0] + z[1]*z[1]) < 4:
        # Formule Z' = Z²+C
        z = [
            z[0]*z[0] - z[1]*z[1] + c[0],
            2 * z[0] * z[1] + c[1]
        ]
        i += 1
      # Sortie
      if i == args['imax']:
        img[y].append([ 0., 0., 0. ]) # intérieur de la fractale
      else:
        k = 1 - (1./args['imax']) * i
        img[y].append([ k, k, k ]) # extérieur de la fractale avec dégradé
  # Retourner une matrice Numpy (on inverse l'axe Y)
  return np.array(img[::-1], dtype='f')

img = julia({
    'c': [ 0.285, 0.01 ], # Paramètres de Julia
    'dxy': [ 0, 0 ], # Décalage par rapport au graphe
    'axeX': [ -2, 2 ], # Axe X, x_min et x_max
    'axeY': [ -1.2, 1.2 ], # Axe Y, y_min et y_max
    'zoom': 1, # Zoom
    'imax': 85, # Itération maximum
    'q': 300 # Qualité du rendu (= 300 pixels pour 1 cellule du graphe)
})

# Affichage de l'image
plt.axis('off')
plt.imshow(img);
plt.show();

Le principe repose sur les nombres complexes, on applique un calcul de limite pour savoir si un point appartient à l'ensemble de Julia. Selon les paramètres que l'on définit, la qualité du rendu et la forme vont varier. Le code est commenté, si tu as des questions, n'hésites pas !

Edit : petit astuce magique, pour afficher la fractale de Mandelbrot, il suffit de déclarer C selon la valeur de Z et Z à 0, comme suit :

      c = [ (lx/w) * x + dx, (ly/h) * y + dy ] # position x et y sur le plan
      z = [ 0, 0 ]

-
Edité par yarflam 26 mars 2020 à 17:53:35

La question n'était pas comment construire un ensemble de Julia, mais : c'est quoi un ensemble de Julia.

Comme je ne connaissais pas la réponse il y a 3 minutes, je vais mettre mon grain de sel. J'ai cherché, j'ai lu la page Wikipédia. J'ai vaguement compris des trucs, mais pas grand chose. J'ai lu ensuite cette page : https://www.mathcurve.com/fractals/julia/julia.shtml qui éclaircit pas mal.

En fait la page Wikipédia parle des ensembles de Julia en général. C'est extrèmement général, extrèmement abstrait. Dans les faits, Parmi l'infinité d'ensemble de Julia, ceux qui font l'objet de plein d'illustrations, ce sont ceux bâtis à partir de la fonction f(z) = z²+c. A partir d'une valeur de c, on bâtit un ensemble de points, qu'on va appeler espace de Julia. Et la représentation de cet espace donne un beau dessin.

Concrètement, on dessine le point f(0), puis le point f(f(0)), puis f(f(f(0))) etc.

Dans tous les dessins qu'il y a sur le lien ci-dessus, les fonds verts/orangés ne sont pas liés à la notion d'ensemble de Julia. Les ensembles de Julia, ce sont les dessins sur fond blanc. Comme les points arrivent dans un certain ordre ( f(0) puis f(f(0)) puis f(f(f(0))) etc ), les points sont ordonnés, et on peut décider de faire des dégradés de couleur (les 100 premiers points d'une certaine couleur, etc etc 

Là, comment je continue ? Dans cette formule f(z) = z²+c, z est un nombre complexe. Est-ce que ça te parle. Si ça ne te parle pas si mulitiplier 2 complexes, ça ne te parle pas, ça va être compliqué.

d'abord il faut comprendre ce qu'est l'ensemble de julia rempli: pour un nombre complexe c donné, l'ensemble de julia rempli est defini comme l'ensemble des nombres complexes Z0 tels que la suite Z(n+1) = Zn*Zn + c   est bornée.

donc par exemple, se demander si 1+i appartient à l'ensemble de julia rempli pour c=2-i, c'est se demander si la suite defini par Z(n+1)=Zn*Zn + (2-i) et Z0=1+i est bornée.

ensuite, l'ensemble de julia (dependant de c) est la "frontiere" de l'ensemble de julia rempli, c'est à dire si tu te représente l'ensemble de julia rempli sur le plan (tu marque d'un point noir tous les points qui appartiennent à l'ensemble julia rempli), alors l'ensemble de julia va être la "bordure" de cette forme. 

edit: tbc92: attention t'as mal compris, relis ton lien ou mon message.

edit: dans les représentation de l'ensemble de julia, on voit de la couleur, car les points où la suite Zn n'est pas borné sont colorés en fonction du nombre de termes avant que la suite Zn atteigne une certaine norme. En gros la couleur dépend du temps que met la suite Zn à "exploser". une suite Zn qui met du temps à exploser sera marqué d'une couleur proche du noir.

-
Edité par poipoi34 7 décembre 2018 à 11:31:41

voici quelques exemples perso. d' ensembles de Julia avec le programme que j'avais écrit sous Scilab   La précision du tracé de la frontière va dépendre du nombre d'itérations que  on se fixe pour considère que les itérés restent bornés. Mais on a à faire à un ensemble fractal et on va ou non diverger pour des variations minimes de \(z_i\). Avec un PC \(\lambda\),  on peut vite atteindre des temps de calculs prohibitifs si on cherche à être trop fin dans le pas de calcul et le nombre d'itérations pour chaque point. 

-
Edité par Sennacherib 7 décembre 2018 à 14:11:05

Alors merci beaucoup pour vos réponses aussi complète ! 

yarflam : ça tombe bien que tu mentionnes Mandelbrot ! En faite je dois coder tout ça en java avec en bonus une variante de Mandelbrot ça va beaucoup m’aider merci ! ☺️

tbc92 poipoi34 grâce à vos explications j´ai mieux saisi le principes merci beaucoup ! C’est déjà plus clair ! 

Sennacherib j’espere Que j’arriverai à faire d’aussi Belle représentation que les tiennes haha ! 

En tout cas merci beaucoup ! Je vais m’y remettre calmement dessus !