Ensemble de Mandelbrot et autres fractales - Historique des versions

Andrien Montmayeur le 12 mai 2021 à 17:57

2021-05-12T17:57:27Z

← Version précédente		Version du 12 mai 2021 à 17:57
Ligne 1 :		Ligne 1 :
			<b>Ce projet a été réalisé en Python sur un notebook Jupyter.</b>
	=Qu'est ce que l'ensemble de Mandelbrot ?=		=Qu'est ce que l'ensemble de Mandelbrot ?=
	L'ensemble de Mandelbrot est une fractale, c'est-à-dire une figure mathématique identique à toutes les échelles. Cet ensemble fut découvert par Gaston Julia et Pierre Fatou avant la Première Guerre Mondiale. Son nom vient du mathématicien polono-franco-américain Benoît Mandelbrot, qui réalisa les premières représentations de l'ensemble dans les années 1980. Les différents points de l'ensemble correspondent aux points des ensembles de Julia connexes, qui sont des ensembles différents pour chaque point du plan complexe.<br>		L'ensemble de Mandelbrot est une fractale, c'est-à-dire une figure mathématique identique à toutes les échelles. Cet ensemble fut découvert par Gaston Julia et Pierre Fatou avant la Première Guerre Mondiale. Son nom vient du mathématicien polono-franco-américain Benoît Mandelbrot, qui réalisa les premières représentations de l'ensemble dans les années 1980. Les différents points de l'ensemble correspondent aux points des ensembles de Julia connexes, qui sont des ensembles différents pour chaque point du plan complexe.<br>

Andrien Montmayeur : /* Comparaison des optimisations */

2021-05-12T14:06:03Z

Comparaison des optimisations

← Version précédente		Version du 12 mai 2021 à 14:06
Ligne 285 :		Ligne 285 :


			=Programme=

			Ce lien mène vers mon programme avec les différentes optimisations listées dans les sections précédentes.
	[[Programme optimisé]]		[[Programme optimisé]]

	=Réalisations=		=Réalisations=
	Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.		Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.

Andrien Montmayeur : /* Réalisations */

2021-05-12T14:05:06Z

Réalisations

← Version précédente		Version du 12 mai 2021 à 14:05
Ligne 289 :		Ligne 289 :
	=Réalisations=		=Réalisations=
	Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.		Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.
			[[Fichier:agsunset.png\|\|500px\|thumb\|none\|agsunset]]
			[[Fichier:blackbody.png\|\|500px\|thumb\|none\|blackbody]]
			[[Fichier:dense.png\|\|500px\|thumb\|none\|dense]]
			[[Fichier:edge.png\|\|500px\|thumb\|none\|edge]]
			[[Fichier:gray.png\|\|500px\|thumb\|none\|gray]]
			[[Fichier:ice.png\|\|500px\|thumb\|none\|ice]]
			[[Fichier:inferno.png\|\|500px\|thumb\|none\|inferno]]
			[[Fichier:jet.png\|\|500px\|thumb\|none\|jet]]
			[[Fichier:peach.png\|\|500px\|thumb\|none\|peach]]
			[[Fichier:pinkyl.png\|\|500px\|thumb\|none\|pinkyl]]
			[[Fichier:rainbow.png\|\|500px\|thumb\|none\|rainbow]]
			[[Fichier:sunsetdark.png\|\|500px\|thumb\|none\|sunsetdark]]
			[[Fichier:tealgrn.png\|\|500px\|thumb\|none\|tealgrn]]

Andrien Montmayeur le 12 mai 2021 à 13:33

2021-05-12T13:33:48Z

← Version précédente		Version du 12 mai 2021 à 13:33
Ligne 283 :		Ligne 283 :
	\|}		\|}




			[[Programme optimisé]]
	=Réalisations=		=Réalisations=
	Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.		Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.

Andrien Montmayeur le 12 mai 2021 à 13:17

2021-05-12T13:17:54Z

