spelling + bug fix

Author: nik1as

.gitignore

@@ -1,3 +1,4 @@
+venv
 .venv
 .idea
 __pycache__

main.py

@@ -282,17 +282,17 @@ def step(self):
 
     def start(self):
         try:
-            intervall = int(self.ent_time.get())
+            interval = int(self.ent_time.get())
 
             self.opt_algorithm["state"] = tk.DISABLED
             self.btn_step["state"] = tk.DISABLED
             self.btn_start["state"] = tk.DISABLED
             self.ent_time["state"] = tk.DISABLED
 
-            self._jop = window.after(intervall, self.start)
+            self._jop = window.after(interval, self.start)
             self.step()
         except ValueError:
-            messagebox.showerror("Error", "intervall must be an integer")
+            messagebox.showerror("Error", "interval must be an integer")
 
     def stop(self):
         self.btn_step["state"] = tk.NORMAL
@@ -328,7 +328,7 @@ def help(self):
 """)
 
 
-class TestEnviroment(tk.Frame):
+class TestEnvironment(tk.Frame):
 
     def __init__(self, parent):
         super().__init__(parent)
@@ -434,9 +434,9 @@ def start_test(self):
 frame_visualization.pack()
 tabs.add(frame_visualization, text="Visualization")
 
-frame_test_envoirement = TestEnviroment(tabs)
-frame_test_envoirement.pack()
-tabs.add(frame_test_envoirement, text="Test environment")
+frame_test_environment = TestEnvironment(tabs)
+frame_test_environment.pack()
+tabs.add(frame_test_environment, text="Test environment")
 
 tabs.pack(expand=True, fill="both")
 

max_flow.py

@@ -141,8 +141,9 @@ def preflow():
                 edge.flow = edge.capacity
                 excess[edge.end] += edge.flow
 
-                active.append(edge.end)
-                in_queue[edge.end] = True
+                if edge.end != target:
+                    active.append(edge.end)
+                    in_queue[edge.end] = True
 
                 edges.append(edge)
         return edges, excess, label, source
@@ -189,165 +190,3 @@ def relabel(node: int):
         if u not in (source, target) and excess[u] > 0:
             active.append(u)
             in_queue[u] = True
-
-
-"""
-class MaxFlow(ABC):
-
-    def __init__(self, graph: Graph, source: int, target: int):
-        self.graph = graph
-        self.source = source
-        self.target = target
-
-    @abstractmethod
-    def step(self):
-        pass
-
-
-class FordFulkerson(MaxFlow):
-
-    def __init__(self, graph: Graph, source: int, target: int, path_algo=dfs):
-        super().__init__(graph, source, target)
-        self.path_algo = path_algo
-
-    def step(self):
-        if result := self.path_algo(self.graph, self.source, self.target):
-            parent, *_ = result
-            path_flow = math.inf
-
-            tmp = self.target
-            path = deque()
-            while tmp != self.source:
-                path_flow = min(path_flow, parent[tmp].residual_capacity())
-                path.appendleft(parent[tmp])
-                tmp = parent[tmp].start
-
-            tmp = self.target
-            while tmp != self.source:
-                parent[tmp].adjust(path_flow)
-                tmp = parent[tmp].start
-
-            return list(path)
-
-
-class EdmondsKarp(FordFulkerson):
-
-    def __init__(self, graph: Graph, source: int, target: int):
-        super().__init__(graph, source, target, bfs)
-
-
-class CapacityScaling(MaxFlow):
-
-    def __init__(self, graph: Graph, source: int, target: int):
-        super().__init__(graph, source, target)
-        max_capacity = max(e.capacity for e in graph.get_edges())
-        self.delta = 2 ** math.floor(math.log(max_capacity, 2))
-
-    def step(self):
-        if result := bfs_capacity(self.graph, self.source, self.target, self.delta):
-            parent, *_ = result
-            path_flow = math.inf
-
-            tmp = self.target
-            path = deque()
-            while tmp != self.source:
-                path_flow = min(path_flow, parent[tmp].residual_capacity())
-                path.appendleft(parent[tmp])
-                tmp = parent[tmp].start
-
-            tmp = self.target
-            while tmp != self.source:
-                parent[tmp].adjust(path_flow)
-                tmp = parent[tmp].start
-
-            return list(path)
-        else:
-            if self.delta > 1:
-                self.delta /= 2
-                return self.step()
-
-
-class Dinic(MaxFlow):
-
-    def __init__(self, graph: Graph, source: int, target: int):
-        super().__init__(graph, source, target)
-
-    def step(self):
-        if result := bfs(self.graph, self.source, self.target):
-            _, level = result
-            start = [0] * (self.graph.number_of_nodes() + 1)
-            edges = []
-            while flow := self.blocking_flow(self.source, math.inf, start, level, edges):
-                pass
-            return edges, level
-
-    def blocking_flow(self, u: int, flow: int, start: list[int], level: list[int], edges: list):
-        # dfs in acyclic layer graph
-
-        if u == self.target:
-            return flow
-
-        while start[u] < self.graph.get_degree(u):
-            edge = self.graph.get_edges_by_node(u)[start[u]]  # edge.start == u
-            if level[edge.end] == level[edge.start] + 1 and edge.residual_capacity() > 0:
-                curr_flow = min(flow, edge.residual_capacity())
-                curr_flow = self.blocking_flow(edge.end, curr_flow, start, level, edges)
-
-                if curr_flow and curr_flow > 0:
-                    edge.adjust(curr_flow)
-                    edges.append(edge)
-                    return curr_flow
-            start[u] += 1
-
-
-class GoldbergTarjan(MaxFlow):  # TODO
-
-    def __init__(self, graph: Graph, source: int, target: int):
-        super().__init__(graph, source, target)
-        self.excess = [0] * graph.number_of_nodes()
-        self.label = [0] * graph.number_of_nodes()
-        self.active = deque()
-        self.preflow_executed = False
-
-    def preflow(self):
-        self.preflow_executed = True
-        self.label[self.source] = self.graph.number_of_nodes()
-        for edge in self.graph.get_edges_by_node(self.source):
-            if not edge.reverse_edge:
-                edge.flow = edge.capacity
-                self.excess[edge.end] += edge.flow
-                self.active.append(edge.end)
-
-    def push(self, u):
-        for edge in self.graph.get_edges_by_node(u):
-            if edge.reverse_edge:
-                continue
-            if edge.flow == edge.capacity:
-                continue
-
-            v = edge.end
-            if self.label[u] > self.label[v]:
-                flow = min(edge.residual_capacity(), self.excess[u])
-                self.excess[u] -= flow
-                self.excess[v] += flow
-                edge.adjust(flow)
-
-    def relabel(self, u):
-        self.label[u] = 1 + min(self.label[edge.v]
-                                for edge in self.graph.get_edges_by_node(u)
-                                if edge.residual_capacity() > 0)
-
-    def step(self):
-        if not self.preflow_executed:
-            return self.preflow()
-
-        if self.active:
-            u = self.active.popleft()
-            if any(self.excess[edge.end] > 0 for edge in self.graph.get_edges_by_node(u)):
-                return self.push(u)
-            else:
-                return self.relabel(u)
-
-            if u not in (s, t) and self.excess[u] > 0:
-                self.active.append(u)
-"""

random_graph.py

@@ -44,14 +44,4 @@ def generate(n: int, max_capacity: int) -> tuple[int, int, Graph]:
         if edge.end == target and not edge.reverse:
             edge.capacity = (degree_target + 1) * max_capacity
 
-    # TODO
-    """
-    while True:
-        parent, dist = max_flow.bfs(graph, source, target)
-        if dist[target] <= 3:
-            pass  # add nodes between source and target
-        else:
-            break
-    """
-
     return source, target, graph