Hello!

Je m'amuse un peu avec l'ensemble de Mandelbrot. Le but est de zoomer le plus loin possible en diminuant le pas d'incrémentation (la différence de valeur d'abscisse et d'ordonnée entre deux positions contigües symbolisées par deux pixels contigus)

Je vois dans la doc que la limite inférieure pour les float est de 10e-308.

Jusqu'à un pas d'incrémentation de 1e-16, mon code affiche bien des pixels distincts à chaque incrémentation, j'en conclus que les calculs se passent bien.

Par contre, dès que je passe à un pas d'incrémentation de 1e-17, le code commence à afficher des blocs de pixels, comme s'il n'arrivait plus à incrémenter correctement les valeurs d'abscisse et d'ordonnée.

Voici le code de la fonction qui calcule et affiche.

step est le fameux pas d'incrémentation.
x_start et y_start sont les valeurs d'abscisse et d'ordonnée du coin supérieur gauche de la zone à afficher.
rows_number et lines_number sont les nombres de pixels qui déterminent la taille du canevas à afficher.

Les autres paramètres se rapportent à la gestion des couleurs et à la façon dont les boucles sont incrémentées (pour permettre des pré-visualisation rapide avant de lancer les calculs complets)

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
def draw_selection(x_start, y_start, step, iteration_and_color_offset, loop_increment):
 
    for x_pixel in range(1, rows_number, loop_increment):
 
        for y_pixel in range(1, lines_number, loop_increment):
 
            x_value = x_start + (x_pixel * step)
            y_value = y_start + (y_pixel * step)
            x = 0
            y = 0
            iterations = 0
 
            while x * x + y * y <= 4:
 
                if iterations <= nb_colors + iteration_and_color_offset:
 
                    x_temp = x * x - y * y + x_value
                    y = 2 * x * y + y_value
                    x = x_temp
                    array_index = iterations - iteration_and_color_offset
 
                    pixel_color = color_array[array_index]
 
                    iterations = iterations + 1
 
                else:
 
                    break
 
            cnv.create_line(x_pixel + 1, y_pixel, x_pixel + 2, y_pixel + 1, fill=pixel_color)
 
        cnv.update()
Je me demande si le problème vient d'une limitation dans les valeurs qu'un float peut contenir, ou bien s'il vient d'une faiblesse de mon code...

Merci d'avance pour vos avis éclairés.