Merge pull request #25 from david-sk/Backtracking

Backtracking

Author: Jxtopher

binpacking/solver/__main__.py

@@ -30,9 +30,10 @@
         bin_packing, tabu_size, max_iterations, getattr(Neighborhood, 'find_one_mutation_neighbor')
     )
 
-    s_star = ts.run(sol_init)
-    print('best solution')
-    print(s_star)
+    solutions = ts.run(sol_init)
+    print('best solutions')
+    print(solutions)
 
-    plot_handler = PlotHandler(bin_packing, s_star)
-    results_filepath = plot_handler.save_to_file('cool_plot.png')
+    for i, solution in enumerate(solutions):
+        plot_handler = PlotHandler(bin_packing, solution)
+        results_filepath = plot_handler.save_to_file(f'cool_plot_{i}_.png')

binpacking/solver/backtracking.py

@@ -0,0 +1,33 @@
+from typing import List
+import copy
+
+from binpacking.solver.bin_packing_2d import BinPacking2D
+from binpacking.solver.solution import Solution, Coordinate
+from binpacking.solver.optimisation_algo import OptimisationAlgo
+
+
+class Backtracking(OptimisationAlgo):
+    def __init__(self, bin_packing: BinPacking2D):
+        self.bin_packing = bin_packing
+
+    def run(self, sol: Solution) -> List[Solution]:
+        return self.backtracking(sol)
+
+    def backtracking(self, sol: Solution, number_of_valid_items: int = 0) -> List[Solution]:
+        width, height = self.bin_packing.capacity.get_width_height()
+        valid_solutions: List[Solution] = []
+        for x in range(width):
+            for y in range(height):
+                for r in [0, 90]:
+                    sol[number_of_valid_items] = Coordinate(x, y)
+                    sol[number_of_valid_items].set_is_rotated(r == 90)
+                    self.bin_packing.evaluate(sol)
+                    if number_of_valid_items < len(sol) - 1:
+                        if 0 <= sol.get_fitness():
+                            valid_solutions.extend(
+                                self.backtracking(copy.deepcopy(sol), number_of_valid_items + 1)
+                            )
+                    else:
+                        if sol.get_fitness() == len(sol):
+                            valid_solutions.append(copy.deepcopy(sol))
+        return valid_solutions

binpacking/solver/iterated_local_search.py

@@ -4,7 +4,7 @@
 #         Universitat Pompeu Fabra, https://EconPapers.repec.org/RePEc:upf:upfgen:513.
 #         (https://econ-papers.upf.edu/papers/513.pdf)
 import copy
-
+from typing import List
 from binpacking.solver.bin_packing_2d import BinPacking2D
 from binpacking.solver.solution import Solution
 from binpacking.solver.neighborhood import Neighborhood
@@ -19,7 +19,7 @@ def __init__(
         self.max_iterations = max_iterations
         self.optimisation_algo = optimisation_algo
 
-    def run(self, sol: Solution) -> Solution:
+    def run(self, sol: Solution) -> List[Solution]:
         # Best known solution
         s_star = copy.deepcopy(sol)
         if not s_star.has_valid_fitness():
@@ -41,4 +41,4 @@ def run(self, sol: Solution) -> Solution:
                 print(s_star)
             iterations += 1
 
-        return s_star
+        return [s_star]

binpacking/solver/optimisation_algo.py

@@ -1,5 +1,5 @@
 from abc import ABCMeta, abstractmethod
-
+from typing import List
 from binpacking.solver.solution import Solution
 
 
@@ -8,5 +8,5 @@ class OptimisationAlgo:
     __metaclass__ = ABCMeta
 
     @abstractmethod
-    def run(self, sol: Solution) -> Solution:
+    def run(self, sol: Solution) -> List[Solution]:
         pass

binpacking/solver/solution.py

@@ -24,7 +24,10 @@ def invalidate(self) -> None:
         self.x, self.y = self.INVALID_COORDINATE
 
     def rotate(self, is_rotated: bool = True) -> None:
-        self.is_rotated = is_rotated  # not self.is_rotated
+        self.is_rotated = not self.is_rotated
+
+    def set_is_rotated(self, is_rotated: bool) -> None:
+        self.is_rotated = is_rotated
 
 
 class Solution(List[Coordinate]):

binpacking/solver/tabu_search.py

@@ -1,7 +1,7 @@
 # @brief : F. Glover, "Future paths for integer programming and links to artificial intelligence,"
 #          Computers & Operations Research, vol. 13, pp. 533-549, 1986.
 
-from typing import Deque, Callable
+from typing import Deque, Callable, List
 from collections import deque
 import copy
 
@@ -24,7 +24,7 @@ def __init__(
         self.find_neighborhood = find_neighborhood
         self.tabu_deque: Deque[Solution] = deque(maxlen=self.tabu_size)
 
-    def run(self, sol: Solution) -> Solution:
+    def run(self, sol: Solution) -> List[Solution]:
         # Best known solution
         s_star = copy.deepcopy(sol)
         if not s_star.has_valid_fitness():
@@ -53,4 +53,4 @@ def run(self, sol: Solution) -> Solution:
             self.tabu_deque.append(s_prim)
 
             iterations += 1
-        return s_star
+        return [s_star]

tests/binpacking/solver/test_backtracking.py

@@ -0,0 +1,53 @@
+from tests.base import BaseTestCase
+
+from binpacking.solver.bin_packing_2d import BinPacking2D, Rectangle
+from binpacking.solver.solution import Solution, Coordinate
+
+from binpacking.solver.backtracking import Backtracking
+
+
+class BacktrackingTest(BaseTestCase):
+    @BaseTestCase.timeConsumingTest()
+    def test_run_big_instance(self) -> None:
+        instance = BinPacking2D(
+            Rectangle(100, 100),
+            [
+                Rectangle(30, 40),
+                Rectangle(70, 30),
+                Rectangle(30, 30),
+                Rectangle(40, 70),
+                Rectangle(30, 20),
+                Rectangle(30, 70),
+            ],
+        )
+        sol = Solution(instance.get_instance_size())
+        sol[0] = Coordinate(-1, -1)
+        sol[1] = Coordinate(-1, -1)
+        sol[2] = Coordinate(-1, -1)
+        sol[3] = Coordinate(-1, -1)
+        sol[4] = Coordinate(-1, -1)
+        sol[5] = Coordinate(-1, -1)
+
+        backtracking = Backtracking(instance)
+        backtracking.run(sol)
+
+    def test_run_small_instance(self) -> None:
+        instance = BinPacking2D(Rectangle(2, 2), [Rectangle(1, 2), Rectangle(1, 2)],)
+        sol = Solution(instance.get_instance_size())
+        sol[0] = Coordinate(-1, -1)
+        sol[1] = Coordinate(-1, -1)
+
+        backtracking = Backtracking(instance)
+        valid_solutions = backtracking.run(sol)
+
+        self.assertEqual(
+            str(valid_solutions),
+            str(
+                [
+                    [(0, 0, 0), (1, 0, 0)],
+                    [(0, 0, 90), (0, 1, 90)],
+                    [(0, 1, 90), (0, 0, 90)],
+                    [(1, 0, 0), (0, 0, 0)],
+                ]
+            ),
+        )