← Version précédente		Version du 12 mai 2021 à 13:17
Ligne 1 :		Ligne 1 :
	==Qu'est ce que l'ensemble de Mandelbrot ?==		=Qu'est ce que l'ensemble de Mandelbrot ?=
	L'ensemble de Mandelbrot est une fractale, c'est-à-dire une figure mathématique identique à toutes les échelles. Cet ensemble fut découvert par Gaston Julia et Pierre Fatou avant la Première Guerre Mondiale. Son nom vient du mathématicien polono-franco-américain Benoît Mandelbrot, qui réalisa les premières représentations de l'ensemble dans les années 1980. Les différents points de l'ensemble correspondent aux points des ensembles de Julia connexes, qui sont des ensembles différents pour chaque point du plan complexe.<br>		L'ensemble de Mandelbrot est une fractale, c'est-à-dire une figure mathématique identique à toutes les échelles. Cet ensemble fut découvert par Gaston Julia et Pierre Fatou avant la Première Guerre Mondiale. Son nom vient du mathématicien polono-franco-américain Benoît Mandelbrot, qui réalisa les premières représentations de l'ensemble dans les années 1980. Les différents points de l'ensemble correspondent aux points des ensembles de Julia connexes, qui sont des ensembles différents pour chaque point du plan complexe.<br>
	L'ensemble de Mandelbrot est régi par une formule mathématique simple : z<sub>n+1</sub> = z<sub>n</sub> * z<sub>n</sub> + c, où z<sub>n</sub> est un nombre complexe évoluant avec le temps et c un point complexe constant. Pour savoir si un point appartient à l'ensemble de Mandelbrot ou non, on répète ce calcul un certain nombre de fois, puis on calcule le module du point complexe obtenu. S'il est strictement inférieur à 2, le point appartient à l'ensemble. Au début du calcul pour un point complexe donnée, z<sub>n</sub> et c sont égaux.		L'ensemble de Mandelbrot est régi par une formule mathématique simple : z<sub>n+1</sub> = z<sub>n</sub> * z<sub>n</sub> + c, où z<sub>n</sub> est un nombre complexe évoluant avec le temps et c un point complexe constant. Pour savoir si un point appartient à l'ensemble de Mandelbrot ou non, on répète ce calcul un certain nombre de fois, puis on calcule le module du point complexe obtenu. S'il est strictement inférieur à 2, le point appartient à l'ensemble. Au début du calcul pour un point complexe donnée, z<sub>n</sub> et c sont égaux.

	==Programme naïf en python==		=Programme naïf en python=
	Le programme dit "naïf" est un programme qui est le plus "évident" possible, c'est-à-dire sans optimisations.		Le programme dit "naïf" est un programme qui est le plus "évident" possible, c'est-à-dire sans optimisations.
	<pre>		<pre>
Ligne 67 :		Ligne 67 :
	[[Fichier : newplot_(9).png\|800px\|thumb\|none\|100 itérations]]		[[Fichier : newplot_(9).png\|800px\|thumb\|none\|100 itérations]]

	==Optimisations==		=Optimisations=
	Il existe divers moyens d'optimiser l'ensemble de Mandelbrot, mais principalement au niveau du nombre de calculs ou modifier la manière dont les calculs sont faits.		Il existe divers moyens d'optimiser l'ensemble de Mandelbrot, mais principalement au niveau du nombre de calculs ou modifier la manière dont les calculs sont faits.
	===Explications===		==Explications==
	====Symétrie sur l'axe des réels====		===Symétrie sur l'axe des réels===
	Il faut savoir que l'ensemble de Mandelbrot est une fractale symétrique selon l'axe des réels. De ce fait, on peut donc diviser le temps total de calcul par 2, puisqu'il suffit de calculer une moitié et de faire son symétrique par rapport à l'axe des réels. L'optimisation apportée se trouve alors dans la fonction ensembleMandelbrot, qui centralise tout. Après modification, on obtient :		Il faut savoir que l'ensemble de Mandelbrot est une fractale symétrique selon l'axe des réels. De ce fait, on peut donc diviser le temps total de calcul par 2, puisqu'il suffit de calculer une moitié et de faire son symétrique par rapport à l'axe des réels. L'optimisation apportée se trouve alors dans la fonction ensembleMandelbrot, qui centralise tout. Après modification, on obtient :
	<pre>		<pre>
