NUCS 4.3.0__tar.gz → 4.4__tar.gz

{nucs-4.3.0 → nucs-4.4/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.3.0
+Version: 4.4
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-4.3.0/NUCS.egg-info → nucs-4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.3.0
+Version: 4.4
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-4.3.0 → nucs-4.4}/docs/source/conf.py

@@ -6,8 +6,8 @@ project = 'NUCS'
 copyright = '2024, Yan Georget'
 author = 'Yan Georget'
 
-release = '4.3.0'
-version = '4.3.0'
+release = '4.4'
+version = '4.4'
 
 # -- General configuration
 

{nucs-4.3.0 → nucs-4.4}/nucs/constants.py

@@ -14,9 +14,9 @@ import os
 
 from numba import bool, int32, int64, types, uint8, uint16  # type: ignore
 
-OPT_RESET = "RESET"
-OPT_PRUNE = "PRUNE"
-OPT_MODES = [OPT_RESET, OPT_PRUNE]
+OPTIM_RESET = "RESET"
+OPTIM_PRUNE = "PRUNE"
+OPTIM_MODES = [OPTIM_RESET, OPTIM_PRUNE]
 
 RG_START = 0  # index corresponding the start of a values range
 RG_END = 1  # index corresponding the end of a values range

{nucs-4.3.0 → nucs-4.4}/nucs/examples/bibd/__main__.py

@@ -33,7 +33,7 @@ if __name__ == "__main__":
     args = parser.parse_args()
     problem = BIBDProblem(args.v, args.b, args.r, args.k, args.l, args.symmetry_breaking)
     solver = BacktrackSolver(
-        problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level, stack_max_height=128
+        problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level, stacks_max_height=128
     )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-4.3.0 → nucs-4.4}/nucs/examples/golomb/__main__.py

@@ -14,7 +14,7 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_PRUNE
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPTIM_MODES, OPTIM_PRUNE
 from nucs.examples.golomb.golomb_problem import GolombProblem, golomb_consistency_algorithm
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import register_consistency_algorithm
@@ -26,7 +26,7 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
-    parser.add_argument("--opt_mode", choices=OPT_MODES, default=OPT_PRUNE)
+    parser.add_argument("--opt_mode", choices=OPTIM_MODES, default=OPTIM_PRUNE)
     parser.add_argument("--processors", type=int, default=1)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
@@ -36,14 +36,14 @@ if __name__ == "__main__":
         MultiprocessingSolver(
             [
                 BacktrackSolver(
-                    prob, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stack_max_height=128
+                    prob, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stacks_max_height=128
                 )
                 for prob in problem.split(args.processors, 0)
             ]
         )
         if args.processors > 1
         else BacktrackSolver(
-            problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stack_max_height=128
+            problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stacks_max_height=128
         )
     )
     solution = solver.minimize(problem.length_idx, mode=args.opt_mode)

{nucs-4.3.0 → nucs-4.4}/nucs/examples/knapsack/__main__.py

@@ -14,7 +14,7 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_RESET
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPTIM_MODES, OPTIM_RESET
 from nucs.examples.knapsack.knapsack_problem import KnapsackProblem
 from nucs.heuristics.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -24,7 +24,7 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
-    parser.add_argument("--opt_mode", choices=OPT_MODES, default=OPT_RESET)
+    parser.add_argument("--opt_mode", choices=OPTIM_MODES, default=OPTIM_RESET)
     args = parser.parse_args()
     problem = KnapsackProblem(
         [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],

{nucs-4.3.0 → nucs-4.4}/nucs/examples/magic_sequence/__main__.py

@@ -33,7 +33,7 @@ if __name__ == "__main__":
         var_heuristic_idx=VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
         dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
         log_level=args.log_level,
-        stack_max_height=128,
+        stacks_max_height=128,
     )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-4.3.0 → nucs-4.4}/nucs/examples/schur_lemma/__main__.py

@@ -27,6 +27,6 @@ if __name__ == "__main__":
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = SchurLemmaProblem(args.n, args.symmetry_breaking)
-    solver = BacktrackSolver(problem, log_level=args.log_level, stack_max_height=128)
+    solver = BacktrackSolver(problem, log_level=args.log_level, stacks_max_height=128)
     solver.solve_all()
     print(solver.get_statistics())

{nucs-4.3.0 → nucs-4.4}/nucs/examples/tsp/__main__.py

