main core

main core done but without sales

algorithms.py

@@ -0,0 +1,52 @@
+def bellman_ford_list(graph, start_node):
+    distances = {i: float('inf') for i in range(graph.num_vertices)}
+    distances[start_node] = 0
+    adj_list = graph.get_list()
+    
+    # Relaxation steps
+    for _ in range(graph.num_vertices - 1):
+        changed = False
+        for u in adj_list:
+            for v, weight in adj_list[u]:
+                if distances[u] != float('inf') and distances[u] + weight < distances[v]:
+                    distances[v] = distances[u] + weight
+                    changed = True
+        if not changed:
+            break
+            
+    # Negative cycle detection
+    for u in adj_list:
+        for v, weight in adj_list[u]:
+            if distances[u] != float('inf') and distances[u] + weight < distances[v]:
+                return None # Negative cycle detected
+
+    return distances
+
+def bellman_ford_matrix(graph, start_node):
+    distances = {i: float('inf') for i in range(graph.num_vertices)}
+    distances[start_node] = 0
+    matrix = graph.get_matrix()
+    n = graph.num_vertices
+    
+    # Relaxation steps
+    for _ in range(n - 1):
+        changed = False
+        for u in range(n):
+            for v in range(n):
+                weight = matrix[u][v]
+                if weight is not None:
+                    if distances[u] != float('inf') and distances[u] + weight < distances[v]:
+                        distances[v] = distances[u] + weight
+                        changed = True
+        if not changed:
+            break
+            
+    # Negative cycle detection
+    for u in range(n):
+        for v in range(n):
+            weight = matrix[u][v]
+            if weight is not None:
+                if distances[u] != float('inf') and distances[u] + weight < distances[v]:
+                    return None # Negative cycle detected
+
+    return distances

generator.py

@@ -0,0 +1,13 @@
+import random
+from graph_module import Graph
+
+def generate_random_graph(num_vertices, density):
+    graph = Graph(num_vertices, directed=True)
+    for u in range(num_vertices):
+        for v in range(num_vertices):
+            if u == v:
+                continue
+            if random.random() < density:
+                weight = random.randint(-2, 10)
+                graph.add_edge(u, v, weight)
+    return graph

graph_module.py

@@ -0,0 +1,22 @@
+class Graph:
+    def __init__(self, num_vertices, directed=True):
+        self.num_vertices = num_vertices
+        self.directed = directed
+        self.adj_matrix = [[None] * num_vertices for _ in range(num_vertices)]
+        self.adj_list = {i: [] for i in range(num_vertices)}
+
+    def add_edge(self, u, v, weight):
+        if 0 <= u < self.num_vertices and 0 <= v < self.num_vertices:
+            self.adj_list[u].append((v, weight))
+            self.adj_matrix[u][v] = weight
+            if not self.directed:
+                self.adj_list[v].append((u, weight))
+                self.adj_matrix[v][u] = weight
+        else:
+            raise ValueError(f"Vertex index out of bounds: {u}, {v}")
+
+    def get_matrix(self):
+        return self.adj_matrix
+
+    def get_list(self):
+        return self.adj_list

main.py

@@ -0,0 +1,60 @@
+import time
+import matplotlib.pyplot as plt
+from generator import generate_random_graph
+from algorithms import bellman_ford_list, bellman_ford_matrix
+
+def run_experiments():
+    sizes = [20, 50, 100, 200]
+    densities = [0.2, 0.5, 0.8]
+    results = {d: {'list': [], 'matrix': []} for d in densities}
+
+    print(f"{'Size':<10} {'Density':<10} {'List (s)':<15} {'Matrix (s)':<15}")
+    print("-" * 55)
+    
+    for d in densities:
+        for n in sizes:
+            t_list, t_matrix = 0, 0
+            runs = 5
+            for _ in range(runs):
+                g = generate_random_graph(n, d)
+                
+                start = time.perf_counter()
+                bellman_ford_list(g, 0)
+                t_list += (time.perf_counter() - start)
+                
+                start = time.perf_counter()
+                bellman_ford_matrix(g, 0)
+                t_matrix += (time.perf_counter() - start)
+            
+            avg_list = t_list / runs
+            avg_matrix = t_matrix / runs
+            results[d]['list'].append(avg_list)
+            results[d]['matrix'].append(avg_matrix)
+            print(f"{n:<10} {d:<10} {avg_list:.6f}        {avg_matrix:.6f}")
+
+    # Plotting
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+    
+    for d in densities:
+        ax1.plot(sizes, results[d]['list'], marker='o', label=f'D={d}')
+    ax1.set_title("Bellman-Ford (List)")
+    ax1.set_xlabel("Number of Vertices")
+    ax1.set_ylabel("Time (seconds)")
+    ax1.legend()
+    ax1.grid(True)
+    
+    for d in densities:
+        ax2.plot(sizes, results[d]['matrix'], marker='o', label=f'D={d}')
+    ax2.set_title("Bellman-Ford (Matrix)")
+    ax2.set_xlabel("Number of Vertices")
+    ax2.set_ylabel("Time (seconds)")
+    ax2.legend()
+    ax2.grid(True)
+    
+    plt.tight_layout()
+    plt.savefig('benchmark_results.png')
+    print("\nBenchmark finished. Results saved to benchmark_results.png")
+    plt.show()
+
+if __name__ == "__main__":
+    run_experiments()