Ligne 81 :		Ligne 81 :
	Dans les deux dernières lignes on assigne par symétrie les points déjà calculés.		Dans les deux dernières lignes on assigne par symétrie les points déjà calculés.

	====Calculs====		===Calculs===
	La seconde optimisation dont on peut parler concerne la fonction Mandelbrot, qui calcule la divergence d'un point complexe. Dans la version "naïf", on vérifie à chaque tour de boucle si le module du nombre complexe est inférieur au ModuleMax. On peut tout d'abord fixer le ModuleMax à 2, qui est la valeur reconnue pour l'ensemble. Enfin, le calcul peut être modifié de différentes manières. La première est de vérifier si l'addition de la partie réelle et de la partie imaginaire est strictement inférieure à 4 : cela revient à mettre l'équation d'avant, abs(z) < 2, au carré. Ce qui donne z.realz.real + z.imagz.imag < 4. On peut également changer à nouveau cette inégalité en séparant l'inégalité en deux : z.real<sup>2</sup> < 2 et z.imag<sup>2</sup> < 2. Avec les optimisations de calcul, on peut passer de 5 opérations par tour de boucle à seulement 3. Ce qui peut donner la fonction suivante.		La seconde optimisation dont on peut parler concerne la fonction Mandelbrot, qui calcule la divergence d'un point complexe. Dans la version "naïf", on vérifie à chaque tour de boucle si le module du nombre complexe est inférieur au ModuleMax. On peut tout d'abord fixer le ModuleMax à 2, qui est la valeur reconnue pour l'ensemble. Enfin, le calcul peut être modifié de différentes manières. La première est de vérifier si l'addition de la partie réelle et de la partie imaginaire est strictement inférieure à 4 : cela revient à mettre l'équation d'avant, abs(z) < 2, au carré. Ce qui donne z.realz.real + z.imagz.imag < 4. On peut également changer à nouveau cette inégalité en séparant l'inégalité en deux : z.real<sup>2</sup> < 2 et z.imag<sup>2</sup> < 2. Avec les optimisations de calcul, on peut passer de 5 opérations par tour de boucle à seulement 3. Ce qui peut donner la fonction suivante.
	<pre>		<pre>
Ligne 123 :		Ligne 123 :

	On peut également optimiser la manière de calculer les points et non les opérations.		On peut également optimiser la manière de calculer les points et non les opérations.
	====Boundary tracing====		===Boundary tracing===
	Le boundary tracing consiste à prendre un point et regarder ses voisins pour voir quelle est leur divergence et ainsi tracer une frontière.<br>		Le boundary tracing consiste à prendre un point et regarder ses voisins pour voir quelle est leur divergence et ainsi tracer une frontière.<br>
	Si on prend le pixel rouge dans la figure 1, la fonction va aller chercher dans sa mémoire les divergences des différents voisins, indiquées par le <b>i</b> de ce pixel et ainsi dessiner une frontière comme dans la figure 2. La fonction suivante suit ce principe. On initialise trois tableaux : Todo, Mem et Done, qui sont respectivement le tableau des pxiels restants, les données des pixels calculés et les pixels calculés. A chaque tour de boucle, plusieurs conditions vont être vérifiées pour un point et c'est le résultat de ces conditions qui permettra de dessiner les "frontières de divergence". Cette méthode a cependant un coût : elle doit garder en mémoire des informations sur les différents pixels tout le long de l'exécution.<br>		Si on prend le pixel rouge dans la figure 1, la fonction va aller chercher dans sa mémoire les divergences des différents voisins, indiquées par le <b>i</b> de ce pixel et ainsi dessiner une frontière comme dans la figure 2. La fonction suivante suit ce principe. On initialise trois tableaux : Todo, Mem et Done, qui sont respectivement le tableau des pxiels restants, les données des pixels calculés et les pixels calculés. A chaque tour de boucle, plusieurs conditions vont être vérifiées pour un point et c'est le résultat de ces conditions qui permettra de dessiner les "frontières de divergence". Cette méthode a cependant un coût : elle doit garder en mémoire des informations sur les différents pixels tout le long de l'exécution.<br>
