Forum TI-Planet.org

je vous présente mon code générant d'autres fractales, liées à l'ensemble de mandelbrot ; elles appartiennent à l'ensemble de julia
Attention : Ce code ne fonctionne pas si votre numworks tourne avec une version 1.2 ou supérieure. Un script est présenté plus tard sur ce topic pour les version 1.2 ou supérieure.

Code: Select all

import kandinsky
N_iteration = 40
X_min = -2
X_max = 2
Y_min = -2
Y_max = 2
for x in range(320):
    for y in range(240):
        c_r = -1
        c_i = 0.3
        z_r = X_min +(X_max-X_min)*x/320
        z_i = Y_min +(Y_max-Y_min)*y/240
        i=0
        while (i < N_iteration ) and ((z_r*z_r)+(z_i*z_i) < 4):
            i+1=i
            stock = z_r
            z_r = z_r * z_r - z_i * z_i +  c_r
            z_i = 2 * stock * z-i + c_i
        rgb = int(255*i/N_iteration)
        col = kandinsky.color(rgb,rgb,rgb)
        kandinsky.set_pixel(x,y,col)

ça affiche ça

Alors oui, le programme est très proche du programme fourni avec la version bêta du python, mais j'y ai mis 4 variables permettant de modifier les parties du plan affichées par la calculatrice (et de faire des zooms)
exemple avec c_r et c_i = 0.36 :



c'est pas mal, mais en modifiant un peu le plan :



ça donne d'un coup plus envie (pensez à augmenter le nombre d'itérations)
c'est pratique quand la fractale générée n'est pas connexe

Pour modifier les couleurs, il suffit de modifier la 20ème ligne de code (pensez à rajouter int( entre chaque "rgb" car chaque valeur se doit d'être entière
pour c_r = 0.3 et c_i = 0.5 :



c_r = 0.285 et c_i = 0.013 avec recadrage



amusez vous bien

Waouh, magnifique loupiot

@loupiot tu nous avais caché tes talents.
c'est très joli, franchement bravo

dommage qu'il n'y ait pas de logiciel de transfert pour numworks pour le moment

Super !
Le tout premier programme NumWorks publié par la communauté, je me trompe ?

Quelqu'un peut m'expliquer comment marche les codes qui dessinent des fractales, avec des couleurs
Je ne sais pas du tout comment ca marche

les fractales sont générées en appliquant à un nombre complexe Z une suite du type Zn+1 = Z²+C avec C un complexe
Quand on a un résultat borné, on peut colorier le point Z du plan. Fais ça pour tout le plan et t'obtient une belle fractale
Quand il y a des couleurs comme dans ce programme, c'est en général qu'on colorie selon la "vitesse" avec laquelle Zn diverge ; plus ça prend un temps long, plus le point est clair
En réalité on prend le nombre d'itération que ça a prit pour comprendre que la suite diverge
j'espère que j'ai été clair

Une maniere assez generale pour generer une fractale est la suivante: on se donne une equation polynomiale dans , par exemple , on applique la methode de Newton pour la resoudre . Selon la valeur initiale , la suite convergera vers un des points fixes, c'est-a-dire une des racines complexes de P ou divergera. On peut alors donner une couleur au point du plan d'affixe en fonction de la racine vers laquelle on converge, ou une autre couleur s'il n'y a pas convergence (numerique) au bout d'un nombre maximal d'iterations.

Ok, merci il me semble que j'ai compris. Je vais essayer de faire ma proper fractale

On notera d'ailleurs que l'absence de complexes dans le module Python de la Numworks rend le code de fractales plus difficile a lire et comprendre, et sa conception fastidieuse.

Voici le script pour les versions 1.2 ou supérieur.
Il faut créer un script, qui s'appelle julia.py

Code: Select all

from kandinsky import*
def julia(c,N_i,xmin,xmax,ymin,ymax):
    """c'est une fonction qui prend en entrées :
    c un nombre complexe,
    N_i le nombre d'itérations,
    xmin et autres la fenêtre du plan que l'on va afficher"""

    if type(N_i*xmin*xmax*ymin*ymax)==complex or N_i<1 or xmin>=xmax or ymin>=ymax:
        """juste pour vérifier que les paramètres correspondent bien à leur utilité ...
        On peut enlever ce if si on est sûr de pas faire n'importe quoi :p """
        return "N_i>=1, xmin<xmax, ymin<ymax"
    else:
        for x in range(320):
            for y in range(222):
                i=0
                z=xmin+(xmax-xmin)*x/320+(ymax-(ymax-ymin)*y/222)*1J
                while i<N_i and abs(z)<=2:
                    z=z*z+c
                    i+=1
                rgb=int(255*i/N_i)
                col=color(rgb,rgb,rgb)
                set_pixel(x,y,col)

cette nouvelle version corrige aussi un autre problème, c'est que l'ancien script générait des images qui étaient le miroir de ce qu'on attendait.