@@ -12,7 +12,9 @@
 ###############################################################################
 import argparse
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_PRUNE
+from rich import print
+
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPTIM_MODES, OPTIM_PRUNE
 from nucs.examples.tsp.tsp_instances import TSP_INSTANCES
 from nucs.examples.tsp.tsp_problem import TSPProblem
 from nucs.examples.tsp.tsp_var_heuristic import tsp_var_heuristic
@@ -27,7 +29,7 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
     parser.add_argument("--name", choices=["GR17", "GR21", "GR24"], default="GR17")
-    parser.add_argument("--opt_mode", choices=OPT_MODES, default=OPT_PRUNE)
+    parser.add_argument("--opt_mode", choices=OPTIM_MODES, default=OPTIM_PRUNE)
     parser.add_argument("--processors", type=int, default=1)
     parser.add_argument("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=False)
     args = parser.parse_args()

nucs-4.4/nucs/examples/tsp/tsp_problem.py

@@ -0,0 +1,47 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+from typing import List
+
+from nucs.problems.circuit_problem import CircuitProblem
+from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ELEMENT_IV
+
+
+class TSPProblem(CircuitProblem):
+    """ """
+
+    def __init__(self, costs: List[List[int]]) -> None:
+        """
+        Inits the problem.
+        :param costs: the costs between vertices as a list of lists of integers
+        """
+        n = len(costs)
+        super().__init__(n)
+        max_costs = [max(cost_row) for cost_row in costs]
+        min_costs = [min([cost for cost in cost_row if cost > 0]) for cost_row in costs]
+        self.succ_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
+        self.pred_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
+        self.total_cost = self.add_variable((sum(min_costs), sum(max_costs)))  # the total cost
+        self.add_propagators([([i, self.succ_costs + i], ALG_ELEMENT_IV, costs[i]) for i in range(n)])
+        self.add_propagators([([n + i, self.pred_costs + i], ALG_ELEMENT_IV, costs[i]) for i in range(n)])
+        self.add_propagator(
+            (list(range(self.succ_costs, self.succ_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
+        )
+        self.add_propagator(
+            (list(range(self.pred_costs, self.pred_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
+        )
+        # total_cost_prop_idx = register_propagator(
+        #     get_triggers_total_cost, get_complexity_total_cost, compute_domains_total_cost
+        # )
+        # costs = [cost for cost_row in costs for cost in cost_row]
+        # self.add_propagator((list(range(n)) + [self.total_cost], total_cost_prop_idx, costs))
+        # self.add_propagator((list(range(n, 2 * n)) + [self.total_cost], total_cost_prop_idx, costs))

{nucs-4.3.0 → nucs-4.4}/nucs/solvers/backtrack_solver.py

@@ -23,7 +23,7 @@ from nucs.constants import (
     MAX,
     MIN,
     NUMBA_DISABLE_JIT,
-    OPT_RESET,
+    OPTIM_RESET,
     PROBLEM_BOUND,
     PROBLEM_UNBOUND,
     SIGNATURE_COMPUTE_DOMAINS,
@@ -91,7 +91,7 @@ class BacktrackSolver(Solver):
         var_heuristic_params: List[List[int]] = [[]],
         dom_heuristic_idx: int = DOM_HEURISTIC_MIN_VALUE,
         dom_heuristic_params: List[List[int]] = [[]],
-        stack_max_height: int = 64,
+        stacks_max_height: int = 64,
         log_level: str = LOG_LEVEL_INFO,
     ):
         """
@@ -105,7 +105,7 @@ class BacktrackSolver(Solver):
         :param dom_heuristic_idx: the index of the heuristic for reducing a domain
         :param dom_heuristic_params: a list of lists of parameters,
         usually parameters are costs and there is a list of value costs per variable/shared domain
-        :param stack_max_height: the maximal choice point stack height
+        :param stacks_max_height: the maximal height of the choice point stacks
         :param log_level: the log level as a string
         """
         super().__init__(problem, log_level)
@@ -122,11 +122,11 @@ class BacktrackSolver(Solver):
         self.consistency_alg_idx = consistency_alg_idx
         self.triggered_propagators = np.ones(problem.propagator_nb, dtype=np.bool)
         logger.debug("Initializing choice points")
-        self.shr_domains_stack = np.empty((stack_max_height, self.problem.shr_domain_nb, 2), dtype=np.int32)
-        self.not_entailed_propagators_stack = np.empty((stack_max_height, self.problem.propagator_nb), dtype=np.bool)
-        self.dom_update_stack = np.empty((stack_max_height, 2), dtype=np.uint16)
+        self.shr_domains_stack = np.empty((stacks_max_height, self.problem.shr_domain_nb, 2), dtype=np.int32)
+        self.not_entailed_propagators_stack = np.empty((stacks_max_height, self.problem.propagator_nb), dtype=np.bool)
+        self.dom_update_stack = np.empty((stacks_max_height, 2), dtype=np.uint16)
         self.stacks_top = np.ones((1,), dtype=np.uint8)
-        logger.info(f"Choice points stack has a maximal height of {stack_max_height}")
+        logger.info(f"The stacks of the choice points have a maximal height of {stacks_max_height}")
         cp_init(
             self.shr_domains_stack,
             self.not_entailed_propagators_stack,
@@ -157,7 +157,7 @@ class BacktrackSolver(Solver):
             STATS_LBL_SOLVER_SOLUTION_NB: int(self.statistics[STATS_IDX_SOLVER_SOLUTION_NB]),
         }
 
-    def minimize(self, variable_idx: int, mode: str = OPT_RESET) -> Optional[NDArray]:
+    def minimize(self, variable_idx: int, mode: str = OPTIM_RESET) -> Optional[NDArray]:
         """
         Return the solution that minimizes a variable.
         :param variable_idx: the index of the variable to minimize
@@ -167,7 +167,7 @@ class BacktrackSolver(Solver):
         logger.info(f"Minimizing (mode {mode}) variable {variable_idx} (domain {domain}))")
         return self.optimize(variable_idx, MAX, mode)
 
-    def maximize(self, variable_idx: int, mode: str = OPT_RESET) -> Optional[NDArray]:
+    def maximize(self, variable_idx: int, mode: str = OPTIM_RESET) -> Optional[NDArray]:
         """
         Return the solution that maximizes a variable.
         :param variable_idx: the index of the variable to maximize
@@ -218,7 +218,7 @@ class BacktrackSolver(Solver):
         ) is not None:
             logger.info(f"Found a local optimum: {solution[variable_idx]}")
             best_solution = solution
-            if mode == OPT_RESET:
+            if mode == OPTIM_RESET:
                 logger.debug("Resetting solver")
                 cp_init(
                     self.shr_domains_stack,
@@ -373,7 +373,7 @@ class BacktrackSolver(Solver):
                 break
             logger.info(f"Found a local optimum: {solution[variable_idx]}")
             solution_queue.put((processor_idx, solution, None))
-            if mode == OPT_RESET:
+            if mode == OPTIM_RESET:
                 logger.debug("Resetting solver")
                 cp_init(
                     self.shr_domains_stack,

{nucs-4.3.0 → nucs-4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name="NUCS"
-version="4.3.0"
+version="4.4"
 authors = [
   { name="Yan Georget", email="yan.georget@gmail.com" },
 ]

{nucs-4.3.0 → nucs-4.4}/tests/examples/test_bibd.py

@@ -18,18 +18,18 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 class TestBIBD:
     def test_6_10_5_3_2(self) -> None:
         problem = BIBDProblem(6, 10, 5, 3, 2)
-        solver = BacktrackSolver(problem, stack_max_height=128)
+        solver = BacktrackSolver(problem, stacks_max_height=128)
         solver.solve_all()
         assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1
 
     def test_7_7_3_3_1(self) -> None:
         problem = BIBDProblem(7, 7, 3, 3, 1)
-        solver = BacktrackSolver(problem, stack_max_height=128)
+        solver = BacktrackSolver(problem, stacks_max_height=128)
         solver.solve_all()
         assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1
 
     def test_8_14_7_4_3(self) -> None:
         problem = BIBDProblem(8, 14, 7, 4, 3)
-        solver = BacktrackSolver(problem, stack_max_height=128)
+        solver = BacktrackSolver(problem, stacks_max_height=128)
         solver.solve_all()
         assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 92

{nucs-4.3.0 → nucs-4.4}/tests/examples/test_golomb.py

@@ -29,7 +29,7 @@ class TestGolomb:
     def test_golomb(self, mark_nb: int, length: int) -> None:
         problem = GolombProblem(mark_nb)
         consistency_alg_golomb = register_consistency_algorithm(golomb_consistency_algorithm)
-        solver = BacktrackSolver(problem, consistency_alg_idx=consistency_alg_golomb, stack_max_height=128)
+        solver = BacktrackSolver(problem, consistency_alg_idx=consistency_alg_golomb, stacks_max_height=128)
         solution = solver.minimize(problem.length_idx)
         assert solution is not None
         assert solution[problem.length_idx] == length

{nucs-4.3.0 → nucs-4.4}/tests/examples/test_magic_sequence.py

@@ -28,7 +28,7 @@ class TestMagicSequence:
             decision_domains=list(range(size - 1, -1, -1)),
             var_heuristic_idx=VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
             dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
-            stack_max_height=128,
+            stacks_max_height=128,
         )
         solutions = solver.find_all()
         assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1

{nucs-4.3.0 → nucs-4.4}/tests/examples/test_tsp.py

@@ -12,13 +12,12 @@
 ###############################################################################
 import pytest
 
-from nucs.constants import STATS_IDX_SOLVER_SOLUTION_NB
+from nucs.constants import OPTIM_PRUNE, STATS_IDX_SOLVER_SOLUTION_NB
 from nucs.examples.tsp.tsp_instances import TSP_INSTANCES
 from nucs.examples.tsp.tsp_problem import TSPProblem
 from nucs.examples.tsp.tsp_var_heuristic import tsp_var_heuristic
 from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_COST, register_var_heuristic
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_SHAVING
 
 
 class TestTSP:
@@ -47,13 +46,12 @@ class TestTSP:
         costs = tsp_instance + tsp_instance
         solver = BacktrackSolver(
             problem,
-            consistency_alg_idx=CONSISTENCY_ALG_SHAVING,
             decision_domains=list(range(0, 2 * n)),
             var_heuristic_idx=tsp_var_heuristic_idx,
             var_heuristic_params=costs,
             dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,
             dom_heuristic_params=costs,
         )
-        solution = solver.minimize(problem.total_cost)
+        solution = solver.minimize(problem.total_cost, mode=OPTIM_PRUNE)
         assert solution is not None
         assert solution[problem.total_cost] == minimum

{nucs-4.3.0 → nucs-4.4}/tests/solvers/test_backtrack_solver.py

@@ -12,7 +12,7 @@
 ###############################################################################
 import pytest
 
-from nucs.constants import OPT_PRUNE, OPT_RESET, STATS_LBL_SOLVER_CHOICE_DEPTH, STATS_LBL_SOLVER_SOLUTION_NB
+from nucs.constants import OPTIM_PRUNE, OPTIM_RESET, STATS_LBL_SOLVER_CHOICE_DEPTH, STATS_LBL_SOLVER_SOLUTION_NB
 from nucs.heuristics.heuristics import (
     DOM_HEURISTIC_MID_VALUE,
     DOM_HEURISTIC_MIN_VALUE,
@@ -86,19 +86,19 @@ class TestBacktrackSolver:
     @pytest.mark.parametrize(
         "mode,dom_heuristic, solution_nb",
         [
-            (OPT_PRUNE, DOM_HEURISTIC_MIN_VALUE, 5),
-            (OPT_PRUNE, DOM_HEURISTIC_MID_VALUE, 3),
-            (OPT_PRUNE, DOM_HEURISTIC_SPLIT_LOW, 5),
-            (OPT_PRUNE, DOM_HEURISTIC_SPLIT_HIGH, 1),
-            (OPT_RESET, DOM_HEURISTIC_MIN_VALUE, 5),
-            (OPT_RESET, DOM_HEURISTIC_MID_VALUE, 3),
-            (OPT_RESET, DOM_HEURISTIC_SPLIT_LOW, 5),
-            (OPT_RESET, DOM_HEURISTIC_SPLIT_HIGH, 1),
+            (OPTIM_PRUNE, DOM_HEURISTIC_MIN_VALUE, 5),
+            (OPTIM_PRUNE, DOM_HEURISTIC_MID_VALUE, 3),
+            (OPTIM_PRUNE, DOM_HEURISTIC_SPLIT_LOW, 5),
+            (OPTIM_PRUNE, DOM_HEURISTIC_SPLIT_HIGH, 1),
+            (OPTIM_RESET, DOM_HEURISTIC_MIN_VALUE, 5),
+            (OPTIM_RESET, DOM_HEURISTIC_MID_VALUE, 3),
+            (OPTIM_RESET, DOM_HEURISTIC_SPLIT_LOW, 5),
+            (OPTIM_RESET, DOM_HEURISTIC_SPLIT_HIGH, 1),
         ],
     )
     def test_maximize(self, mode: str, dom_heuristic: int, solution_nb: int) -> None:
         problem = Problem([(1, 5)])
-        solver = BacktrackSolver(problem, dom_heuristic_idx=dom_heuristic, stack_max_height=8)
+        solver = BacktrackSolver(problem, dom_heuristic_idx=dom_heuristic, stacks_max_height=8)
         solution = solver.maximize(0, mode=mode)
         assert solution is not None
         assert solution.tolist() == [5]

{nucs-4.3.0 → nucs-4.4}/tests/solvers/test_multiprocessing_solver.py

@@ -12,7 +12,7 @@
 ###############################################################################
 import pytest
 
-from nucs.constants import OPT_PRUNE, OPT_RESET, STATS_LBL_SOLVER_SOLUTION_NB
+from nucs.constants import OPTIM_PRUNE, OPTIM_RESET, STATS_LBL_SOLVER_SOLUTION_NB
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_ALLDIFFERENT, ALG_RELATION
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -40,18 +40,18 @@ class TestMultiprocessingSolver:
     @pytest.mark.parametrize(
         "mode, split_var, split_nb, solution_nb",
         [
-            (OPT_PRUNE, 0, 1, 6),
-            (OPT_RESET, 0, 1, 6),
-            (OPT_PRUNE, 0, 2, 6),
-            (OPT_RESET, 0, 2, 6),
-            (OPT_PRUNE, 0, 3, 6),
-            (OPT_RESET, 0, 3, 6),
-            (OPT_PRUNE, 1, 1, 6),
-            (OPT_RESET, 1, 1, 6),
-            (OPT_PRUNE, 1, 2, 6),
-            (OPT_RESET, 1, 2, 6),
-            (OPT_PRUNE, 1, 3, 6),
-            (OPT_RESET, 1, 3, 6),
+            (OPTIM_PRUNE, 0, 1, 6),
+            (OPTIM_RESET, 0, 1, 6),
+            (OPTIM_PRUNE, 0, 2, 6),
+            (OPTIM_RESET, 0, 2, 6),
+            (OPTIM_PRUNE, 0, 3, 6),
+            (OPTIM_RESET, 0, 3, 6),
+            (OPTIM_PRUNE, 1, 1, 6),
+            (OPTIM_RESET, 1, 1, 6),
+            (OPTIM_PRUNE, 1, 2, 6),
+            (OPTIM_RESET, 1, 2, 6),
+            (OPTIM_PRUNE, 1, 3, 6),
+            (OPTIM_RESET, 1, 3, 6),
         ],
     )
     def test_minimize_relation(self, mode: str, split_var: int, split_nb: int, solution_nb: int) -> None:

nucs-4.3.0/nucs/examples/tsp/tsp_problem.py

@@ -1,53 +0,0 @@
-###############################################################################
-# __   _            _____    _____
-# | \ | |          / ____|  / ____|
-# |  \| |  _   _  | |      | (___
-# | . ` | | | | | | |       \___ \
-# | |\  | | |_| | | |____   ____) |
-# |_| \_|  \__,_|  \_____| |_____/
-#
-# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
-#
-# Copyright 2024 - Yan Georget
-###############################################################################
-from typing import List
-
-from nucs.examples.tsp.total_cost_propagator import (
-    compute_domains_total_cost,
-    get_complexity_total_cost,
-    get_triggers_total_cost,
-)
-from nucs.problems.circuit_problem import CircuitProblem
-from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ELEMENT_IV, register_propagator
-
-
-class TSPProblem(CircuitProblem):
-    """ """
-
-    def __init__(self, cost_rows: List[List[int]]) -> None:
-        """
-        Inits the problem.
-        :param cost_rows: the costs between vertices
-        """
-        n = len(cost_rows)
-        super().__init__(n)
-        max_costs = [max(cost_row) for cost_row in cost_rows]
-        min_costs = [min([cost for cost in cost_row if cost > 0]) for cost_row in cost_rows]
-        self.next_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
-        self.prev_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
-        self.total_cost = self.add_variable((sum(min_costs), sum(max_costs)))  # the total cost
-        for i in range(n):
-            self.add_propagator(([i, self.next_costs + i], ALG_ELEMENT_IV, cost_rows[i]))
-            self.add_propagator(([n + i, self.prev_costs + i], ALG_ELEMENT_IV, cost_rows[i]))
-        self.add_propagator(
-            (list(range(self.next_costs, self.next_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
-        )
-        self.add_propagator(
-            (list(range(self.prev_costs, self.prev_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
-        )
-        total_cost_prop_idx = register_propagator(
-            get_triggers_total_cost, get_complexity_total_cost, compute_domains_total_cost
-        )
-        costs = [cost for cost_row in cost_rows for cost in cost_row]
-        self.add_propagator((list(range(n)) + [self.total_cost], total_cost_prop_idx, costs))
-        self.add_propagator((list(range(n, 2 * n)) + [self.total_cost], total_cost_prop_idx, costs))