Reorganisation + function to generate graphs without cycles + division of modules in multiples files.

Author: maxime-bc

README.md

@@ -1,5 +1,5 @@
 Pierre BRUOT et Maxime BLANCHON
 # Théorie des graphes 
 
-### [TP1 : Implantation d'algorithmes en Python](tp1/TP1.md)
-### [TP2 : Algorithmes dans les graphes sans circuits](tp2/TP2.md)
+### [TP1 : Implantation d'algorithmes en Python](reports/TP1.md)
+### [TP2 : Algorithmes dans les graphes sans circuits](reports/TP2.md)

tp1/figure1.png figures/figure1.pngtp1/figure1.png renamed to figures/figure1.png

@@ -183,26 +183,26 @@ Fin génèreGraph
 
 Cette fonction permet de tester les performances en exécutant n fois chaque algorithme avec des graphs aléatoires dont la taille augmente progressivement de a à b, b non compris.
 
-Exemple ci-dessous, avec n = 1000, a = 1, b = 21 (la taille des graphs générés varie de 1 à 20)
+Exemple ci-dessous, avec n = 1000, a = 1, b = 101 (la taille des graphs générés varie de 1 à 100)
 
-![Figure1](/tp1/figure1.png?raw=true)
+![Figure1](../figures/figure1.png?raw=true)
 
 On peut voir sur le diagramme ci-dessous que l'algorithme le plus efficace est Roy-Warshall 2 (environ 2 fois plus efficace que Roy-Warshall 1).
 On remarque également que Roy-Warshall 1 Bis est l'implémentation la moins efficace.
 
 Cependant, si on zoome dans le diagramme, on peut voir que Roy-Warshall 1 bis est très légèrement plus efficace que Roy-Warshall 1 pour des graphs avec des sommets allant de 1 à 7/8.
 
-![Figure2](/tp1/figure2.png?raw=true)
+![Figure2](../figures/figure2.png?raw=true)
 
-Le diagramme peut être visualisé en exécutant les commandes suivantes dans un terminal (sur Linux) :
+Le diagramme peut être visualisé en exécutant les commandes suivantes dans un terminal à l'intérieur du dossier racine (sur Linux) :
 
 ```bash
 python3 -m venv venv # création d'un environnement virtuel pour installer la bibliothèque matplotlib
 source venv/bin/activate # activation de l'environnement virtuel
 pip3 install matplotlib # installation de la bibliothèque Python matplotlib
-python3 tp1/src/graph.py # exécution du script Python qui génère les diagrammes
+python3 -m src.tp1 # exécution du script Python qui génère les diagrammes
 ```
