TP2 plot

Author: maxime-bc

src/performance.py

@@ -10,11 +10,10 @@ def get_exec_time(function, *args) -> float:
     return default_timer() - start
 
 
-def get_n_exec_time(algorithm, n, size) -> int:
+def get_n_exec_time(algorithm, n, adjacency_list) -> 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
+    return mean(exec_times)

src/tp1.py

@@ -4,15 +4,21 @@
 import matplotlib.pyplot as plt
 
 from src.performance import get_n_exec_time
-from src.utils import adjacency_list_to_adjacency_matrix
+from src.utils import adjacency_list_to_adjacency_matrix, generate_adjacency_list
 
 """ ---------- Plot Roy Warshall exec times ---------- """
 
 
 def main() -> None:
-    min_graph_size = 1
-    max_graph_size = 21
-    number_of_executions = 1000
+    if len(sys.argv) != 4:
+        sys.exit("Usage : <min_graph_size> <max_graph_size> <number_of_executions>")
+
+    min_graph_size = int(sys.argv[1])
+    max_graph_size = int(sys.argv[2]) + 1
+    number_of_executions = int(sys.argv[3])
+
+    if min_graph_size < 1 or max_graph_size < min_graph_size or number_of_executions < 1:
+        sys.exit("Invalid arguments.")
 
     print("{} executions".format(number_of_executions))
 
@@ -21,14 +27,13 @@ def main() -> None:
     line3 = []
 
     for i in range(min_graph_size, max_graph_size):
-        sys.stdout.write('{0:.1f}% processed ({1} vertices) \r'.format(i / max_graph_size * 100, i))
+        sys.stdout.write('{0:.1f}% processed ({1} vertices) \r'.format((i + 1) / max_graph_size * 100, i))
         sys.stdout.flush()
 
-        line1.append(get_n_exec_time(roy_warshall_1, number_of_executions, i))
-        line2.append(get_n_exec_time(roy_warshall_1_bis, number_of_executions, i))
-        line3.append(get_n_exec_time(roy_warshall_2, number_of_executions, i))
+        line1.append(get_n_exec_time(roy_warshall_1, number_of_executions, generate_adjacency_list(i)))
+        line2.append(get_n_exec_time(roy_warshall_1_bis, number_of_executions, generate_adjacency_list(i)))
+        line3.append(get_n_exec_time(roy_warshall_2, number_of_executions, generate_adjacency_list(i)))
 
-    sys.stdout.write('100% processed ({} vertices) \r'.format(max_graph_size - 1))
     vertices_number = [*range(1, max_graph_size)]
 
     plt.plot(vertices_number, line1, label='Roy Warshall 1')
@@ -37,7 +42,7 @@ def main() -> None:
 
     plt.grid()
 
-    plt.ylabel('Average exec time (in µs)')
+    plt.ylabel('Average exec time (in seconds)')
     plt.xlabel('Number of vertices')
     plt.title('Average exec time of the 3 different Roy Warshall algorithms ({} execs)'.format(number_of_executions))
     plt.legend()

src/tp2.py

@@ -1,19 +1,44 @@
+import sys
 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
+import matplotlib.pyplot as plt
+
+from src.performance import get_n_exec_time
+from src.utils import generate_adjacency_list_without_cycles
 
 
 def main():
-    # graph = [[1, 2], [2], [3], [4], []]
-    # graph = [[1, 2], [2], [3], [4, 5], [], [6], []]
-    # print(grundy(graph))
+    if len(sys.argv) != 4:
+        sys.exit("Usage : <min_graph_size> <max_graph_size> <number_of_executions>")
+
+    min_graph_size = int(sys.argv[1])
+    max_graph_size = int(sys.argv[2]) + 1
+    number_of_executions = int(sys.argv[3])
+
+    if min_graph_size < 1 or max_graph_size < min_graph_size or number_of_executions < 1:
+        sys.exit("Invalid arguments.")
+
+    print("{} executions".format(number_of_executions))
+
+    line1 = []
+
+    for i in range(min_graph_size, max_graph_size):
+        sys.stdout.write('{0:.1f}% processed ({1} vertices) \r'.format((i + 1) / max_graph_size * 100, i))
+        sys.stdout.flush()
+
+        line1.append(get_n_exec_time(grundy, number_of_executions, generate_adjacency_list_without_cycles(i)))
+
+    vertices_number = [*range(1, max_graph_size)]
+    plt.plot(vertices_number, line1, label='Grundy')
 
-    for i in range(1):
-        print_adjacency_matrix_csv(adjacency_list_to_adjacency_matrix(generate_adjacency_list_without_cycles(8)))
+    plt.grid()
 
-    # print(adjacency_list_to_adjacency_matrix(generate_adjacency_list_without_cycles(5)))
+    plt.ylabel('Average exec time (in seconds)')
+    plt.xlabel('Number of vertices')
+    plt.title('Average exec time of grundy value algorithm ({} execs)'.format(number_of_executions))
+    plt.legend()
+    plt.show()
 
 
 def leveling(adjacency_list: List[List[int]]) -> List[int]:
@@ -31,7 +56,7 @@ def leveling(adjacency_list: List[List[int]]) -> List[int]:
             for k in range(len(adjacency_list[j])):
 
                 if adjacency_list[j][k] == no_successor_vertices[i]:
-                    no_successor_vertices.append(j)
+                    no_successor_vertices.append(j)  # <-- bug here
 
                     if graph_leveling[j] < (graph_leveling[no_successor_vertices[i]] + 1):
                         graph_leveling[j] = graph_leveling[no_successor_vertices[i]] + 1