Ligne 205 :		Ligne 205 :
	</pre>		</pre>

	====Periodicity checking====		===Periodicity checking===
	Cette méthode permet de vérifier si un point obtenu par itération d'un pixel a été obtenu avant, et si c'est le cas, le point ne peut pas diverger et fait partie de l'ensemble. Comme la méthode "boundary tracing" vue juste au-dessus, la fonction doit également stocker des informations et les conserver tout du long de son exécution.<br>Cela nous amène au code qui suit :		Cette méthode permet de vérifier si un point obtenu par itération d'un pixel a été obtenu avant, et si c'est le cas, le point ne peut pas diverger et fait partie de l'ensemble. Comme la méthode "boundary tracing" vue juste au-dessus, la fonction doit également stocker des informations et les conserver tout du long de son exécution.<br>Cela nous amène au code qui suit :
	<pre>		<pre>
Ligne 229 :		Ligne 229 :
	Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.		Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.

	===Comparaison des optimisations===		==Comparaison des optimisations==

	Les différents temps relevés ci-dessous ont été mesurés avec la bibliothèque time de python. Il est important de préciser que les temps peuvent varier selon les différents processus actifs au moment du chronométrage. Tous les temps ont donc été mesurés en "même temps", c'est-à-dire sans que d'autres processus soient lancés avant, pendant ou après les chronométrages. <br><br>		Les différents temps relevés ci-dessous ont été mesurés avec la bibliothèque time de python. Il est important de préciser que les temps peuvent varier selon les différents processus actifs au moment du chronométrage. Tous les temps ont donc été mesurés en "même temps", c'est-à-dire sans que d'autres processus soient lancés avant, pendant ou après les chronométrages. <br><br>
Ligne 283 :		Ligne 283 :
	\|}		\|}

	==Réalisations==		=Réalisations=
	Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.		Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.

Andrien Montmayeur : /* Periodicity checking */

2021-05-12T13:16:32Z

Periodicity checking

← Version précédente		Version du 12 mai 2021 à 13:16
Ligne 206 :		Ligne 206 :

	====Periodicity checking====		====Periodicity checking====
	Cette méthode permet de vérifier si un point obtenu par itération d'un pixel a été obtenu avant, et si c'est le cas, le point ne peut pas diverger et fait partie de l'ensemble.<br>Cela nous amène au code qui suit :		Cette méthode permet de vérifier si un point obtenu par itération d'un pixel a été obtenu avant, et si c'est le cas, le point ne peut pas diverger et fait partie de l'ensemble. Comme la méthode "boundary tracing" vue juste au-dessus, la fonction doit également stocker des informations et les conserver tout du long de son exécution.<br>Cela nous amène au code qui suit :
	<pre>		<pre>
	def peridocity(précision, x,y):		def peridocity(précision, x,y,max_iteration):
	xold = 0		xold = 0
	yold = 0		yold = 0
	period = 0		period = 0
			iteration = 0
	while (xx + yy <= 2*2 and iteration < max_iteration) :		while (xx + yy <= 2*2 and iteration < max_iteration) :
	xtemp = xx -yy + x		xtemp = xx -yy + x
Ligne 223 :		Ligne 224 :
	xold = x		xold = x
	yold = y		yold = y
			iteration += 1
	return i		return i
	</pre>		</pre>
	Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.		Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.


	===Comparaison des optimisations===		===Comparaison des optimisations===

Andrien Montmayeur : /* Boundary tracing */

2021-05-12T13:14:41Z

Boundary tracing

