Add simulated annealing package with GUI, TSP helper, and unit tests

Author: athikha

simulated_annealing/example.py

@@ -29,5 +29,28 @@ def cli_example():
     print("Cost:", cost)
 
 
+def tsp_example():
+    # Small TSP demo
+    from .simulated_annealing import SimulatedAnnealing
+    from .tsp import make_tsp_cost, random_tour, vector_to_tour
+
+    coords = [(0, 0), (1, 5), (5, 4), (6, 1), (3, -2)]
+    n = len(coords)
+    init_tour = random_tour(n)
+    # represent tour as vector by using tour indices as values (so ranking recovers order)
+    initial = [float(i) for i in init_tour]
+    cost_fn = make_tsp_cost(coords)
+
+    sa = SimulatedAnnealing(cost_fn, initial, temperature=100.0, cooling_rate=0.995, iterations_per_temp=500)
+    best, cost, history = sa.optimize()
+    best_tour = vector_to_tour(best)
+    print("Best tour:", best_tour)
+    print("Cost:", cost)
+
+
 if __name__ == "__main__":
+    # Run CLI examples
+    print("Running continuous example...")
     cli_example()
+    print("Running TSP example...")
+    tsp_example()

simulated_annealing/gui.py

@@ -121,16 +121,24 @@ def _on_run(self):
 
         def worker():
             sa = SimulatedAnnealing(func, initial, bounds=bounds, temperature=temp, cooling_rate=cooling, iterations_per_temp=iterations)
-            best, cost, history = sa.optimize()
-            # update plot on main thread
+
+            def progress_cb(step, best_cost, current_cost):
+                # schedule a plot update on the main thread
+                self.after(0, lambda: self._update_plot_partial(step, best_cost))
+
+            best, cost, history = sa.optimize(stop_event=self.stop_flag, progress_callback=progress_cb)
+            # update final plot on main thread
             self.after(0, lambda: self._on_complete(best, cost, history))
 
         t = threading.Thread(target=worker, daemon=True)
         t.start()
 
     def _on_stop(self):
-        # currently we don't have a cooperative stop in the algorithm; inform user
-        messagebox.showinfo("Stop", "Stop requested, but immediate stop is not implemented. The run will finish current loop.")
+        # set stop flag; optimizer will stop cooperatively
+        self.stop_flag.set()
+        self.stop_btn.config(state=tk.DISABLED)
+        self.run_btn.config(state=tk.NORMAL)
+        messagebox.showinfo("Stop", "Stop requested; optimizer will stop shortly.")
 
     def _on_complete(self, best, cost, history):
         x = list(range(len(history.get("best_costs", []))))
@@ -147,6 +155,23 @@ def _on_complete(self, best, cost, history):
         self.run_btn.config(state=tk.NORMAL)
         self.stop_btn.config(state=tk.DISABLED)
 
+    def _update_plot_partial(self, step: int, best_cost: float):
+        # Append a new point to plot (x=step, y=best_cost)
+        # We'll redraw full plot for simplicity
+        line_x = list(range(len(self.ax.lines[0].get_xdata()) + 1)) if self.ax.lines else [step]
+        if self.ax.lines:
+            ydata = list(self.ax.lines[0].get_ydata())
+            ydata.append(best_cost)
+        else:
+            ydata = [best_cost]
+        self.ax.clear()
+        self.ax.plot(line_x, ydata, label="best_cost")
+        self.ax.set_xlabel("Iterations")
+        self.ax.set_ylabel("Best cost")
+        self.ax.grid(True)
+        self.ax.legend()
+        self.canvas.draw()
+
 
 def main():
     app = SA_GUI()

simulated_annealing/simulated_annealing.py

@@ -65,9 +65,13 @@ def _accept(self, delta: float, temp: float) -> bool:
             prob = 0.0
         return random.random() < prob
 
-    def optimize(self, max_steps: Optional[int] = None) -> Tuple[List[float], float, dict]:
+    def optimize(self, max_steps: Optional[int] = None, stop_event: Optional[object] = None, progress_callback: Optional[Callable[[int, float, float], None]] = None) -> Tuple[List[float], float, dict]:
         """Run optimization and return best solution, cost, and history.
 
+        New optional args:
+        - stop_event: a threading.Event-like object. If set, optimization stops early.
+        - progress_callback: callable(step, best_cost, current_cost) called periodically.
+
         history dict contains: temps, best_costs, current_costs
         """
         temp = self.temperature
