From 26d4540a9755fc3ce8419b59879f75ea02eb9947 Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Tue, 21 Nov 2023 18:39:04 +0100 Subject: [PATCH 1/8] =?UTF-8?q?premi=C3=A8re=20version=20fini?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- __main__.py | 90 +++++++++++++++++++++++++++++++++++++++++++++-- sort/fusion.py | 48 ++++++++++++++++++++++++- sort/insertion.py | 29 +++++++++++++++ sort/range.py | 21 ++++++++++- sort/recursion.py | 18 +++++++++- sort/selection.py | 35 ++++++++++++++++++ 6 files changed, 235 insertions(+), 6 deletions(-) diff --git a/__main__.py b/__main__.py index 98a585e..53885f4 100644 --- a/__main__.py +++ b/__main__.py @@ -1,5 +1,89 @@ -def main(): - print("Hello world") +import time +from enum import Enum, unique, auto +from sort.range import generate_array_of_number +from sort.selection import sort as selection_sort +from sort.insertion import sort as insertion_sort +from sort.recursion import get_factorial +from sort.fusion import sort as fusion_sort -main() +@unique +class Function(Enum): + GENERATE_ARRAY = auto() + SELECTION_SORT = auto() + INSERTION_SORT = auto() + FACTORIAL = auto() + FUSION_SORT = auto() + + +LOOP_REQUIRED = [element*1000 for element in range(1, 11)] + + +def main(use_tri: Function): + """main function call two other fonction + and take on parameter the sort we want use""" + write_result(do_function(use_tri), use_tri) + + +def do_function(use_tri: Function) -> list[float]: + """do_function make ten time the right sort + and return a tab of time different for the number of element""" + timer_tab: list[float] = [] + for element in range(len(LOOP_REQUIRED)): + start: float = time.time() + + # Generate a tab from 1_000_000 to 10_000_000 + if (use_tri == Function.GENERATE_ARRAY): + generate_array_of_number(LOOP_REQUIRED[element] * 1000) + + # Use selection sort on tab from 1_000 to 10_000 + if (use_tri == Function.SELECTION_SORT): + selection_sort(generate_array_of_number(LOOP_REQUIRED[element])) + + # Use insertion sort on tab from 1_000 to 10_000 + if (use_tri == Function.INSERTION_SORT): + insertion_sort(generate_array_of_number(LOOP_REQUIRED[element])) + + # Use factorial on number from 10 to 100 + if (use_tri == Function.FACTORIAL): + get_factorial(LOOP_REQUIRED[element] // 100) + + # Use fusion sort on tab from 10_000 to 100_000 + if (use_tri == Function.FUSION_SORT): + fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 10)) + + end: float = time.time() + timer_tab.append(end-start) + return timer_tab + + +def write_result(timer_tab: list[float], use_tri: Function): + """write_result take tab of time and the sort for write them to user""" + + for element in range(len(timer_tab)): + + # print time for generate array from 1_000_000 to 10_000_000 + if (use_tri == Function.GENERATE_ARRAY): + print("Le résultat pour " + str(LOOP_REQUIRED[element] * 1000) + + " entrées est " + str(timer_tab[element])) + + # print time for factorial from 10 to 100 + elif (use_tri == Function.FACTORIAL): + print(f"Le résultat pour " + str(LOOP_REQUIRED[element] // 100) + + " entrées est " + str(timer_tab[element])) + + # print time for fusion sort from 10_000 to 100_000 + elif (use_tri == Function.FUSION_SORT): + print("Le résultat pour " + str(LOOP_REQUIRED[element] * 10) + + " entrées est " + str(timer_tab[element])) + + # print time for fusion sort from 1_000 to 10_000 + else: + print("Le résultat pour " + str(LOOP_REQUIRED[element]) + + " entrées est " + str(timer_tab[element])) + +# main(Function.GENERATE_ARRAY) +# main(Function.SELECTION_SORT) +# main(Function.INSERTION_SORT) +# main(Function.FACTORIAL) +# main(Function.FUSION_SORT) diff --git a/sort/fusion.py b/sort/fusion.py index 73a21d3..d6d021f 100644 --- a/sort/fusion.py +++ b/sort/fusion.py @@ -1,2 +1,48 @@ +"""Le tri fusion prend un tableau. +Si le tableau n'est pas vide ou n'est pas composé d'un seul élément, +Python vas le divisé en deux en rappelant la meme fonction puis le merger. +A chaque fois avant de merger les différents tableaux vont se réduire, +jusqu'à ce que chaque tableau n'ait qu'un élément. +Ensuite les tableaux vont se merger petit à petit en restant croissant et +en formant au final un seul tableau """ + + def sort(array: list[int]) -> list[int]: - return array + """if length of array <=1 return array, + else return the merge of the left part and the right part of the array""" + if len(array) <= 1: + return array + return merge(sort(array[:len(array) // 2]), sort(array[len(array) // 2:])) + + +def merge(array_gauche: list[int], array_droite: list[int]) -> list[int]: + """merge take two array and create one new array we both of them, + at every loop it takes the smallest number between two arrays + and remove from the array. Then we return new array created""" + new_array: list[int] = [] + while (True): + if (array_gauche == []): + new_array += array_droite + return new_array + elif (array_droite == []): + new_array += array_gauche + return new_array + if array_droite[0] < array_gauche[0]: + new_array.append(array_droite.pop(0)) + else: + new_array.append(array_gauche.pop(0)) + + +""" +Résultat : +Le résultat pour 10000 entrées est 0.14179372787475586 +Le résultat pour 20000 entrées est 0.11987948417663574 +Le résultat pour 30000 entrées est 0.18050265312194824 +Le résultat pour 40000 entrées est 0.32453370094299316 +Le résultat pour 50000 entrées est 0.38787841796875 +Le résultat pour 60000 entrées est 0.49108314514160156 +Le résultat pour 70000 entrées est 0.6442813873291016 +Le résultat pour 80000 entrées est 0.9117996692657471 +Le résultat pour 90000 entrées est 0.9976096153259277 +Le résultat pour 100000 entrées est 1.2517235279083252 +""" diff --git a/sort/insertion.py b/sort/insertion.py index 73a21d3..d7e32ac 100644 --- a/sort/insertion.py +++ b/sort/insertion.py @@ -1,2 +1,31 @@ +""" +Selon moi, Le tri par insertion va regarder le deuxieme element de la liste +et le placer avant ou après le premier si il est plus petit ou non. Puis faire +pareil avec les autres éléments en les comparant avec tous ceux avant +""" + + def sort(array: list[int]) -> list[int]: + """We make two loop""" + for increment in range(len(array)): + for implementation in range(increment): + if array[increment] < array[implementation]: + temp: int = array[implementation] + array[implementation] = array[increment] + array[increment] = temp return array + + +""" +Résultat : +Le résultat pour 1000 entrées est 0.017726898193359375 +Le résultat pour 2000 entrées est 0.11009573936462402 +Le résultat pour 3000 entrées est 0.21297407150268555 +Le résultat pour 4000 entrées est 0.38732194900512695 +Le résultat pour 5000 entrées est 0.6125597953796387 +Le résultat pour 6000 entrées est 0.9321205615997314 +Le résultat pour 7000 entrées est 1.2588913440704346 +Le résultat pour 8000 entrées est 1.573819637298584 +Le résultat pour 9000 entrées est 2.006103038787842 +Le résultat pour 10000 entrées est 2.4676148891448975 +""" diff --git a/sort/range.py b/sort/range.py index fc252ab..adf1dc9 100644 --- a/sort/range.py +++ b/sort/range.py @@ -1,2 +1,21 @@ +import random + + def generate_array_of_number(array_size: int) -> list[int]: - return [] + """ return an array generate number randomly between 1 and 100""" + return [random.randint(0, 100) for i in range(array_size)] + + +""" +Résultat : +Le résultat pour 1000000 entrées est 0.49683332443237305 +Le résultat pour 2000000 entrées est 0.9791500568389893 +Le résultat pour 3000000 entrées est 1.5108468532562256 +Le résultat pour 4000000 entrées est 1.8603689670562744 +Le résultat pour 5000000 entrées est 2.314495086669922 +Le résultat pour 6000000 entrées est 2.7060232162475586 +Le résultat pour 7000000 entrées est 3.1330814361572266 +Le résultat pour 8000000 entrées est 3.629992723464966 +Le résultat pour 9000000 entrées est 4.128807783126831 +Le résultat pour 10000000 entrées est 4.500385284423828 +""" diff --git a/sort/recursion.py b/sort/recursion.py index e7f4320..714f21a 100644 --- a/sort/recursion.py +++ b/sort/recursion.py @@ -1,2 +1,18 @@ def get_factorial(number: int) -> int: - return number + """ return the factorial of the number""" + return number * get_factorial(number - 1) if number >= 1 else 1 + + +""" +Résultat : +Le résultat pour 10 entrées est 0.0 +Le résultat pour 20 entrées est 0.0 +Le résultat pour 30 entrées est 0.0 +Le résultat pour 40 entrées est 0.0 +Le résultat pour 50 entrées est 0.0 +Le résultat pour 60 entrées est 0.0 +Le résultat pour 70 entrées est 0.0 +Le résultat pour 80 entrées est 0.0 +Le résultat pour 90 entrées est 0.0 +Le résultat pour 100 entrées est 0.0 +""" diff --git a/sort/selection.py b/sort/selection.py index 73a21d3..3e4beba 100644 --- a/sort/selection.py +++ b/sort/selection.py @@ -1,2 +1,37 @@ +""" +Selon moi le tri par selection va regarder toute la liste, +il va selectionner l'element le plus petitet le pla cer au début de la liste. +Ensuite, il recommence avec le reste de la liste tant qu'elle n'est pas vide. +""" + + def sort(array: list[int]) -> list[int]: + """We make two loop. if an element is smaller than "index_min_number", + we change "index_min_number" we permut first element with element + at this index. We do it again for second element of the list + until end of the list """ + + for increment in range(len(array)): + index_min_number: int = increment + for implementation in range(increment, len(array)): + if array[index_min_number] > array[implementation]: + index_min_number = implementation + temp: int = array[increment] + array[increment] = array[index_min_number] + array[index_min_number] = temp return array + + +""" +Résultat : +Le résultat pour 1000000 entrées est 0.45252156257629395 +Le résultat pour 2000000 entrées est 0.9531290531158447 +Le résultat pour 3000000 entrées est 1.4106464385986328 +Le résultat pour 4000000 entrées est 1.9002070426940918 +Le résultat pour 5000000 entrées est 2.3450512886047363 +Le résultat pour 6000000 entrées est 2.733344554901123 +Le résultat pour 7000000 entrées est 3.4658050537109375 +Le résultat pour 8000000 entrées est 4.107401609420776 +Le résultat pour 9000000 entrées est 4.056782007217407 +Le résultat pour 10000000 entrées est 4.458217620849609 +""" From 03f0436ada0214461556612f692d3b1b331f7840 Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Wed, 22 Nov 2023 19:15:21 +0100 Subject: [PATCH 2/8] =?UTF-8?q?tri=20termin=C3=A9s?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 50 ++++++++++++++++++++++++++++++++++------- __main__.py | 4 ++-- graphique courbes.xlsx | Bin 0 -> 5212 bytes sort/fusion.py | 20 +++++++++++++++-- sort/insertion.py | 6 +++++ sort/range.py | 20 ++++++++--------- sort/selection.py | 28 ++++++++++++++--------- 7 files changed, 95 insertions(+), 33 deletions(-) create mode 100644 graphique courbes.xlsx diff --git a/README.md b/README.md index 74f925a..ff27e6b 100644 --- a/README.md +++ b/README.md @@ -75,7 +75,10 @@ Observez attentivement l'animation de tri par sélection ci-dessous pour en comp -Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici* +Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? +Selon moi le tri par selection va regarder toute la liste, +il va selectionner l'element le plus petit et le placer au début de la liste. +Ensuite, il recommence avec le reste de la liste tant qu'elle n'est pas vide. Puis implémentez l'algorithme en python dans la fonction `sort` du fichier `sort/selection.py`. Vérifiez son bon fonctionnement en éxécutant le fichier `python3 -m unittest`. Le test correspondant au tri par sélection doit passer. @@ -88,7 +91,12 @@ Mesurez le temps d'éxécution pour un tableau de : Tracez le graphique correspondant. -Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici* +Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? +Le tri par selection est de complexité O(N**2) +Car entre la première et la dernière valeur les entrées sont multiplé par 10 +alors que les temps sont multipliés par 100. +De plus on a directement une double boucle dans le programme +qui regarde tout les éléments, ce qui fait N*N donc N**2 ### 2. Tri par insertion @@ -96,7 +104,10 @@ Observez attentivement l'animation de tri par insertion ci-dessous pour en compr -Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici* +Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? +Selon moi, Le tri par insertion va regarder le deuxieme element de la liste +et le placer avant ou après le premier si il est plus petit ou non. Puis faire +pareil avec les autres éléments en les comparant avec tous ceux avant Puis implémentez l'algorithme en python dans la fonction `sort` du fichier `sort/insertion.py`. Utilisez les tests automatiques pour vérifier votre implémentation. @@ -109,7 +120,12 @@ Mesurez le temps d'éxécution pour un tableau de : Tracez le graphique correspondant. -Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici* +Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? +Le tri par insertion est de complexité O(N**2) +Car entre la première et la dernière valeur les entrées sont multiplé par 10 +alors que les temps sont multipliés par 100. +De plus on a directement une double boucle dans le programme +qui regarde tout les éléments, ce qui fait N*N donc N**2 ### 3. Tri par fusion @@ -154,7 +170,14 @@ Observez bien le schéma suivant : il représente le concept du tri par fusion. Cet algorithme est de type "diviser pour régner". -Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? *Écrivez votre réponse ici* +Écrivez en français classique ce que vous voyez. Quel est le fonctionnement ? Comment l'expliqueriez-vous à quelqu'un ? +Le tri fusion prend un tableau. +Si le tableau n'est pas vide ou n'est pas composé d'un seul élément, +Python vas le divisé en deux en rappelant la meme fonction puis le merger. +A chaque fois avant de merger les différents tableaux vont se réduire, +jusqu'à ce que chaque tableau n'ait qu'un élément. +Ensuite les tableaux vont se merger petit à petit en restant croissant et +en formant au final un seul tableau Complétez la fonction `sort` du fichier `sort/fusion.py` en suivant les instructions suivantes. @@ -174,9 +197,20 @@ Mesurez le temps d'éxécution pour un tableau de : Tracez le graphique correspondant. -Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? *Écrivez votre réponse ici* - -Question bonus : Y a-t-il des tailles de tableaux pour lesquelles le tri par fusion n'est pas aussi rapide que les précédents tris abordés ? *Écrivez votre réponse ici* +Quelle semble être la complexité de notre fonction de tri ? Cela est-il logique par rapport au code que vous avez implémenté ? +Le tri fusion a l'air d'etre de complexité N*log(N) +car on subdivise le tri en plusieurs tri de 1 élément. +Puis on les recombine ensemble en les lisant. +Le nombre d'étape ou on lit chaque valeur est +a chaque fois que l'on merge des élements (2**(k))>=n>(2**(k-1))+1. +Il a donc k étapes ou on lit tout n. k est plus petit que N +car on prend le k supérieur ou égal à N + +Question bonus : Y a-t-il des tailles de tableaux pour lesquelles le tri par fusion n'est pas aussi rapide que les précédents tris abordés ? +Si on considère que le tri par fusion a une complexité inférieur aux autres tri +alors plus le nombre de valeur va augmenté +plus l'écart entre les différentes complexités va augmenté également. +Le tri sera toujours plus rapide qu'un tri avec une complexité supérieur ### 4. sort() diff --git a/__main__.py b/__main__.py index 53885f4..4979e86 100644 --- a/__main__.py +++ b/__main__.py @@ -50,7 +50,7 @@ def do_function(use_tri: Function) -> list[float]: # Use fusion sort on tab from 10_000 to 100_000 if (use_tri == Function.FUSION_SORT): - fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 10)) + fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 100)) end: float = time.time() timer_tab.append(end-start) @@ -74,7 +74,7 @@ def write_result(timer_tab: list[float], use_tri: Function): # print time for fusion sort from 10_000 to 100_000 elif (use_tri == Function.FUSION_SORT): - print("Le résultat pour " + str(LOOP_REQUIRED[element] * 10) + + print("Le résultat pour " + str(LOOP_REQUIRED[element] * 100) + " entrées est " + str(timer_tab[element])) # print time for fusion sort from 1_000 to 10_000 diff --git a/graphique courbes.xlsx b/graphique courbes.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..3c1197a1b13c5e7f5300c2424c567c7329e4122d GIT binary patch literal 5212 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 DU_QOd literal 0 HcmV?d00001 diff --git a/sort/fusion.py b/sort/fusion.py index d6d021f..b3ee441 100644 --- a/sort/fusion.py +++ b/sort/fusion.py @@ -1,10 +1,12 @@ -"""Le tri fusion prend un tableau. +""" +Le tri fusion prend un tableau. Si le tableau n'est pas vide ou n'est pas composé d'un seul élément, Python vas le divisé en deux en rappelant la meme fonction puis le merger. A chaque fois avant de merger les différents tableaux vont se réduire, jusqu'à ce que chaque tableau n'ait qu'un élément. Ensuite les tableaux vont se merger petit à petit en restant croissant et -en formant au final un seul tableau """ +en formant au final un seul tableau +""" def sort(array: list[int]) -> list[int]: @@ -45,4 +47,18 @@ def merge(array_gauche: list[int], array_droite: list[int]) -> list[int]: Le résultat pour 80000 entrées est 0.9117996692657471 Le résultat pour 90000 entrées est 0.9976096153259277 Le résultat pour 100000 entrées est 1.2517235279083252 + +Le tri fusion a l'air d'etre de complexité N*log(N) +car on subdivise le tri en plusieurs tri de 1 élément. +Puis on les recombine ensemble en les lisant. +Le nombre d'étape ou on lit chaque valeur est +a chaque fois que l'on merge des élements (2**k)>=n>(2**(k-1))+1. +Il a donc k étapes ou on lit tout n. k est plus petit que N +car on prend le k supérieur ou égal à N + +Si on considère que le tri par fusion a une complexité inférieur aux autres tri +alors plus le nombre de valeur va augmenté +plus l'écart entre les différentes complexités va augmenté également. +Le tri sera toujours plus rapide qu'un tri avec une complexité supérieur + """ diff --git a/sort/insertion.py b/sort/insertion.py index d7e32ac..490b0c8 100644 --- a/sort/insertion.py +++ b/sort/insertion.py @@ -28,4 +28,10 @@ def sort(array: list[int]) -> list[int]: Le résultat pour 8000 entrées est 1.573819637298584 Le résultat pour 9000 entrées est 2.006103038787842 Le résultat pour 10000 entrées est 2.4676148891448975 + +Le tri par insertion est de complexité O(N**2) +Car entre la première et la dernière valeur les entrées sont multiplé par 10 +alors que les temps sont multipliés par 100. +De plus on a directement une double boucle dans le programme +qui regarde tout les éléments, ce qui fait N*N donc N**2 """ diff --git a/sort/range.py b/sort/range.py index adf1dc9..34633da 100644 --- a/sort/range.py +++ b/sort/range.py @@ -8,14 +8,14 @@ def generate_array_of_number(array_size: int) -> list[int]: """ Résultat : -Le résultat pour 1000000 entrées est 0.49683332443237305 -Le résultat pour 2000000 entrées est 0.9791500568389893 -Le résultat pour 3000000 entrées est 1.5108468532562256 -Le résultat pour 4000000 entrées est 1.8603689670562744 -Le résultat pour 5000000 entrées est 2.314495086669922 -Le résultat pour 6000000 entrées est 2.7060232162475586 -Le résultat pour 7000000 entrées est 3.1330814361572266 -Le résultat pour 8000000 entrées est 3.629992723464966 -Le résultat pour 9000000 entrées est 4.128807783126831 -Le résultat pour 10000000 entrées est 4.500385284423828 +Le résultat pour 1000000 entrées est 0.4899604320526123 +Le résultat pour 2000000 entrées est 0.9306461811065674 +Le résultat pour 3000000 entrées est 1.527371883392334 +Le résultat pour 4000000 entrées est 1.882685899734497 +Le résultat pour 5000000 entrées est 2.3193047046661377 +Le résultat pour 6000000 entrées est 3.0640199184417725 +Le résultat pour 7000000 entrées est 3.450831651687622 +Le résultat pour 8000000 entrées est 3.9937903881073 +Le résultat pour 9000000 entrées est 4.156933307647705 +Le résultat pour 10000000 entrées est 4.718446493148804 """ diff --git a/sort/selection.py b/sort/selection.py index 3e4beba..2359a9b 100644 --- a/sort/selection.py +++ b/sort/selection.py @@ -1,6 +1,6 @@ """ Selon moi le tri par selection va regarder toute la liste, -il va selectionner l'element le plus petitet le pla cer au début de la liste. +il va selectionner l'element le plus petit et le placer au début de la liste. Ensuite, il recommence avec le reste de la liste tant qu'elle n'est pas vide. """ @@ -24,14 +24,20 @@ def sort(array: list[int]) -> list[int]: """ Résultat : -Le résultat pour 1000000 entrées est 0.45252156257629395 -Le résultat pour 2000000 entrées est 0.9531290531158447 -Le résultat pour 3000000 entrées est 1.4106464385986328 -Le résultat pour 4000000 entrées est 1.9002070426940918 -Le résultat pour 5000000 entrées est 2.3450512886047363 -Le résultat pour 6000000 entrées est 2.733344554901123 -Le résultat pour 7000000 entrées est 3.4658050537109375 -Le résultat pour 8000000 entrées est 4.107401609420776 -Le résultat pour 9000000 entrées est 4.056782007217407 -Le résultat pour 10000000 entrées est 4.458217620849609 +Le résultat pour 1000 entrées est 0.027270793914794922 +Le résultat pour 2000 entrées est 0.10175871849060059 +Le résultat pour 3000 entrées est 0.2276897430419922 +Le résultat pour 4000 entrées est 0.41335439682006836 +Le résultat pour 5000 entrées est 0.7159967422485352 +Le résultat pour 6000 entrées est 0.9541590213775635 +Le résultat pour 7000 entrées est 1.2389578819274902 +Le résultat pour 8000 entrées est 1.6056084632873535 +Le résultat pour 9000 entrées est 2.092197895050049 +Le résultat pour 10000 entrées est 2.540802001953125 + +Le tri par selection est de complexité O(N**2) +Car entre la première et la dernière valeur les entrées sont multiplé par 10 +alors que les temps sont multipliés par 100. +De plus on a directement une double boucle dans le programme +qui regarde tout les éléments, ce qui fait N*N donc N**2 """ From 584329a633fa6d284f46f8d6a39fa400993b528e Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Fri, 24 Nov 2023 07:37:41 +0100 Subject: [PATCH 3/8] fin avant review --- graphique courbes.xlsx | Bin 5212 -> 40675 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/graphique courbes.xlsx b/graphique courbes.xlsx index 3c1197a1b13c5e7f5300c2424c567c7329e4122d..48df2f7a62326f8d4b5f6e80b45f5e3400f46da8 100644 GIT binary patch literal 40675 zcmeFZWo%sSlJ9F~W@ct)W@culn3)-3#+aFzVvd=anH}3PGxK%w?wPr>XU{!Hx*v{? z=5480xAZKjSFf&rRsE`}9|dV(5EK9~00;m8078IR0Ikn_X`u1)9LEydH+*|IsifQF1ujH5tpCO8ESIQ=8~CQO;qaqiaS+;WuCOYpD45|g zMdX3XGj{O%u0f0q;f3}Kf0IqBt&^m_|@c#Qp**~9p-F%y|pI-y>NQ-gO5*RVdc#wom? zV#(%Oy9@z}Vcot&qR%N^g@Z5bn9Mz0jHfyuNEjpU`*xyN@3Mn3mv%7ROI;vh^?py< z?(KewjL5IpeUo?e0r98$?=$3^T_dTG@6m<_&nev)2l$Oq&665jVi@38B`qmvwXxZn zQXrGm?lwU1tjaYaR+ismqo*Ink@f)D;CY{~Km7#2#|JQg!hdojjj9a9x1TFApI!p` z(~ammnp!*2)BQgF?LPh|JB|PN?v)9$@_h_2p%)UbVZ#p#8*vCi(r$thKL}NP{Uz7o z8>0(Ius6EMaS&9nf`G;SI(%P8*EV>fkB15Gf3j3YBB5{-H@Q`XraU{ifK!n# z?(`$NF5E5Lr-@5>P`Gx)QdP8+=1Gri5sS@TiPRxX(WzrWA{XI=qVc8$XbsA0ZW=vS z11<>6U^QM){99AM?L3(7G5+5SXz4Oy*V7VI0^5|!W?5h~Q90`oXFWm(E zS0drs)bWo21^|Hi486Z)Jkix@Nn^f#9Q``yp_t8&9DvMI%Cq zr0=Tij4qhoKo16`g{8eNQ7ENU7oGpnDNO0;y%N@dYOO@X8D<`89-4B&t}2-=h@EF5 zwW28iIV`g;RIT*<$Z$hP!I(UjnIa`5)ogJ1QsL&OQ~k|Xi{efMK_EQ|ZE-RDBBRnj zB7<2qs6VY}7Pa}YOue&=^>Q5rpo!{@0m7*3r_d}M;f!66!dTI;L4JKPkR>+)ENQdE z7D_%FuhzE?(CVMhWn~>Qs;okvSA5z8T2wfiu=Y(QonFe>tBC;Eo7oj1aKaL1GnD0)l?U1_lv|DKT~zG~j@lR0xW}%5F-fiB z8%WSYq{U2(wnPnGN`CNEmNR6{iJ$wvTzO&P-k_Y5A))*cr*Anc4$NV3r=>{vcS9bi zu=%dlktexCoaA=OGhnFJu%Yp<4yJo*`3%+4&{~er#-y~zmjg9h3p$a!bSPAr>wV2) z7Tx_qK6y3E*EBoOPD3_=Sh~f|ndA7dZTx->6gol9SiBd?edGMOr!3Y71RqtwnKzC_ z4Yi`AovZ@g30f83exVkVkD9&Pix<{2G&ic-+2j=-!0=QIc*`HYvQ+pA9rHL{-7xxR zC2qVpFwCfD-8y!DPv3qy+atz1B7ctpk763tzy3gzkAv+Tl_5Vpc{nl{tzO}{BojpN z=yTw>6k{(KHWoyP`FUi5);|O9EH)%r>~0*1e#UW_1gA(ruIzUs%ikARi1-Y{8TNNxa^O3V)FlA+L&DtlB`wm#q7lQ+4(k!bDaz8?gtu7avChA3I!+QCWYSKPl z>)tZSiN^s{TZbQQ<0YdRV8|ca=kARdrsqBZhG#rC`~wq)*p4l0f^OM@2Q$`8uHalw zRw@L5{98Q=H0;K=S-lDkoYfFWIy^TLnBpp(jlSzSH7#;OcHfP`ts&J^H(uthuECo3 zPl5i|_{OW@?}_j!>T?hP04x9qz)$J^72^Ki0{*vf2l$ySf1dk4`_Z1XVHNzDEnYzT zfRFe@xAD`O?rtXaZZ@rfLvUef%91d@U7c}5RG}u{inT+^gl69C!;I`aE;P=7yIW_f z5=A2;2GHuPENg`~-`s2jeT{3NbvdD-U<8OT_Vsdd4^TtK7n-}psEZIKg;D&VAVmY? zimp59aV&A{oa-;DF|CP=tQItrtWSBb2^}_1pD9!6&5^q2hv((~s5vVyr`#Svy};FI zGa{U^fZwO~=)|k9y=RR>`hJ!g9?}l?T@&fo+!HhwK)Qf$bDU!9cgUV~`g9mr+E~{J zlS<+Hl~GL-!c=F|R2Go$`beRVlszmdbxFHeCd*Yg!*nRauBNGH@KKp>N>A*cX7FF_ zsnbH#nC;Wj=D`5~Fh0-tM<{TzFg0~{qW|;4{5vLO&S}dBF`xi!yCHuF&$%r+I4}V* zLoq&^MWq~6|nHyA_X#uqqN<+dxSw;~7?x9%}#dC&i@Ys`dN5B>2=`g+KYsuI}3nGGh1 zr8jP&B^LM`Q%6PqiKJ@r0(jU??dI$^)DBW%)6tRri)3ksc4%___#@!polIIFN z&ohUyyaqz|^Q6E$|Dr-5LdTx=^Dev;+%XM*%mdu>R)!snoWc*^$i;1*m(zn!oV1IX;! zWDoB84e|Z_K^VB%F_G4wA!v+7{QUvlb59%`PwJS;uPaY2{82Z6_L)b93HytZl#gIr zAPw@q+E;f}h!MxYD4@<H^)K(ir#%UA&Y%G_MV%*yU2O6m;?^1-&?aL@& zla8bTF8>L-A5xJy5|M-o`~pT7nzMIv*NtJ%ZULPO0pol7UWr1dw3R!AY8{867+%v1#9bORy^YCX{Lh!oY)!o_1;KEq9K_-$p< zP4AHu?gmDqHEN*Z1{NYXQRjTvAeyP|^HL|=kmO(mhiEd7_P9H^aREu>w2NZ;L|@R_ zCErDeaPj>4h<|1i8vX;~wofkE0Q+yX#`2fer0ohA5CFElir(OpFZ$cl!9dEi>Mgt~ z%55J`QwcS$f*P~L8;|{J2&L++=oCp22GO?0w;de1Qh;oFG^$m@3nafHQWRrXtC7CH zX@N6GRTh-z2~ksAacg+f# zzX!8m_9X!g@3WWsR2zQqx{mQ-(>@GZx(x}1n*a>NvG;q^ZU?Vbf^MIr)nW#pf!2Mt zhGWmh%U2^3&G!bS)#;*3my3cVrUv%+h_@`9zNj1YcoK6l?TxnZlo7&%v1{f8#8J6f z(>HZSMJX8Tr`iB>s&_r9nX{3IDUEAcYtP=$Ez@gQJE_-;JSn@1M_VkB@1nScBl%GE zmI|(5RBryr9a*R6B4=TCwGm5Jx_m{2PMx76%F8TwoKxq`)OfW9Er7{ zcf5dlFL3f_$Qb1ukpG9>IL|6V1u?+*?^H<8D`?wP72I2{@rnfV+Vn|vyf;uH8(pKl zcZ*YAU9nD`_~;C6r%b8Q23d%rcI|S*^{!V!_;UR$*eF3!IWvXQlOyFP%uzib)@Ld- zsV}SpNsFhU#I2Fe>p?ORJC-OLQ;H-Vj@pwLF�WFo#RoHrja`g~KCUU={QsuET; z%PBLHI-2^!V472AE_G7FuP4_@L)ciBb2btTx^m>^(eFR5`~QHwPoF4ga(>2^oBuwx zu>P_4L|MCC0))^D>N7uqbzJM8g)ycjTBOmdYgTKvQy8(vD115u_zPAaFGk{$Y7?a8 zAhQhJH;hY4GYOB}{WF4%=2lTfbj1Kbf1eV2Wb<*IkN^j3UKkGnRA{>bCqu8ea`FzpM6A(Ng;y z)cWZp_q1Q|BN&Muj4ac3fL;$d(L5E|fnop0!yhYho>#Q(V}JnLu2A6>Fz)tGtLJe64=9B#Gz1c%vRpI9 zBEmx4Dp2Gt5J8P>R;e-{b6-R{d=XOaYpFisMB-P)G?tC8eM&uT1mOsGkqWR<#HFV* z(g9T*xrGsS;>UbJCGZt)G%@oLu%(oFk!x^!aLy&Ba?Ug{0q|oY<8w zjn&e=r>MZhl-!Jl3`pR)D^ie<)`#->l9vRAWpOBt|EvrIY4c3%S%~RX*qC`zTxhyf z>%Mn^gPY}ado(`t6zOJkjB7{-A+6>6q%-nh&tznrAfx>ry^}kA$xEonB$h-S{dox}sJ`A;u8Z&&k#Y`O0R5Pa_Gv5An_a#!vAW(k8RQ3w`>VrPx>u1tS-4Ez`rAzHq4t6Q+e zSXlVrsr%OpiLC+&iO0PCl-nHrcKgn+O-zJT?88`&z;7udra-%W5!s3I@M?)*f*A9w z)Nfb<`&`xf7fa8L-}qn!3J@z<8V43NYn+2%zWC49z-@GR)@U_dhQ1%CPn;?E(6oaU zJqNMA8cc)IYq`TpUF~4;ow9KAYIlJZJ+5MP>RCMmwiW3I5lJQVu{u*$s{R;Ts3t%b zYtFhf!+<&dCgTwkXsuzIl5W(C)JnNzvsov%Z{tq5E4&VbqXZizZzFRgiI`FR==+gR@DjUalbb*_Y#}4 z`Ehp?1TKH^kvUPNs_D2!k(TaA-}!NUVaI>-{=EMK9llGdgfASO?EOhThyUa3A*Cz~ z^`P4Q{;uF47N7U!S0ulm_u=&Bufy(Oc*&@c=CIg~6Pi#^uG1m#*9nqPM51Jn2!Uo{ z7kx1_d%J*A=%t<}Xgfy(O!Ujy*Cx{w-~NLH4zo_A0W|v*##O`hBY$cuy1u?X4<;A+ z$pf-;E+O&i)*lpgKc+%bR7RB{uTO)5Gx+HLD8)nHfebDpR)Q!$5OR_+}3)G|?pM`(%0g_wvDyEp^t6`)f^FC$+K61*Yoe zng^w^y?tmEHjfnX2k)QJv^kJ@&iZr|n}}^E#M{wkJpO_kF|)iQs?hdmJxi56COgGA zmYA{3Pn7X9zQJbGSX3uw2P!7zCA}GpfVjlGm0o3!!L}Q2=|exPGhMmHOcxepbSdJ- zhopC`aN1OuM3;^|9&C&B9)wHU#@bi}Mmob02Ths~Rl^YP_6bCGOvMhrWksOMhM~e1 z`C^uvqNrB`%&92`sN2Hp&1?H&6ylm#3<`SisX0hxjEo(YZ)aK+vU4V;V*-%gGXY;q zuz#zt*6Uf1RKf(|`peAYGIy?%FRoxj$X&hTb}B>*2Sv#y4sr{mHlk*>A30oclGT09a_qS+6&T_ROe}pIzpP~m^DNwQWx;9S3^;xyzCrfw8?c?Fl zFhz_Rdg}B0Q^T|k+n(J$u1@&0w-<4;8#%-uQ9tFg>1?g1P%lpSc*0)5E=;svAQEK# zXdKPev~jfxF>B0{Cf@L=_W?)6{R=v2cta(O;ih#&y~VE+olPR<_I zrcS>@aJ$-H#dZ2=KZ3{VL!*&KSV>VFae)9f3M}wtb*+5s{B{VEtWnzM3tXwDB9b%P zblPVlr@_56X67)Q5#>0b$I!hb z=ZI+e-f&+Do^Lv@q)4%hRze-j;BnE!@^#wRq>4sDffv}KB*Rzj%ZcZYmE$H~NMa0% z)WjCiuUKRNAVm!IaeahEc1Gprk5M+CZ zek%z{gfAS{1;~4HPgTt_yCxeN`SaKluk&bK7))IXYarYM$MV{GR2OzS%Y?u)f^R(r z&Xp2-IL*Pg+G?*HDuxI2NweG(5R9vODGV%_e5d%9VWab7xnp4uL2TsEe+zVcE_xPq zeO#Ge`0M(Q>!i6=A!U}e^Yvy`SZ~{;#@tPwDvT8>$(Ao`NBs_fM@dOH+HPJSW%vfo ztO;I<5HHoE4DG7n>g z!$3)~UMC6Pt56!;_9;2j4kO7X(wjEaQq;8hjqu<>JzP&SI+hi5o$0r`cjOtd8Y!Op z7W@MYG>@{QkgP;q$S283F%eT=X@Rmf1q_KX`4O%(V}^N=FgqOv4lYgbNkiDY25A%d z5g82B&g@CsnrGV-XLXaEP=?#`Sy!BX@O`B27`_FlS<~kd59#8sbkyUDgofRDxjFTf zQPY&3cLbE6cFyR1hw=NN*O^vR9XXr?aeq|$XT`pi>Ua=E%QGLA#fNdG z%ME%V-XL_J;o*^Sz4&!=5PctULCMw#kVS0kRDq>^T5y26OyG26iOH{t;>3RH1O_eH z-F+7&65{g_=pnuBFhhO;+$R%5!)tpo`3^1@i_;LYfG2v%#}c{6zMPEL&!qNWlrE>E zYN5S9R{}ntDF2X|g`uOViL$e!rLFlNwZV)DLiI8r2+VYB1H()# zgCs}}!{j%!k4^1Poiv-=n0PsyTS1e7{rIam_s_+j>v6^~%Fp7@ z+-KqbAB9#EM?<&Y7fSz+H-A#}Och1D3oQ4mBr!0S1NeCzvSV-lfva`N>U>ai} zq~)|Tma_8qhn2ww#S}?x{cZ0dH@Ejr?nU;4JaBoLa=A;Kd`%F*U6pylsuUOo0`d9Sqh*unEEQClt^7 zv=R~}d2b10@JL7nr5K&^Iku|rSOhRodo zeX89(&m#`eB`Ep*`vjcT7_|f#7?@zGc;P8{zh_rO?^~3amlAQvHm)!XAX^1a9R3#< z697z#k!4Lk^;PX{iXS+gDyW;|ZmLKsgHQ<;i69xe^-xqeCEV?mQaJQ_v{hR5OQ|sKONK#Rb+_xXc_BkXiH9b1A4X2{xETJ@xHXKsr_S2n8)r z`4&OR6}WVYX`Q{b8e!EhM`yN-ll~oz=!fsX^k`-WdtCYlV(IZjX-5c|P8O~QD}1oS z-+-K*XGczyWC?0w-WD^o^G76({OFNv!skPc(mBVRr1|SajLCAgb6h>=&8ZI^40K{6 zX*DlQ)NI@o5QfL$zO`4xqyPLlC>O`hgd>^~bP{sJow$a?LV0c2hdcQm8?p5-#n9Fc z$ZYVb6Byio7lZMq7(Q$Ge_sAUf6{ilYzUp`hkgnnK)fhTcfJ^P=ymOyC=;$hBxiZ- zTKP7tC}l;Z{hRq89erUq+R+^=HqZ@`d)pH8_AJb=X1|DC?yZy&Pw;MvO`MH>2oE(e zOlT_3F7&@Y-5bR%s}Up6A{e5`pVHc%s?XJQag7ZbHTkKSLcV=LDlp>&7hP&!ignP)Nt~Px4 zI##AmQXz`=eiJV*@Wx8IAW!9&*G^haTQb*kuvkI}K2`uZ9x1VGO?CT4*um&!q)J>z zTzOCK)eiME`v3^d+*i3lGkJIN=SLm6Q*hx)C58m_d=!w1$mrL7)6VSdysJReHELT2 zvOOXV*)08}cEprYMD?%0=Q`SE0q)@Z(!F?OY-Av{3P4zU93lZ%@J)B!ioA6h541m* zn-C@pF^I_A-4Y>N+=^l?WUw5Fb=BD$ams31Ue&kvSvBUo0cN@Zz0gL>mEM|=Gla@V z8g}<_3vo=@k4Kx%0YDf)k;Geb`_W5#3X{r?x;^t9`Xn@Ul7dUI)5182b;R|pbx4I* zk7=oIHBh*6<<{2JE|R5rPu=>66;><*LQXmaieVf3n+ByzfstQcBH+GGA2S^Dc1!RN zXKV(wE9M>o73diY75y9_)L=3vyQkBi){s%hU=rQ0YLG6q)Y5z2%rQ9=mwKWuRtun2 zVgq_WG0>9G7#2P5K-UAI<~)uAMHd2$29$zW#VhnM_Rf{54ufO-R(u8~fUQXE-rC>V zVjV04CjrE&e7xxI5l~Z^{UQ9w2Q1+kO&ZrW8=}=?yFY=0Oj9eVGRJMz+s`>9@eoh@ zh13LqkrQc}m}w>P;av4?CO1j+Cv5}JxJy^7xOWC)FPtYVMQ@zYQwt3nxQ1DKcX0%U zFqbp3m0)Wy9=ed~sHw+Z!=nYIkO!QP4C<(_tYWmnuO9IP;d@pa>+e-)FcwiDl6u#f z24_afz6?I(EWl*M@~9)o$(HJK)6o1|U2}SXFnAlQuYtJ{2ga*vOYW34$#WN*rxBag z?miC_%`46C7`{64YVf2`iA*3N+Oo>8)W)FM$44UJyfJ~tS|$PlB1^?C?N)|>2+m(d zh8~pBJwabbRvyX~7ND%NQcvlwAz4b5jj|DM97hUmW-RN5 zzYdfP7!fCDqDe<-cxutG8j-bkJPOs~qbqMwaCDo7#hu;6Go?tReVj-*gbF4U$0I*x zBYPs+qkR~cI)s*8hzRbHRiB6$qHyojQQ`)!8y*h$o|1)Mlw|weqT(j48z#6bA_ZF3 z;e#A8zTps`Otg?-^;6Bels4_DjTyr1CQ^{=VYlb$$(v2u z?A$xq!;iwX+*(bv=0*sKb;Cbm4AfF(P4|14G)#ZPBjUp_0Z#x8FUePiWWp=ta+!={ zE$XN(gZI5h)L->Z@1j$cx-<}-D=s`mP&Dglp=?=mdWX-JNSt+a*Rk;40@j(q0d_d& ziBJ}`2N7p@3!u#Y=9MNC81y}IqEn4^s*+pz69va|wF)!`-GmLTMrP3M(_(6e?1NjE z^>Hj>VXL>-9mSPLLr83--6G{}{#jVMJ(E$D25ThjmO0-A9dkAbNT=2acw@&)o3`8# zBHl$wX?)y?G9LQbHn3g&DnT)Hl5gRHQX<48e*sY0j=jpw^5DuhCaQoS=KH+ua7<=t(z1! zO7G%e)HN@9k{BbWf1J2jKBlRT^MXM7OS-eeB~ z<@FXy-gCvn>}$ren<1bN?vy{CV>UqP8Pf_7aDTO)y0?1c%uvEOW6lVjG|$9j9uUQg zDN2*8S2~;!p2m&^Bfja0mMJTY^?f)P>QRJ5RVIor(JFZg(J9r`erF&UGD_occcuie zvm;U3pQ(Pkzl$;f?W~|n;cOVh<@s8t_a6YR++7%co!!GNJ(rHo9^vs+ z{AtNK2#DP(lrsg+_I3uDs~Y5P(7+;=Opa1_5}2(Ez*U!$Om%7etFZuFt7P1w4dj;t zJP_us!CqeuQ1az!*+$iuw4)~R*;eJn8{Vx4LcrMKSY6zKZHKZZNG8vC04m&|HP+OT z5_T30U|#x6Nu+`;nI1=f$^F`9v)QR(4l2dy04Vc6i>HtPeE~k_eftqmE&Z_ha|})b zyFneW9z+{<6jD>rS;!Mrp0w~9P#F-seD*Zt**y~%GvecQ03{kF+{RiQrdWEJ6B z%5_nq5pKIxHJ8SBYvi_J%7hacA|(}g^M$_%ha}vGG)sGpCQ14V+mbNbC%f!pH@twh zV3p~K_tMaG%&4chL{U6|v@b-8?9AaItFq-n*g(;y49^3q<%@WBl|8L7q`7lhjHTBp z_A)P*HK;Vlm*HK)ET|jpcY2Vjl_Ae7W{Mqq33vRFE%Cz1@MHs;3RXZ`k|qhSWuY;) zGW99b@q41Bg&5Ils9w-)C${*HibF$1Ysww;pSbzrsM1nG<$OTjV_zV~+e68+6cOKv zI&x!FvT9spT3E=JBx}7B>DM)>@H6={Rm2M`#nmomRT#_VJE$LAsw9Iv=;e72!3X32>|=Sy(Y2RQlMtEo=D{_^+PLbspz+sO+BF__HhbZbFSf zHdx|)%`RDjzLnyaNJP!7sImmt1+4|@B({*dch$`&7HK+claMRQU0BgxzrYRW#k*cw z?gLE+eQRl~Un$CeXm3!#gHlrZ_PJvFS=d7T zi?;s_Fzl@D9G(97v%*9{+fUpUtwDMMa6lrcBI+$Zi2xfwGl>3Z@bp`THgNM9$zX_SByTYKF8vKU%h!SS#R1FzYAbp?v1?+2YXy#Rz7GwT|Si{rTCXAU;xk&1bAY}xUm5eXwDt>A5R+F%!G})7V zAL*fAwWnSN<_Z>-vK1YC<`m_ly2S8ea^x|(Qnx*RZ28_p9f#j94foy0raSL#T{Lq2 z8OHf%-cR$q3!(Z94DzT98sg557vDJf*cc!$0_VJXhtLSP~h|2;G|pB6H!MFu&ItHRDQa zcuH3*#Jve!WN6;YCqmL2uu_7!1{kMiyTTz)ryy%G6zB{T6di5Tr_cVLO`l>aH|4RZ z+K{XTC5Rbs5a6oIW-~?WM!e(GTSw*8qurUbo2iaGQK=4<+PY&>vVaq%f*`pu4_WEe zYu02eZyy)$Sp=SJb^ zQ1xzJQ{qOaRIqgKa^RkuMF#Ir+@oC{IvgxubxMq#AR5wwW5b}X{PCq5b(6O3fqN~D zKxrP33Y+UOrH1Q>hU;{Q?yN5b=)-Q8-%VZ(&6EcLph(1=G_ud=J0o zHi;hNg!ULI-O{H8yP>;~C@+p;tLS#HaLnpJzba4fd&L#MK@BI#C4aAPp}|z9KMZ3r7Sh(Y)e-G$ zJEo=o&HUYRV{58^nE#;<*jFY8zbT7&GroPE zOF(WnG1e*6j~-4rPo1716^31ZM6o7txlJrstC*5JSe*jzAAs9~^ANgpf^ijU`Ct5@ zOTP_k_w9qWV{m`K_q@Om95IU#+yz8BCv5#31K77U*x(%vNe4gB$O zgiPbZUKdo)779jR-J!$%p|Whw!S0!%)Gm9GKgbi)r}-W+`7Ey{(6k z1V~?~`dgt4dt!}KasXQ%QAC?tydtx7<^@E#C&?RFFmU50g2#gIhs#Zigp%!kcid_T<0Sy#`np?uEciLc*DZ-tn~)L8my~dxw@Qw% zLR?qHk#Z9BD!{JMk-OHDxByvd;y32a?@&*J5ppmyKw&>?ef!+|AckJ&c3za5nPb{@ zai^ufZVBooE5>qmd@U^Q$8>bfe#`pG4mH_lf$}KHBlULah+-C#;vRose)V)weyqY& zQM>phfHYN(c3>f}kt(nHsSj0GQ0RjlH_3wmn9fto?9vQ$2u!B==7ad%0@ zK<+ho>cqCr;MOc<423$*o*ZlCR?3Ue8JW&NYv^()d|noyUNE0b;fG)=K-rDVLY=rr z4^%0EngtY{RGf0-nAUQ6GyFQ9G@gqWOtlmC;(SCgYLDq5~P|6={@JvKz`tHaA$d1{bT$$b;&I zj04arvj-ZPyCJ+PIbNz{3|l_1hoHPJyWcfc)$DEPw~r=2>b4lCG|gZu=kY(+H3 zu&H*ux}_GbzDRA)ULtvlQmGWJ#-Zv7R*$x+;`0nTSZF^gTH|~YKdYkO)k{?R^w`xz zbDo+Q-LvTsG}{T5k1^kJdzk+-2j^c?asQn0{V#z3uZa9N@c#|`e*^#D!2f?g@c;2= ze*^!&Z(y+tkzGvj3H-DFJ@EhaPb!tQn9l~kPtCkv?W0wVe)QUs0V8bOrZq#L)@e9oRt0E^P zh?1e&ZZ>mzk2%$j?)%-?vr^!;Vq66#l?w z6)4}yyzs?yHu{fi0*Y!==`yMzh|KF9c@u2=Ap=`(W%JG=pDx3~eIsYqK==Yt_ne_G zOY7aKXt~it#Up(dM_zV>yLE~^Q%{c0*iQFp971|6=>%M6gluzUBG-GQpHT|Ur(3f zfeQ0DiqP+L%SV93XG|}P%3q0ARr8cB#~?e1oFjBw9I5yvT;J&ucWf7co9AR2b(-> zeGvd=mdX993bTdMkT-W4shWG?ZP&xs1`P^XM#(Bx2Wh@KVdG-T9{#G^Qu&b)hg_Lx zFIo#b(_|aBIE1hBFyC5gW=Q%MqN@n(Of({@!QGIGFPv?Krz?lUK$|&kxJUi|QgyAkbpa@A%&2pDZb@;-hRo^qj}7ty?0n18$2 z@Mdt$QbW{3BIC$v<6dpsntZ=n$S_i>3|DD}r7Q)Oap$HiKG!NUW5Q}2NM9_(jRqr6TnJ`NfJ2nw=8Gg1p2;px>QKhI+9$mQsm6W~w?Zt!QmE`Ym2aNeo3J zS65wj&4Kz=1gvXYLp=ngN~7G6@HpOZkrH(L)xBZK3QUYDJm2@1=p?YA@{*G{$1sF` zT0jxbIDe`jC0l!;DIH1JE=O)nRKGlHj&MbJK_d0@_{OJu=L#2wt4?y#-4O{Aw z4CGO?5)QFVoCKSRd=tC9os9P1LJ|2&r5MZcn;xkvjCj3-$)FX_Z3~G*dWG#*i&NF> zRhJ4?*+qcPz0o@aI>K^DkzXn;!h7StN0a+ZakOq9{;DRs)*F-J}=c3PC)=KKJT*PGZ?KcC}bB5Por4f6q&J7a1NbW z(@?hbl4L-89-rTMfle!3$*NQ!C^~{Aq}nKPg_A8rRb?(AoGo*Q7KgUo+7v z{lIM>z_@Wt;<&bMQ8uadoiS2V6~&WcHYXODQfSHW5hCt7!C?R+sC)w9z0`R4O_y87 z+ zcL$~GzMo(C{o*(6Th^C+(tarp75u`!xpBD|r$1n#a>PjAc-SZH<2(CXu?%zlgZ4>e z4J><^S@McLX+J^U#FBwKE8#coe}WxJG8wOMqE`A9W_n%G$mFz1GMLRWG8WCVv(7Kk z99ACJp)M~(7&=6-6h9uAP)jV5UF%bGLkx4lWL;R6>&cy7?B`rhv=T!!GDRej61ZyM zaCVqi0%>CUJ7f5!$okXy1UTkR2AmSZZF9s-kyG&SgB-0{!C~yrDbFFz^Z~Vb;mUD+s=pNnkxZJsA2+{Z?KZ+<67b&3=ua;QzL?vPZItiS_Qf@x4R=764gr1 zHG)j~!3;sCOf^`1%6?F@x*p_s-$#?Fm!`u-GGHgAc_2~b6&O-GezL65fP zE(%(P|4xEgLKey|+bwAxpHrx5#(KU49mh@YOz4$>S?P~t6w-uH4pkodC zhTy8NKl>zL?@@h&*;RStp_!G>?5QsZ@pPlb`AZEX@n*hp1#^|F4iHC2{WUuYY&CNAco={o+Y~ovo(>etn=3y-AZ3&dD`l)jr5(;iI%+dFf57Wy~u|9>?2|Juz# zWz9D8H}5BX^8Tb_m~I1t3%yEwISKq3xW*ujgn^y)1!=_f#a*I4CL%^-FCoRZJJF zCPqqj4U>M=1(l`-q^@6pl6ukO3@%ZZM3PLtD{(re$`_#vdRASl*bU8eo;Xa*NOXT? zFeh~enc0nv+%DLK*uux>Jj_56Lr@5z%6mIK5)dfOEhR92QkF0e0KSlZR9c#$+E@%% zryi3IRQ*}iG}2p9;NBU1?TI_EQXv+m8Sw3=66~5TGbOHBP6M9TLWMz9rXkyN<>zip z#Vd-5$Yh-}tIp3zWIa5RzXDQ&iow{w5JG% z+T0=M{FnKLo(k1BF1D@dlq#igJ*~l39@%%w0Wy^SRmk#siB>?IF1O8->jdF6MIRlK zEy6lf5e|klL$vR`Xe%;wJ^Zwd3+8>7h9oMh6TeItm?EpUpdsAz!Xma<^N>I1`Nclx z`C)#~^9N&ke$z(&Ja?-bH5z*AB@VQM}cvk+$%elm;ezY;WO+cdr9!@+@_VAD0 z3tt}Gu55Fj7GtRrC79mBQZz6bg|tE=E{Km#Ow~5STv$ZN9i>{q76UGC-q*Vntp z1vKZ&>D*XBh)MfvOVz)Cxdp@bYH19}$@R~>$f%e)?{j^l5$R3PpaMMCNSw0x2*xf3 zDUB#%sI{`IIVFfR7ui7b08P&Lf7(0iuqwB$(bKJTD4O(9|fC#^r;L`K{c?ikl;f&3JIXbffG?!gNwjd zePRf`jc_7yuAOEz(`d6a6|YBonOxb6T`I=!XI=xhi4RcCKd#3Mf{G>};z|747Kgb% z%@^Ft00SxGA81ss-`Op~mboxe>d!B!C!I-|m*52W=+t9ao_;jITh02u=WAcb(Oa#@ z3ab-Z#=Df5le5%KCE3;EP|*MnNFqY?6wyISKj^^kCo(Dx4jXu12=qJdDKtM8czZ8= zl==AaSCt7}q{v`1Q#8gQ~p$cTGeVmN_QyL`qhx9is*FD{spJ0)n#>IDb365Vg z2<3LBqr(u`eu12B*fxkq%v%v6MA1V~=D~cw*WxJ)0ZI+g>WOP7qZ5e80^NA zplFC~>mjsGXBk8}5bw?N9L(oZjO2W+*8?RCNBRN-nwrRHLfc9!$X+n4`;@`&u`(ms z4Eozpie$ns5Lhgsj??n-XJYiyiOjx(S3-SjE2Iztf%M~0Gua6GQskbk0SZW|T|!@u zi|UJzhFUY*{ZqRc)R?NPU~>Hhg_K3PoV3Q*1BXx;=Dx`_BPq^JHVon-Q?ctN7Kc^;`*7+A%N8=M4;bsO1K?+~s zaS+UEKH#7$t2uVh*Vyb#96JzecKlkD_1QB+tOUI~YhnjY&nwWpJZ{zH1KN5>z|}Y9 zPvRt2#}$q^Sm7V>>&Subht83>V`_X(y1<_UtgZXh6>o&<$a$)R6A zIY~vI2o{@zrdf1!am&JvFNx9r$Q6|!1?JIv_C`On4{>QIhJj;bkkzI0O)2lM8+v)> zMwepr9@E;y!2c-ZvDr;kpU%3Z_53ai-G{GWI7*c{XP2E$Y(!-9opc{nneTABR@rn1 zACuw*1;i9ldy@Sr0;6s75@3KZ!U7IM z?fl8}hSRsp0@t|Wf zVKytO}kMm4ow zSNDbA)!LIwU`CYxb!7a{x$Pgr`5(jiAH(?{!}-78aK0VS{xO{YFr25oLJn^X=f5}! z|1&L|ip|YQ_-j6kAFcbYP;f#RSZ{<7Zcf67+*r;qsq?Y zD2ytn(i2^SlB)p$X%aN~5MTy83E!tBM1l?6kLSw6_bR~nx(tkrXL>6!RE;G-rO*1g z8>LR_q0(IP>wM@WHlJ)6aY9D8(nH0qE6w>Dxu=Idcram1r~wO_bqU3ekpju6zN7#@ z9yljJD)#}y_QgFi2Hd<7bT2%HwhLa3ixs%8S_m87C$iBmNe}|-Qyjij&aZm$HAZor z(Zj&*^$9wE60!y!gb)7!JP7ZyELtsft;U67mmHn6ruMC9Mt5Eq5GOV79{`Ej%C>fD zP-v&#N+pi&&iNE^_%lArBYlFz*1Z}%airK63kka8u0`pv(YgKe(yGCoUh18?`3y|= z!>8z6_WDZN%-xTUYU@~ z4ncj7my#L}@X{g35l1R)6t?fp{+eNSFixU{6gwhGSt0w_Kb?C;%Pi^Hx46+Cy5ysV zIqaR}Z<7|2ybQy-ZVcz`KOE%|V2<)Q%!Q3EHK5^4FFFY{oY#3W0BE-d;TZ-mWA^Vp z2*2lhZ%Pg5C||tWQGTmge=?lmwhSuEc2V<=V`=x8ftEAnjpZB$w48IL6vJi>ZY}4k z*(q7Ty{Q*Vt?0c?W3zkR7umX(mE|eV#YMIDJ#G)en`a#4mL_9fOs0JysVY-@*+>#O z33RiYTm4|ZIxoRJFMRn8 z+7eNay7dy59J`W`HJP8+3%~G$=R-`HZ9}*btc9z*yR@3pWx?5z65j=yXw&MFlbYhb z^Tj?(d^gXa*JChP5{ENE2-`MeU;EY)Nsc!3we1GX#6ts2K$SRWuSD}WCNfJ(^GJMv z>vO?~$OwWuqmY)qZZjDr#lSa_lNhy6u8T95_QFE}<@kP$_wcxwG-x>btUb@6jLqoo zUsrw|cGaOV=c#hyaI+WuUUc7nL6LR;Q%gXVEwkWsh#Cvr~Sx(`o32Znu~*UdlTr0zMB1X~rr^&$FrokT`EyPHh7Ppl+flQ|iF zjhb%Wy5;b^j1$FoJwaSMfwbeNv2gd-*wi%>H|o=-9zOv3Ky%**lc^tA9T{uYLqO^K z2j+|X64(Fhn6KQ;{8;U9M8t%{m5zCg|OEL((WX}eYEE3Lv|v|w~l`56%}M@;xX5%C19GMzj|*e>kUEKlACpa=xZvAK#^ zvkso>hC>Qs-B;jaj5s2?iHJue5{tWyh?f$wM1F*~jE4=3h-ZfaM#LZHFDx2RE1sba zwTj<|FJLRPZYo-NP>c&a0w12PXk)0=!m&=tj=3U|86HK&K2}hWgX`1cU04Q%$D8uj zN1DWKb+NJJ>o6=IL&4m-o5@@4p52zS<4b@(3NRvGQ8*65L5xI>&QaCY%ErAfW+vN(Vww;T8It>Zv*W?z^CY_&Nb*qu&*X!OVAM$nA5!h3#QBEz zaEQbr#YiKeps(cTaesr$ksG1O?Lq4-3^f!^NGFv-QS=C>ek{_L3jZq5iuj2f>UdJS zQB1%<_lUi}dBbV<$UMsI$0%j~;|22j3(S{ztbVPs@tpTC<|9a{X=aS*pUU}B_=hft z=Inad5_DL2MCOY}u^l#(9C}X;vVR{{$q4I)0FWWzVN^mSO68IBS&E@jn&G`Jk3Y3V z3xFo=erhX*%3y{E>z~~4opcU*1(W{iaJs=pfRF`NzP|SZ5ew%}`$R4uUv|aCi`lMu zKB|0Z_9ei6E!cMJEC;txALEejf{6>VhbYvh^PTp#31VXx0bC3buSSNS&~ePC6HKc9 z06{k*9TX_40XQZmFFSj5&sAN5i<~SI-oby`OXJvcK~DQ2ecWbh2TZ%;LR#*`LE866YWj}~Fl8LL%*v!n=zM%7lVc}*3*bA6 zN$HlI`OvrLvC~%B6fLSQt5@qh)6EAz3xy$YS$o9x#`}GH+0gD)r1WFoVYR zBiPixuADE7UOlsYGqw{V3Qa!DraC~B2x|g2jxOyCi%YRq)M!#>tvXTBGkxk9QmLT& zDO1qcyHnPTXHrUS$(7Lu%f#O#+~sZWXC6uQWL)I6$JwL6V0eN`55#-8T0$H_&6BH# zPj?o*<@ak_RxLWir8Yz0gg$1ej*hyLro5)A>m3~)zX^udn5f4pRk;XGgbZzAks%u;WH7`gN6zgP4XH&za@Dx%K_-v_gMc1QMdl zG)><(1bih2KeAje<##gXC*W-trrE}-wnVvV#AIt*CpI`}Q4X;I(zLrYe+0u5-X{)= zfM+_pSS0m~j&M`Ie1J=J?4(`Gw=Q%uWfvBcf@GGFL-fg!g7=O}Dv8$xOSbyqc=M3g*_zGx zkDN>1(%{T}MIpV9sRWmpN)BXwn!3t}SLF}v*hLD7mcmJH=qUbNaj z6VD%_xe|Wh2wNzvcE~Fq7gjxTpmckX=jY(htET$Fvs*4+hbGya!U%5o(iHBR&6n3g z^uB%uyN=`{b1n?Gf#nw)>GQ=4?i7Uu-d)Rb8F&hBNO59ZV*XDtT|3&y^N1MS>Z21E zK3yr84CXsRW5OX+QB|)zwWk@JnqhTgf!8vw{*1MH{U~{JY#6(+Lvi@i;IE>Bo8%YSfmng-qG|gZ|=@NEQ3#OX3LHqMB zUvwuZuHscY568HR0_bV?N&2()^{eS8S{*g=OANVW;|oJRII~nxv;fN;R1GIMCk_^K z=2){3!yYQPjWk#FW_L%iG<}=LUla+o&lW)GBY98=T`ExY(kIMl{BSppdn(jeeMRe{ zO)rMv+Oqcr&olfZ>4}z3(^lQ0oNu1XA5s_1VgVD2wgk}{NO{A=KSZRrN>N}tG-;dz#q>QZnxZT>n^<6v1&)T+=por<^_d%l(68@0Uu${mKW`=K? zE-0|n^Mxt4Eq+jrMw||flQ}VTaOR<1-p{MkvK!KWA<%AcrO`6M?YU@>DF;}9|NO;9 z%-o2;?tnd$=u4GZ?9>cw3Tpy=iht%sSDz0OCzf?FAYE8+h=j|(GW$^gmLhdkc2K}5 z3>K2diy~tRQ8v<{S|@MB_0hElqn5H<%LW-g07>u*P*CzbGH znG?tfFI*%U22u^f=q)F0uU8-#l==Ogw1|~l#38~|7Eap$pm_q!r5pfV< zbh){%cPpgZZ~qsv!edty^ELxNoDLYnNCy1*=K?=JYe(Id`MG@@Z!1Ry#SGje%?#QN z*hM?G9rZwqE6^4BPJ0BIWPA~5gHgR#XlKV55HN3JmV9MeFwI}6I772PpYcKoholGJ z4t~<2fxY`P4h)quj`*%by9~;O$GbO!?1p{vGpPQe1)LMZg;*|9RqGZ)Nqn*W$rIg( z%1KqqkOSB}N}IV;Z%%vt&Le2#)P#AzV2H4VY+Yt;16-J$zpp%rljf&Sh&t^VV8t*J zmkdnUefS|nX{9H7L&{sV^rw`;SD`qwa!mkWuZRCr?{7~t-S)mTZa@xLP{(gq;=S+^ zk0bzE$b6mAe6*aIh=kmhaD-cN3)0iG%>W~V(&5_*@!5fyd(D-m>5+f15h-$+t-zx* zEYc_(UDT!~cm?|CfHcgUU`$r)3qaZc+o0SAnmkKQF_s~6yo3+?i>sgrqYPH1ZImK< zIZI8k_zYiHvRCC6JF;g3emo+sLm!Gy{qS}uXiK5v)`m=79Un15*DhTh)tYN(IxUdleEtG9j}O*Ak?esG48 zH8(+AKI+nb{+>fef{C@NfKzAEcro=8S|8TzbHniX&uH>4h`=%sH=2=Fz;UA)FMrVt zX`p6|MHd<{I2kLb7PZi--QD|C+5|j3;8Cq?ps?KWBF{LCsMCi<7+Xo{Elt ztC%jesa7`1E(@4`is==t_|Z+k$NBU1$wN*D(q)Qb6Q`6#KE3#j z&`=B`Dfhaljuz^n<`GJzuiA7bTI9TDnqQk;xN15ZoO){o!7C`VDK+gjH-P7q3pt=; z$ZbBNOjz=+Td&EmyyjyG-fQgsG3P$^WQJ`-HqU$Q<8QIP_l8Ejm^eX04)@glU}d}- z&CXEXYGFH>W=kHqgI1LQoT3o&MIyc|7C%m6!d__}LSpRsx{$WW!PnQZhfKi`{CIGj zPmpzU(ku0vp~*xW<#qpMMVm2fO=aRY2>CacHqw2R&~*H*U3NjT@Xw|gc>q1duPfHS z;pYqp#b>_C+a=cdL>ET&pqdnCjaf=)CfPU`gaDE^fpbo zswCk=#wd-D^_VxAq*MM-=o`WI>{<=*!DAmxIcKlJG;?BvtQEL-iB*XWO?>N(dmqja z9%-qyAXX=+C>%uXn+0mHreckyp~knKwQsffX+I_s?vf-r3{phsPBITmM(2<{@UCsj zd^#AP+Y|2micH)(o#XtCN9Zou2qD=B5$OSMZw<9Cepl{}@9ooY`^|Y=`X*lyu$WKw z*5;@7W4Gduxxs-XLF1}gkhzl;10wpEWF|-Q7~YN#l;59+zg;Q31j zKV0k{cx0b2TNen25$Bh~6LoQUX=Zy)X@0!ycpeDB95p$>PPB62dX$nL>qkxJp;+P9 z#L+m%Z`z}S+4xF{aKLFwlldOQ<0HHWP*M^BG|Gl^=uOc|gdxF}s`M#=$P5b_>f>_*D-$GZ%3s-H1SYin+>aNgsy@{1J}T2kK(819^L%uAK-OpS0iUbk3T z3yp`9L`>}XFvSw;E!$hxB?T;g{Azq;+{qbTC}@dH8N+8UBli5&ORcCxO`}fsY2aTR zvx8{ey-9Xie2(}Zojj$eC!%}X-M2XI$#-nKtBZOdxD*fqa~2|WFB0aoHmCX7-){J+u7?N)*CJI<_x(=fp95R+LJUD zI*>PG-&WD1Fx{m`%kv|OT6QQyU2dmRnm-xNgqpz7!*T}KYJ3yXxh=|71eM35sO zAuotc&bLw@&)E=Mnp34Qb^id!=p+={y`OY_J?|>i?onw|6wR8h67iiw zvJ^|H>faiYZ_SOnhGbaL|K1__zR2O+d!Sq>K$Gm+-`s_g8taba7>DtWdzctnq0QSH6{m{&vKnCeerrOh*~+g|o=E1HBe*T%sy ziJiVfArTZu8i>ECR} zq%LBNVN?=Brb9}9anZC$D5kC@k)$BLK>0ZB}$DbwE!IU-AX4QJ{L;lM%4TSd-_inrB;SDqu0hFb=}C4DQM^Wxv*cFycfGO^5g(q&uV?-ktt2 zd4zN>Ek(G0e!^k#+o@nEsrE3#W|?&8B<>Xrs#@H1$rGE4(gQm<6rKX^D7bx#Ey0XQ zl>yhSd27>eMeIp|D;AC}c`mb=#oGbz-dC+&YN*L4zHl!v{AkOwo~DU*IJdLIKjW(T zMf396(N0wR-H(QiO4#_{8WnFNE&do6ep#rB{ueJ)bKH7P{-ZX4mguFitvB^RU+e}p z2aYr=j<(_D$)N@cR_L5SbSYx60kr{t05J3}GJmV#r#9?4BkOuA;&dwtPu6BrYZ7Uv zvwLaJxeR5$PT|BGieslIx8EQpj>g?D7?1tL7*?D>O|YUgikv%@8W8sav(p2g3to96 zg-WK&=T(^fT%CN1FI)B;^Jn+r*r9f!@#m7Cy}IuYn&J>i8*!1us2}U6}Z`GX|T(ZtDYZDE#-Q!{x&y$KM(me$|H7 z8-rG4H{i#OK^q<_F{UfBrg{jSCwg1<20Wx$5?r-S=Xsis1`I9ct{@0ER<;YiIO~BET9+;Vz>gVFo z9#{j%*~C%V#M$|_#thhd7Dhu0+pUBFsYL~>?jIJHZw3wN5o}Fau+$Clr5C&9q{p}u zyMhX^Iclh%2xU`J$j0I03$8G9z^5+L>zqT>xKQx<5njzrkq%qa6LfNyPjA9g-sq1HQyvz5uwOZ1B4GbCe;F8OJ9Zv=r4sJJ zpYO!jhWGB`xu8v@>^hd{x@Yuu@x>NiO(Wpb0!GBSqv-*lcU`(rmNFtS$`t;%~RfA03=}?O%nskTv&fPaK znxWJ%cd6(m`pY#+a_~>%CY6)MHay}se|%S9*B5WW?I@chE&!MQKPv@mMZXmfJ=a59*`#7sT% zGn|zK|7YcQeR>4u%XWHSSn_4FDTg&$ zNqV-()3~M0==$bBg(?C+{t--&9~v5zkN^S#_hfshal2ugDrLpg zvJ^<@LMkNYunVSJvQ`og`d##VV-{;I=s4{Ub|S@VYSQFfRPn8W6-fG7NEK0GNi+t6 zwWCK2GegL*@T4gUO&AO!kM)Pin_8q&rJj|2)0jl6#ny)^B$sU)$15vUMeKS}mYqxK zh_e1McLMuu`M7i`^+f?NPfGnzd%^bk~8qp`~Y0J5y@T0U+ylnbq z`l`01*!SijN<_hoyvY%vvTx~{Q>ud^O`k*>-A5t_q&bj4ZZ>-iYKJ-WI9_e5Bz zjWaXefR#j&_tLze`E-taT#i%jLY?(q&n>-dgwxLlbLe; zq2==pvVKxpb(+nGSX&5jv;8N#9h9dyPz0g)iS||co*gco?&F^3D%uLuiUr3xiW0U{ z4tkSf?Rk?r(D%=tXU;irk~AO{m$=aObcL4?{iruze!hUK*JmUhluw;wQ6>}{ko9Ra zuR7mCfYFYc&wW7|pqYpLl5!td3r1Ye==dzV6^TzC>6Hm`BQjhJE3Vg0c$pdwQRs`( z#3+(e8j?%_iZG78AZpQ=5+e5VSkZ$BkrvZ0sMwF{Zbx7YTDJ&KI;iZvOhl4>x6QFctNI*jKU) zrg;*SYRb9^U=0j8V=B4;3NDE&`g1?rM_rxH-ai6LRbP(3&d^y?bX{MXW9KBisxbIK zaKgq{pYJP^eAqaCkUh1d>KDGFuX&DzCSN9;mw?_>Owhgl*Kb%)* z-QL7W=jLfpkp45^ttvCwA@JX2fDoX`@XJda=-l|Zb#!YHgI~z~RogEb_{bpv8v^|B zUtZQgm;JxIgobu@R(E~s(`SAjXuxN72lyETzg!AjeE=H)y!ht_yV^Ng{SV^KMzolV z8a)9vV*FoG0w9ztuyE#|U6r>^%GQ^0G{fhhbGx9#|!!VxzG>Tcc6-~{m0Iv~Ob{jUU2 zB^_`Ac)1D?A)Dn_f)S{A1vmn{f&&OK%zBFe7sl;lgx?FJ z4Y(QvD(1h$c`J-N3BMOcoZzp7pTf8k0iN9w)Qwi5JB4xQlM0^25JVvs{Zm73gmEX~ z_rj=_`IT@hj5`Ux7lyy$uY{k%xDx@M`UBLBDy2Jxap!;op5g&SK~?=zLvDm|C*k+P z*wp%!a4U>E3BMOcqyDdipTf8k0e+kd)Qt^;JB4xQxCwr22SkxD{!>G4gmEX~_re&q z`jv1ij5`Ux7e$_6F+4ki#wFW=g!B$()!#Q8(aY26)U4i1O??IOXR| z3u4_l&w_`+fPiW)e*wH53GM`f$Bux2j;? zSZ{F3FM_+hm3KA^+$9MDLi^kT|Cj@Q;(nbL?*xLo`9MGjU|a%dF#m}IbNYen3AmFC z1Vi=vi`M=Awt{<}KtN>w-?Z-cFmSgG2u2ui3;X3+_~mBY4l;Mj4%`z00^$e$rggtp zIB+)t2u2h17qa_(>%jNsK|qS&-?Z-cFz}6S5bW`bzi8d>6&ZZD7zAVq`AzG74+Gz7 z1;GSE|DtujzZu~BmmuKNuv;M5?j;l0``g`2@TcR?n_?g&1jN$_2#9~%A_Kqt&-)U; hUVaw!%jN&trBIND1zH~v5UjwjFF@PnF!tu%{{c1@j&uM3 literal 5212 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 DU_QOd From 0975da46d0e790b485ff3d4450f095d4fedcd5ec Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Fri, 24 Nov 2023 12:30:48 +0100 Subject: [PATCH 4/8] erreur corrige --- __main__.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/__main__.py b/__main__.py index 4979e86..71780c0 100644 --- a/__main__.py +++ b/__main__.py @@ -50,7 +50,7 @@ def do_function(use_tri: Function) -> list[float]: # Use fusion sort on tab from 10_000 to 100_000 if (use_tri == Function.FUSION_SORT): - fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 100)) + fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 10)) end: float = time.time() timer_tab.append(end-start) @@ -74,7 +74,7 @@ def write_result(timer_tab: list[float], use_tri: Function): # print time for fusion sort from 10_000 to 100_000 elif (use_tri == Function.FUSION_SORT): - print("Le résultat pour " + str(LOOP_REQUIRED[element] * 100) + + print("Le résultat pour " + str(LOOP_REQUIRED[element] * 10) + " entrées est " + str(timer_tab[element])) # print time for fusion sort from 1_000 to 10_000 @@ -86,4 +86,4 @@ def write_result(timer_tab: list[float], use_tri: Function): # main(Function.SELECTION_SORT) # main(Function.INSERTION_SORT) # main(Function.FACTORIAL) -# main(Function.FUSION_SORT) +main(Function.FUSION_SORT) From 7ab188afec53f34e35a7969220a16867a12ceaec Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Fri, 24 Nov 2023 12:31:20 +0100 Subject: [PATCH 5/8] erreur corrige --- __main__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/__main__.py b/__main__.py index 71780c0..53885f4 100644 --- a/__main__.py +++ b/__main__.py @@ -86,4 +86,4 @@ def write_result(timer_tab: list[float], use_tri: Function): # main(Function.SELECTION_SORT) # main(Function.INSERTION_SORT) # main(Function.FACTORIAL) -main(Function.FUSION_SORT) +# main(Function.FUSION_SORT) From 83ab94213661b66c8213fb1ae041c42166ce0404 Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Fri, 24 Nov 2023 16:28:38 +0100 Subject: [PATCH 6/8] Fin avant review --- README.md | 3 ++ __main__.py | 106 +++++++++++++++++++++++++++++++++------------- sort/insertion.py | 7 ++- 3 files changed, 85 insertions(+), 31 deletions(-) diff --git a/README.md b/README.md index ff27e6b..c326b78 100644 --- a/README.md +++ b/README.md @@ -218,6 +218,9 @@ Bien que tout cela soit fascinant, Python possède sa propre méthode de tri : ` Une dernière fois, analysez le temps d'exécution et découvrez si python fait mieux que nos implémentations rudimentaires ;) +Le tri sort de python est environ 100 fois plus rapide que notre tri fusion. +Sa complexité semble etre N + ## Pour rendre ce TP Merci de faire une Pull Request vers ce repository. diff --git a/__main__.py b/__main__.py index 53885f4..a626ee7 100644 --- a/__main__.py +++ b/__main__.py @@ -14,9 +14,23 @@ class Function(Enum): INSERTION_SORT = auto() FACTORIAL = auto() FUSION_SORT = auto() + PYTHON_SORT = auto() -LOOP_REQUIRED = [element*1000 for element in range(1, 11)] +# We create a loop where there are all the element we need for test our sort +LOOP_REQUIRED = list[int](((element % 10)+1) * 10 if element < 10 + else + ((element % 10)+1) * 1_000 if 10 <= element < 20 + else + ((element % 10)+1) * 10_000 if 20 <= element < 30 + else + ((element % 10)+1) * 1_000_000 + for element in range(0, 40)) + +TEN_PART: int = 0 +THOUSAND_PART: int = 10 +TEN_THOUSAND_PART: int = 20 +MILLION_PART: int = 30 def main(use_tri: Function): @@ -29,61 +43,93 @@ def do_function(use_tri: Function) -> list[float]: """do_function make ten time the right sort and return a tab of time different for the number of element""" timer_tab: list[float] = [] - for element in range(len(LOOP_REQUIRED)): - start: float = time.time() + for element in range(len(LOOP_REQUIRED)//4): + tab_generate = generate_array_of_number( + generate_index_tab_with_sort(use_tri, element)) + start: float = time.time() # Generate a tab from 1_000_000 to 10_000_000 if (use_tri == Function.GENERATE_ARRAY): - generate_array_of_number(LOOP_REQUIRED[element] * 1000) + generate_array_of_number(LOOP_REQUIRED[element + MILLION_PART]) + + # Use factorial on number from 10 to 100 + if (use_tri == Function.FACTORIAL): + get_factorial(LOOP_REQUIRED[element//3] // 100) # Use selection sort on tab from 1_000 to 10_000 if (use_tri == Function.SELECTION_SORT): - selection_sort(generate_array_of_number(LOOP_REQUIRED[element])) + selection_sort(tab_generate) # Use insertion sort on tab from 1_000 to 10_000 if (use_tri == Function.INSERTION_SORT): - insertion_sort(generate_array_of_number(LOOP_REQUIRED[element])) - - # Use factorial on number from 10 to 100 - if (use_tri == Function.FACTORIAL): - get_factorial(LOOP_REQUIRED[element] // 100) + insertion_sort(tab_generate) # Use fusion sort on tab from 10_000 to 100_000 if (use_tri == Function.FUSION_SORT): - fusion_sort(generate_array_of_number(LOOP_REQUIRED[element] * 10)) + fusion_sort(tab_generate) + + # Use python sort on tab from 1_000_000 to 10_000_000 + if (use_tri == Function.PYTHON_SORT): + tab_generate.sort() end: float = time.time() timer_tab.append(end-start) + return timer_tab -def write_result(timer_tab: list[float], use_tri: Function): - """write_result take tab of time and the sort for write them to user""" +def generate_index_tab_with_sort(use_tri: Function, element: int) -> int: + """Generate a tab with different length for different sort""" - for element in range(len(timer_tab)): + # Generate a tab from 10 to 100 + if (use_tri == Function.FACTORIAL): + return LOOP_REQUIRED[element + TEN_PART] - # print time for generate array from 1_000_000 to 10_000_000 - if (use_tri == Function.GENERATE_ARRAY): - print("Le résultat pour " + str(LOOP_REQUIRED[element] * 1000) + - " entrées est " + str(timer_tab[element])) + # Generate a tab from 10_000 to 100_000 + elif (use_tri == Function.FUSION_SORT): + return LOOP_REQUIRED[element + TEN_THOUSAND_PART] + + # Generate a tab from 1_000_000 to 10_000_000 + elif (use_tri == Function.PYTHON_SORT): + return LOOP_REQUIRED[element + MILLION_PART] - # print time for factorial from 10 to 100 - elif (use_tri == Function.FACTORIAL): - print(f"Le résultat pour " + str(LOOP_REQUIRED[element] // 100) + - " entrées est " + str(timer_tab[element])) + # Generate a tab from 1_000 to 10_000 + else: + return LOOP_REQUIRED[element + THOUSAND_PART] - # print time for fusion sort from 10_000 to 100_000 - elif (use_tri == Function.FUSION_SORT): - print("Le résultat pour " + str(LOOP_REQUIRED[element] * 10) + - " entrées est " + str(timer_tab[element])) - # print time for fusion sort from 1_000 to 10_000 - else: - print("Le résultat pour " + str(LOOP_REQUIRED[element]) + - " entrées est " + str(timer_tab[element])) +def write_result(timer_tab: list[float], use_tri: Function) -> None: + """write_result take tab of time and the sort for write them to user""" + + for element in range(len(timer_tab)): + tab_generate = generate_index_tab_with_sort(use_tri, element) + # print time for function use + print("Le résultat pour " + str(tab_generate) + + " entrées est " + str(timer_tab[element])) + +# A décommenter # main(Function.GENERATE_ARRAY) # main(Function.SELECTION_SORT) # main(Function.INSERTION_SORT) # main(Function.FACTORIAL) # main(Function.FUSION_SORT) +# main(Function.PYTHON_SORT) + + +""" +Le tri sort de python est environ 100 fois plus rapide que notre tri fusion. +Sa complexité semble etre N + +Résultat du python sort : +Le résultat pour 1000000 entrées est 0.10117459297180176 +Le résultat pour 2000000 entrées est 0.24679017066955566 +Le résultat pour 3000000 entrées est 0.31505799293518066 +Le résultat pour 4000000 entrées est 0.42998576164245605 +Le résultat pour 5000000 entrées est 0.537330150604248 +Le résultat pour 6000000 entrées est 0.6411576271057129 +Le résultat pour 7000000 entrées est 0.7325379848480225 +Le résultat pour 8000000 entrées est 0.9010059833526611 +Le résultat pour 9000000 entrées est 0.9867992401123047 +Le résultat pour 10000000 entrées est 1.0364351272583008 +""" diff --git a/sort/insertion.py b/sort/insertion.py index 490b0c8..5316b66 100644 --- a/sort/insertion.py +++ b/sort/insertion.py @@ -6,7 +6,12 @@ def sort(array: list[int]) -> list[int]: - """We make two loop""" + """We make two loop, + then compare one element of the second loop with element before, + if it is smaller we permute those two elements we continue compare + with the element before until we reach the top of the list + or we find an element smaller. We do this the length of the list. + So We insert one element between other""" for increment in range(len(array)): for implementation in range(increment): if array[increment] < array[implementation]: From 2b8d2e38352262ae47b783cd9576a231c8cd6699 Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Fri, 24 Nov 2023 16:29:36 +0100 Subject: [PATCH 7/8] Fin avant review --- graphique courbes.xlsx | Bin 40675 -> 47026 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/graphique courbes.xlsx b/graphique courbes.xlsx index 48df2f7a62326f8d4b5f6e80b45f5e3400f46da8..df4d0965cb909d7925d112171c9c63ea27597239 100644 GIT binary patch delta 7919 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 delta 3941 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 From a857e1fd6f9288db4b35c2ec7bfbbd405891afab Mon Sep 17 00:00:00 2001 From: joffrey3 Date: Sat, 25 Nov 2023 16:49:35 +0100 Subject: [PATCH 8/8] =?UTF-8?q?tous=20les=20retours=20ont=20=C3=A9t=C3=A9?= =?UTF-8?q?=20corrig=C3=A9s?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- graphique courbes.xlsx | Bin 47026 -> 47031 bytes sort/fusion.py | 29 ++++++++++++++------- sort/insertion.py | 58 ++++++++++++++++++++++++----------------- sort/selection.py | 32 +++++++++++++++-------- 4 files changed, 74 insertions(+), 45 deletions(-) diff --git a/graphique courbes.xlsx b/graphique courbes.xlsx index df4d0965cb909d7925d112171c9c63ea27597239..840f936c5223410d19b9d9371065be6d09584374 100644 GIT binary patch delta 4993 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 delta 5002 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 diff --git a/sort/fusion.py b/sort/fusion.py index b3ee441..ba67867 100644 --- a/sort/fusion.py +++ b/sort/fusion.py @@ -17,22 +17,31 @@ def sort(array: list[int]) -> list[int]: return merge(sort(array[:len(array) // 2]), sort(array[len(array) // 2:])) -def merge(array_gauche: list[int], array_droite: list[int]) -> list[int]: +def merge(array_left: list[int], array_right: list[int]) -> list[int]: + """We can erge two array together by forming a new array""" """merge take two array and create one new array we both of them, at every loop it takes the smallest number between two arrays and remove from the array. Then we return new array created""" new_array: list[int] = [] + + # We loop until the new array have all left and right values while (True): - if (array_gauche == []): - new_array += array_droite - return new_array - elif (array_droite == []): - new_array += array_gauche - return new_array - if array_droite[0] < array_gauche[0]: - new_array.append(array_droite.pop(0)) + + # if left or right list is empty then we can had the other + # at our new array and return it because it is sorted + if (array_left == []): + return new_array + array_right + elif (array_right == []): + return new_array + array_left + + # if we suppose that the right and the left list is sorted then for + # have a new sort we just need to compare the first element of each + # list. We don't forget to add it at the new array and remove it + # because we add this value + if array_right[0] < array_left[0]: + new_array.append(array_right.pop(0)) else: - new_array.append(array_gauche.pop(0)) + new_array.append(array_left.pop(0)) """ diff --git a/sort/insertion.py b/sort/insertion.py index 5316b66..f6f7d85 100644 --- a/sort/insertion.py +++ b/sort/insertion.py @@ -1,38 +1,48 @@ """ -Selon moi, Le tri par insertion va regarder le deuxieme element de la liste -et le placer avant ou après le premier si il est plus petit ou non. Puis faire -pareil avec les autres éléments en les comparant avec tous ceux avant +Selon moi, Le tri par insertion va regarder chaque élément de la liste, +les uns après les autres. A chaque fois, l'élément sera inséré +entre deux autres éléments dans la liste déja trié, +à la fin ou au début de la liste. On décalera tous les éléments triés +après la nouvelle position, de cette nouvelle position +vers l'ancienne position de l'élément """ def sort(array: list[int]) -> list[int]: - """We make two loop, - then compare one element of the second loop with element before, - if it is smaller we permute those two elements we continue compare - with the element before until we reach the top of the list - or we find an element smaller. We do this the length of the list. - So We insert one element between other""" + """we sort a list of int by insert each number at their position""" + + # The first loop represent element who search to sort + # and who will be insert between other number for increment in range(len(array)): - for implementation in range(increment): - if array[increment] < array[implementation]: - temp: int = array[implementation] - array[implementation] = array[increment] - array[increment] = temp + + # The secund loop go from the element who want to sort + # to the begin of the list + for number in range(increment, -1, -1): + + # if the element size is between two element or + # if we reach the top of the list we insert it on list + if (array[increment] < array[number] + and (array[increment] >= array[number-1] + or number == 0)): + + # We remove the element at increment + # position and we insert it at number position + array.insert(number, array.pop(increment)) return array """ Résultat : -Le résultat pour 1000 entrées est 0.017726898193359375 -Le résultat pour 2000 entrées est 0.11009573936462402 -Le résultat pour 3000 entrées est 0.21297407150268555 -Le résultat pour 4000 entrées est 0.38732194900512695 -Le résultat pour 5000 entrées est 0.6125597953796387 -Le résultat pour 6000 entrées est 0.9321205615997314 -Le résultat pour 7000 entrées est 1.2588913440704346 -Le résultat pour 8000 entrées est 1.573819637298584 -Le résultat pour 9000 entrées est 2.006103038787842 -Le résultat pour 10000 entrées est 2.4676148891448975 +Le résultat pour 1000 entrées est 0.028821706771850586 +Le résultat pour 2000 entrées est 0.16448330879211426 +Le résultat pour 3000 entrées est 0.3654301166534424 +Le résultat pour 4000 entrées est 0.691014289855957 +Le résultat pour 5000 entrées est 1.0119526386260986 +Le résultat pour 6000 entrées est 1.4506659507751465 +Le résultat pour 7000 entrées est 2.0582830905914307 +Le résultat pour 8000 entrées est 2.850092887878418 +Le résultat pour 9000 entrées est 3.4401211738586426 +Le résultat pour 10000 entrées est 4.12743878364563 Le tri par insertion est de complexité O(N**2) Car entre la première et la dernière valeur les entrées sont multiplé par 10 diff --git a/sort/selection.py b/sort/selection.py index 2359a9b..b6a5b23 100644 --- a/sort/selection.py +++ b/sort/selection.py @@ -6,19 +6,29 @@ def sort(array: list[int]) -> list[int]: - """We make two loop. if an element is smaller than "index_min_number", - we change "index_min_number" we permut first element with element - at this index. We do it again for second element of the list - until end of the list """ + """We sort a list of int by select the minimum number + each time for build the list""" + # The first loop can permit us to search the minimum of the list then + # we sort it and we search again the minimum until we reach end of list for increment in range(len(array)): - index_min_number: int = increment - for implementation in range(increment, len(array)): - if array[index_min_number] > array[implementation]: - index_min_number = implementation - temp: int = array[increment] - array[increment] = array[index_min_number] - array[index_min_number] = temp + + # We define the minimum at the increment index + index_min: int = increment + + # The second loop check all number between the index "increment" and + # the end of the list. Number before increment index are already sorted + for number in range(increment, len(array)): + + # We modify index of the minimum if we find a number smaller. + # Each turn we search the minimum of rest of the list + # that we weren't sort + if array[index_min] > array[number]: + index_min = number + + # We permut the minimum we find with the increment who represent + # the begin of the list we already search + array[increment], array[index_min] = array[index_min], array[increment] return array