← Version précédente		Version du 12 mai 2021 à 13:14
Ligne 125 :		Ligne 125 :
	====Boundary tracing====		====Boundary tracing====
	Le boundary tracing consiste à prendre un point et regarder ses voisins pour voir quelle est leur divergence et ainsi tracer une frontière.<br>		Le boundary tracing consiste à prendre un point et regarder ses voisins pour voir quelle est leur divergence et ainsi tracer une frontière.<br>
	Si on prend le pixel rouge ~~ci-contre~~ ~~comme~~ ~~exemple,~~ ~~[[Fichier : carre2.jpg]]~~,~~<br>~~ la fonction va aller chercher dans sa mémoire les divergences des différents voisins de ce pixel et ainsi dessiner une frontière comme ~~ici~~ : ~~[[Fichier~~ : ~~carre4~~.~~jpg]].<br><br>~~ On ~~obtient~~ ~~alors~~ la ~~fonction~~ ~~suivante~~, ~~assez~~ ~~complexe~~.		Si on prend le pixel rouge dans la figure 1, la fonction va aller chercher dans sa mémoire les divergences des différents voisins, indiquées par le <b>i</b> de ce pixel et ainsi dessiner une frontière comme dans la figure 2. La fonction suivante suit ce principe. On initialise trois tableaux : Todo, Mem et Done, qui sont respectivement le tableau des pxiels restants, les données des pixels calculés et les pixels calculés. A chaque tour de boucle, plusieurs conditions vont être vérifiées pour un point et c'est le résultat de ces conditions qui permettra de dessiner les "frontières de divergence". Cette méthode a cependant un coût : elle doit garder en mémoire des informations sur les différents pixels tout le long de l'exécution.<br>
			[[Fichier : carre2.jpg\|300px\|thumb\|none\|Figure 1]]
			[[Fichier : carre4.jpg\|300px\|thumb\|none\|Figure 2]]

	<pre>		<pre>
	def mandelbrot_boundary_tracing(tabx, taby, max_iter,noOpti):		def mandelbrot_boundary_tracing(tabx, taby, max_iter,noOpti):

Andrien Montmayeur le 12 mai 2021 à 12:48

2021-05-12T12:48:54Z

← Version précédente		Version du 12 mai 2021 à 12:48
Ligne 224 :		Ligne 224 :
	Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.		Le paramètre "précision" sert dans la comparaison entre le point obtenu et ceux en mémoire. Il agit comme une tolérance.

	====Exemples====
	Avec ces optimisations, on peut obtenir des images comme celles-là :
	[[Fichier : newplot_(12).png]]

	===Comparaison des optimisations===		===Comparaison des optimisations===

Andrien Montmayeur : /* Comparaison des optimisations */

2021-05-12T12:06:51Z

Comparaison des optimisations

← Version précédente		Version du 12 mai 2021 à 12:06
Ligne 230 :		Ligne 230 :
	===Comparaison des optimisations===		===Comparaison des optimisations===

			Les différents temps relevés ci-dessous ont été mesurés avec la bibliothèque time de python. Il est important de préciser que les temps peuvent varier selon les différents processus actifs au moment du chronométrage. Tous les temps ont donc été mesurés en "même temps", c'est-à-dire sans que d'autres processus soient lancés avant, pendant ou après les chronométrages. <br><br>

			Ce premier tableau compare la vitesse de calcul pour une partie d'ensemble de hauteur 720 pixels et de largeur 720 pixels, gradué de -2 à 2 sur l'axe des réels et des imaginaires purs. On voit que la comparaison individuelle des composants réel et imaginaire du nombre complexe z est légèrement plus rapide que les deux autres méthodes.

	{\|class="wikitable"		{\|class="wikitable"
Ligne 251 :		Ligne 252 :
	\|}		\|}

			<br><br>

		⚫	Le code qui suit correspond aux opérations effectuées quand la manière "Classique" : Réduction du nombre de multiplications est choisie. Le booléen "appartient" permet d'arrêter la boucle <b>while</b> de calcul. Les variables x et y correspondent aux coordonnées du point en cours de calcul.




⚫	Le code qui suit correspond aux opérations effectuées quand la manière "Classique" : Réduction du nombre de multiplications est choisie. Le booléen "appartient" permet d'arrêter la boucle <b>while</b> de calcul
	<pre>		<pre>
	if x2+y2 >= 4 :		if x2+y2 >= 4 :
