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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
def calculage_rapide(identifiant, lecture):
"""
Rempli peu a peu la variable 'matrice'
iters_max = nbr maximum d'itérations
mod_carre = module maximum du nbr complex
largeur = largeur de la matrice
hauteur = hauteur de la marice
z0 = premier terme de la suite
suite = formule de récurence de la suite
couleur = information que l'on enregistre dans la matrice
xmin, xmax, ymin et ymax = dimension du plan complex
iteration = True quand les itérations comptent et pas seulement le module
nbr_couleur = Nombre totale de couleur différentes que peut avoir la fractale
"""
def calcul(ligne, hauteur):
"""
Remplissage d'une partie de la matrice
Retourne la ligne dans une liste
"""
print(" Ligne n°"+str(ligne+1)+"----"+str(int(100*ligne/hauteur))+"%")
liste = [] #On initialise la liste que l'on va remplir
I = complex(0,1) #Ainsi, I est considéré comme une variable
y = (ymax-ymin)*ligne/(hauteur-1)+ymin #La partie imaginaire du plan complex
for colone in range(0,largeur): #Pour chaque case de chaque ligne
x = (xmax-xmin)*colone/(largeur-1)+xmin #La partie réel du plan complex
z = eval(z0) #Création du premier rang de la suite
c = 0 #Initialisation du compteur
while (c<iters_max) and (((z.real**2)+(z.imag**2))<mod_carre): #Tant qu'il n'y a aucune raison d'arrêter le calcul de la suite
c+=1 #Incrémentation du compteur
z = eval(suite) #Calcul du rang suivant
if iteration: #Si la divergence de la suite compte
c = c/iters_max #On prend en compte le nombre d'itérations
else: #Si le module de la suite compte
c = abs(z)/math.sqrt(mod_carre) #Sinon, c'est le module de z qui est pris en compte
liste.append(int(c*nbr_couleurs)/nbr_couleurs) #Ce pxl est ajouté à la ligne
return liste #La ligne est la valeur de retour
global matrice,fin #On fait en sorte que la matrice soit accessible dans tous le programme
if __name__ == "__main__": #Si le programme en cours d’exécution est le programme principal
tuple1, tuple2 = lecture.lire_tout(identifiant) #On récupère les données qui permettent de créer l'image
iters_max = tuple1[5]
mod_carre = tuple1[6]
largeur = tuple2[6]
hauteur = tuple2[7]
z0 = str(tuple1[7])
suite = str(tuple1[8])
xmin = tuple1[9]
xmax = tuple1[10]
ymin = tuple1[11]
ymax = tuple1[12]
iteration = tuple1[13]
nbr_couleurs = tuple1[4]
import multiprocessing #On importe le module
pool = multiprocessing.Pool() #Il est possible de mettre en argument: processes=nbr_de_coeurs
liste_res = [] #Tous les résultats seront enregistrés ici
compteur = 0 #On met le compteur à 0
for ligne in range(0,hauteur): #Pour chacune des lignes à traiter
if fin: return None #Si il faut en finir, on s'arrète de suite
compteur += 1 #On incrémente le compteur
liste_res.append(pool.apply_async(calcul, args=(ligne, hauteur)))#On s'en charge
compteur = compteur%(hauteur//10) #C'est le nombre de boucles pandant lesquelles la matrice n'est pas actualisée
if compteur == 0: #Si on en est à la 16ème boucle
pool.close() #On arrète momentanément de charger la liste d'attente
pool.join() #On lance les calculs en liste d'attente
matrice.extend([resultat.get() for resultat in liste_res])#Récupération des lignes qui viennent d'être calculées
pool = multiprocessing.Pool() #On réinitialise le pooleur
liste_res = [] #On vide la liste des lignes qui ont déjà étés calculées
pool.close() #Validation des dernières lignes
pool.join() #Lancement des derniers calculs
matrice.extend([resultat.get() for resultat in liste_res]) #Récupération des derniers résultats
fin = True
print(" Fin du calcul")
return None |
multiprocessing dans une def!
Répondre avec citation
Partager