-Les paramètres d'exécution peuvent être modifiées au début du fichier `tp1/src/graph.py` :
+Les paramètres d'exécution peuvent être modifiées au début du fichier `src/tp1.py` :
 
 ```python
 def main() -> None:

tp1/figure2.png figures/figure2.pngtp1/figure2.png renamed to figures/figure2.png

@@ -0,0 +1,20 @@
+from statistics import mean
+from timeit import default_timer
+
+from src.utils import generate_adjacency_list
+
+
+def get_exec_time(function, *args) -> float:
+    start = default_timer()
+    function(*args)
+    return default_timer() - start
+
+
+def get_n_exec_time(algorithm, n, size) -> int:
+    exec_times = []
+
+    for i in range(n):
+        adjacency_list = generate_adjacency_list(size)
+        exec_times.append(get_exec_time(algorithm, adjacency_list))
+
+    return mean(exec_times) * 10 ** 6  # Convert seconds to microseconds

tp1/TP1.md reports/TP1.mdtp1/TP1.md renamed to reports/TP1.md

@@ -1,10 +1,11 @@
 import sys
-from timeit import default_timer
 from typing import List, Tuple
-from random import randrange, sample
-from statistics import mean
+
 import matplotlib.pyplot as plt
 
+from src.performance import get_n_exec_time
+from src.utils import adjacency_list_to_adjacency_matrix
+
 """ ---------- Plot Roy Warshall exec times ---------- """
 
 
@@ -43,35 +44,16 @@ def main() -> None:
     plt.show()
 
 
-""" ---------- Performance Tests ---------- """
-
-
-def get_exec_time(function, *args):
-    start = default_timer()
-    function(*args)
-    return default_timer() - start
-
-
-def get_n_exec_time(algorithm, n, size):
-    exec_times = []
-
-    for i in range(n):
-        adjacency_list = generate_adjacency_list(size)
-        exec_times.append(get_exec_time(algorithm, adjacency_list))
-
-    return mean(exec_times) * 10 ** 6  # Convert seconds to microseconds
-
-
 """ ---------- Roy Warshall Algorithm ---------- """
 
 
 def roy_warshall_1(adjacency_list: List[List[int]]) -> List[List[int]]:
     # here we convert the adjacency list to an adjacency matrix
     matrix = adjacency_list_to_adjacency_matrix(adjacency_list)
     vertices_number = len(adjacency_list)
-    for k in range(0, vertices_number):
-        for i in range(0, vertices_number):
-            for j in range(0, vertices_number):
+    for k in range(vertices_number):
+        for i in range(vertices_number):
+            for j in range(vertices_number):
                 matrix[i][j] = matrix[i][j] or (matrix[i][k] and matrix[k][j])
 
     return matrix
@@ -80,10 +62,10 @@ def roy_warshall_1(adjacency_list: List[List[int]]) -> List[List[int]]:
 # Another implementation of Roy Warshall's algorithm, more efficient than roy_warshall_1
 def roy_warshall_1_bis(adjacency_list: List[List[int]]) -> List[List[int]]:
     matrix = adjacency_list_to_adjacency_matrix(adjacency_list)
-    for i in range(0, len(matrix)):
-        for j in range(0, len(matrix[i])):
+    for i in range(len(matrix)):
+        for j in range(len(matrix[i])):
             if matrix[i][j] == 1:
-                for x in range(0, len(matrix[j])):
+                for x in range(len(matrix[j])):
                     if matrix[j][x] == 1:
                         matrix[i][x] = matrix[j][x]
     return matrix
@@ -154,64 +136,5 @@ def _depth_first_search(vertex: int, glob_index: int):
     return res_visit_stack, scc
 
 
-""" ---------- Utility functions ---------- """
-
-
-def generate_adjacency_list(vertices_number):
-    adjacency_list = [[] for i in range(vertices_number)]
-
-    for i in range(vertices_number):
-        # actual vertex can be linked to itself
-        successors_number = randrange(vertices_number + 1)
-        adjacency_list[i].extend(sample(range(vertices_number), successors_number))
-
-    return adjacency_list
-
-
-def adjacency_list_to_adjacency_matrix(adjacency_list: List[List[int]]) -> List[List[int]]:
-    vertices_number = len(adjacency_list)
-    matrix = [[0 for x in range(vertices_number)] for x in range(vertices_number)]
-
-    for i in range(0, len(adjacency_list)):
-        for j in range(0, len(adjacency_list[i])):
-            matrix[i][adjacency_list[i][j]] = 1
-
-    return matrix
-
-
-def transpose_adjacency_list(adjacency_list: List[List[int]]) -> List[List[int]]:
-    vertices_number = len(adjacency_list)
-    transposed_adjacency_list = [[] for i in range(vertices_number)]
-
-    for i in range(vertices_number):
-        for j in range(len(adjacency_list[i])):
-            transposed_adjacency_list[adjacency_list[i][j]].append(i)
-
-    return transposed_adjacency_list
-
-
-def print_matrix(matrix: List[List[int]]) -> None:
-    print('    ', end='')
-    for i in range(0, len(matrix)):
-        print(i, end=' ')
-
-    print('\n', end='')
-    print('    ', end='')
-
-    for i in range(0, len(matrix)):
-        print('_', end=' ')
-
-    print('\n', end='')
-
-    i = 0
-    for row in matrix:
-        print('{} |'.format(i), end=' ')
-        for val in row:
-            print(val, end=' ')
-        print('\n', end='')
-        i += 1
-    print('')
-
-
 if __name__ == "__main__":
     main()

tp2/TP2.md reports/TP2.mdtp2/TP2.md renamed to reports/TP2.md

@@ -1,11 +1,19 @@
 from operator import itemgetter
 from typing import List
 
+from src.utils import print_adjacency_matrix_csv, adjacency_list_to_adjacency_matrix, \
+    generate_adjacency_list_without_cycles
+
 
 def main():
     # graph = [[1, 2], [2], [3], [4], []]
-    graph = [[1, 2], [2], [3], [4, 5], [], [6], []]
-    print(grundy(graph))
+    # graph = [[1, 2], [2], [3], [4, 5], [], [6], []]
+    # print(grundy(graph))
+
+    for i in range(1):
+        print_adjacency_matrix_csv(adjacency_list_to_adjacency_matrix(generate_adjacency_list_without_cycles(8)))
+
+    # print(adjacency_list_to_adjacency_matrix(generate_adjacency_list_without_cycles(5)))
 
 
 def leveling(adjacency_list: List[List[int]]) -> List[int]:

src/__init__.py

@@ -0,0 +1,79 @@
+from random import randrange, sample
+from typing import List
+
+
+def generate_adjacency_list(vertices_number: int) -> List[List[int]]:
+    adjacency_list = [[] for i in range(vertices_number)]
+
+    for i in range(vertices_number):
+        # actual vertex can be linked to itself
+        successors_number = randrange(vertices_number + 1)
+        adjacency_list[i].extend(sample(range(vertices_number), successors_number))
+
+    return adjacency_list
+
+
+def generate_adjacency_list_without_cycles(vertices_number: int) -> List[List[int]]:
+    adjacency_list = [[] for i in range(vertices_number)]
+
+    for i in range(vertices_number):
+        successors_number = randrange(vertices_number - i)
+        adjacency_list[i].extend(sample(range(i + 1, vertices_number), successors_number))
+
+    return adjacency_list
+
+
+def print_adjacency_matrix_csv(adjacency_matrix: List[List[int]]) -> None:
+    vertices_number = len(adjacency_matrix)
+    for i in range(vertices_number):
+        for j in range(vertices_number):
+            print(adjacency_matrix[i][j], end='')
+            if j != (vertices_number - 1):
+                print(', ', end='')
+        print('\n', end='')
+    print('\n', end='')
+
+
+def adjacency_list_to_adjacency_matrix(adjacency_list: List[List[int]]) -> List[List[int]]:
+    vertices_number = len(adjacency_list)
+    matrix = [[0 for x in range(vertices_number)] for x in range(vertices_number)]
+
+    for i in range(len(adjacency_list)):
+        for j in range(len(adjacency_list[i])):
+            matrix[i][adjacency_list[i][j]] = 1
+
+    return matrix
+
+
+def transpose_adjacency_list(adjacency_list: List[List[int]]) -> List[List[int]]:
+    vertices_number = len(adjacency_list)
+    transposed_adjacency_list = [[] for i in range(vertices_number)]
+
+    for i in range(vertices_number):
+        for j in range(len(adjacency_list[i])):
+            transposed_adjacency_list[adjacency_list[i][j]].append(i)
+
+    return transposed_adjacency_list
+
+
+def print_adjacency_matrix(adjacency_matrix: List[List[int]]) -> None:
+    print('    ', end='')
+    for i in range(len(adjacency_matrix)):
+        print(i, end=' ')
+
+    print('\n', end='')
+    print('    ', end='')
+
+    for i in range(len(adjacency_matrix)):
+        print('_', end=' ')
+
+    print('\n', end='')
+
+    i = 0
+    for row in adjacency_matrix:
+        print('{} |'.format(i), end=' ')
+        for val in row:
+            print(val, end=' ')
+        print('\n', end='')
+        i += 1
+    print('')