@@ -81,6 +85,11 @@ def optimize(self, max_steps: Optional[int] = None) -> Tuple[List[float], float,
         steps = 0
         while temp > self.min_temperature:
             for _ in range(self.iterations_per_temp):
+                # Check stop event
+                if stop_event is not None and getattr(stop_event, "is_set", lambda: False)():
+                    self.current = current
+                    return best, best_cost, history
+
                 candidate = self._neighbor(current)
                 candidate_cost = float(self.func(candidate))
                 delta = candidate_cost - current_cost
@@ -96,6 +105,13 @@ def optimize(self, max_steps: Optional[int] = None) -> Tuple[List[float], float,
                 history["current_costs"].append(current_cost)
 
                 steps += 1
+                if progress_callback is not None and steps % max(1, self.iterations_per_temp // 10) == 0:
+                    try:
+                        progress_callback(steps, best_cost, current_cost)
+                    except Exception:
+                        # Don't let callback errors stop optimization
+                        pass
+
                 if max_steps is not None and steps >= max_steps:
                     self.current = current
                     return best, best_cost, history

simulated_annealing/tsp.py

@@ -0,0 +1,53 @@
+import math
+import random
+from typing import List, Sequence, Tuple
+
+
+def euclidean_distance(a: Sequence[float], b: Sequence[float]) -> float:
+    return math.hypot(a[0] - b[0], a[1] - b[1])
+
+
+def total_distance(tour: Sequence[int], coords: Sequence[Tuple[float, float]]) -> float:
+    d = 0.0
+    n = len(tour)
+    for i in range(n):
+        a = coords[tour[i]]
+        b = coords[tour[(i + 1) % n]]
+        d += euclidean_distance(a, b)
+    return d
+
+
+def random_tour(n: int) -> List[int]:
+    tour = list(range(n))
+    random.shuffle(tour)
+    return tour
+
+
+def neighbor_swap(tour: Sequence[int]) -> List[int]:
+    # swap two indices
+    n = len(tour)
+    i, j = random.sample(range(n), 2)
+    new = list(tour)
+    new[i], new[j] = new[j], new[i]
+    return new
+
+
+def tour_to_vector(tour: Sequence[int]) -> List[float]:
+    # Convert permutation to a float vector for generic optimizer compatibility
+    return [float(i) for i in tour]
+
+
+def vector_to_tour(vec: Sequence[float]) -> List[int]:
+    # Convert vector of floats back to a tour by ranking
+    pairs = list(enumerate(vec))
+    pairs.sort(key=lambda p: p[1])
+    return [int(p[0]) for p in pairs]
+
+
+def make_tsp_cost(coords: Sequence[Tuple[float, float]]):
+    def cost_from_vector(vec: Sequence[float]) -> float:
+        # Convert vector to tour and compute total distance
+        tour = vector_to_tour(vec)
+        return total_distance(tour, coords)
+
+    return cost_from_vector

tests/test_simulated_annealing.py

@@ -0,0 +1,28 @@
+import unittest
+from simulated_annealing.simulated_annealing import SimulatedAnnealing
+
+
+def sphere(x):
+    return sum(v * v for v in x)
+
+
+class TestSimulatedAnnealing(unittest.TestCase):
+    def test_minimize_sphere_1d(self):
+        sa = SimulatedAnnealing(sphere, [5.0], bounds=[(-10, 10)], temperature=10, cooling_rate=0.9, iterations_per_temp=50)
+        best, cost, hist = sa.optimize()
+        # Best should be near 0 with tiny cost
+        self.assertLess(cost, 1e-2)
+
+    def test_stop_event(self):
+        import threading
+        stop = threading.Event()
+        sa = SimulatedAnnealing(sphere, [5.0], bounds=[(-10, 10)], temperature=10, cooling_rate=0.9, iterations_per_temp=1000)
+        # request stop immediately
+        stop.set()
+        best, cost, hist = sa.optimize(stop_event=stop)
+        # Should return without error
+        self.assertIsNotNone(best)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_tsp.py

@@ -0,0 +1,20 @@
+import unittest
+from simulated_annealing.tsp import total_distance, random_tour, euclidean_distance
+
+
+class TestTSP(unittest.TestCase):
+    def test_distance_symmetric(self):
+        a = (0, 0)
+        b = (3, 4)
+        d = euclidean_distance(a, b)
+        self.assertAlmostEqual(d, 5.0)
+
+    def test_total_distance_cycle(self):
+        coords = [(0, 0), (0, 1), (1, 1), (1, 0)]
+        tour = [0, 1, 2, 3]
+        d = total_distance(tour, coords)
+        self.assertGreater(d, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()