Ligne 265 :		Ligne 262 :
	y2 = y*y		y2 = y*y
	</pre>		</pre>
			Ci-dessous, nous avons le même tableau comparatif qu'au-dessus, mais appliqué cette fois aux manières d'effectuer le calcul du point. Dans mon programme, elles sont au nombre de 4 : <b>boundary tracing</b> (utilisation des "frontières" de divergence), <b>periodicity checking</b>, <b>comparaison individuelle des composantes du nombre complexe</b> et <b>réduction du nombre de multiplications</b> (avec le code au-dessus). On remarque que la méthode du boundary tracing permet de gagner 1 seconde environ par rapport aux autres méthodes.
	{\|class="wikitable"		{\|class="wikitable"
	\| '''Manière d'effectuer le calcul du point''' \|\| Boundary tracing \|\| Periodicity checking \|\| "Classique" : abs(z.real) < 2 and abs(z.imag) < 2 \|\| "Classique" : Réduction du nombre de multiplications		\| '''Manière d'effectuer le calcul du point''' \|\| Boundary tracing \|\| Periodicity checking \|\| "Classique" : abs(z.real) < 2 and abs(z.imag) < 2 \|\| "Classique" : Réduction du nombre de multiplications
Ligne 283 :		Ligne 281 :
	\|-		\|-
	\|}		\|}


	==Réalisations==		==Réalisations==

Andrien Montmayeur le 12 mai 2021 à 11:42

2021-05-12T11:42:29Z

← Version précédente		Version du 12 mai 2021 à 11:42
Ligne 283 :		Ligne 283 :
	\|-		\|-
	\|}		\|}


			==Réalisations==
			Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.

← Version précédente		Version du 12 mai 2021 à 14:05
Ligne 289 :		Ligne 289 :
	=Réalisations=		=Réalisations=
	Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.		Ci-dessous, quelques exemples de l'ensemble de Mandelbrot avec différentes palettes de couleurs.
			[[Fichier:agsunset.png\|\|500px\|thumb\|none\|agsunset]]
			[[Fichier:blackbody.png\|\|500px\|thumb\|none\|blackbody]]
			[[Fichier:dense.png\|\|500px\|thumb\|none\|dense]]
			[[Fichier:edge.png\|\|500px\|thumb\|none\|edge]]
			[[Fichier:gray.png\|\|500px\|thumb\|none\|gray]]
			[[Fichier:ice.png\|\|500px\|thumb\|none\|ice]]
			[[Fichier:inferno.png\|\|500px\|thumb\|none\|inferno]]
			[[Fichier:jet.png\|\|500px\|thumb\|none\|jet]]
			[[Fichier:peach.png\|\|500px\|thumb\|none\|peach]]
			[[Fichier:pinkyl.png\|\|500px\|thumb\|none\|pinkyl]]
			[[Fichier:rainbow.png\|\|500px\|thumb\|none\|rainbow]]
			[[Fichier:sunsetdark.png\|\|500px\|thumb\|none\|sunsetdark]]
			[[Fichier:tealgrn.png\|\|500px\|thumb\|none\|tealgrn]]

Ensemble de Mandelbrot et autres fractales - Historique des versions

Andrien Montmayeur le 12 mai 2021 à 17:57

Andrien Montmayeur : /* Comparaison des optimisations */

Andrien Montmayeur : /* Réalisations */

Andrien Montmayeur le 12 mai 2021 à 13:33

Andrien Montmayeur le 12 mai 2021 à 13:17

Andrien Montmayeur : /* Periodicity checking */

Andrien Montmayeur : /* Boundary tracing */

Andrien Montmayeur le 12 mai 2021 à 12:48

Andrien Montmayeur : /* Comparaison des optimisations */

Andrien Montmayeur le 12 mai 2021 à 11:42

Andrien Montmayeur : /* Comparaison des optimisations */

Andrien Montmayeur : /* Réalisations */

Andrien Montmayeur : /* Periodicity checking */

Andrien Montmayeur : /* Boundary tracing */

Andrien Montmayeur : /* Comparaison des optimisations */