NUCS 3.0.0__tar.gz → 4.2.0__tar.gz

{nucs-3.0.0 → nucs-4.2.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 3.0.0
+Version: 4.2.0
 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-3.0.0 → nucs-4.2.0}/NUCS.egg-info/SOURCES.txt

@@ -47,7 +47,28 @@ nucs/examples/sports_tournament_scheduling/__main__.py
 nucs/examples/sports_tournament_scheduling/sports_tournament_scheduling_problem.py
 nucs/examples/sudoku/__init__.py
 nucs/examples/sudoku/sudoku_problem.py
+nucs/examples/tsp/__init__.py
+nucs/examples/tsp/__main__.py
+nucs/examples/tsp/mcp_dom_heuristic.py
+nucs/examples/tsp/mrp_var_heuristic.py
+nucs/examples/tsp/total_cost_propagator.py
+nucs/examples/tsp/tsp_instances.py
+nucs/examples/tsp/tsp_problem.py
+nucs/heuristics/__init__.py
+nucs/heuristics/first_not_instantiated_var_heuristic.py
+nucs/heuristics/greatest_domain_var_heuristic.py
+nucs/heuristics/heuristics.py
+nucs/heuristics/max_regret_var_heuristic.py
+nucs/heuristics/max_value_dom_heuristic.py
+nucs/heuristics/mid_value_dom_heuristic.py
+nucs/heuristics/min_cost_dom_heuristic.py
+nucs/heuristics/min_value_dom_heuristic.py
+nucs/heuristics/smallest_domain_var_heuristic.py
+nucs/heuristics/split_high_dom_heuristic.py
+nucs/heuristics/split_low_dom_heuristic.py
+nucs/heuristics/value_dom_heuristic.py
 nucs/problems/__init__.py
+nucs/problems/circuit_problem.py
 nucs/problems/latin_square_problem.py
 nucs/problems/problem.py
 nucs/propagators/__init__.py
@@ -58,6 +79,7 @@ nucs/propagators/alldifferent_propagator.py
 nucs/propagators/and_propagator.py
 nucs/propagators/count_eq_propagator.py
 nucs/propagators/dummy_propagator.py
+nucs/propagators/element_iv_propagator.py
 nucs/propagators/element_lic_propagator.py
 nucs/propagators/element_liv_propagator.py
 nucs/propagators/exactly_eq_propagator.py
@@ -68,14 +90,15 @@ nucs/propagators/max_eq_propagator.py
 nucs/propagators/max_leq_propagator.py
 nucs/propagators/min_eq_propagator.py
 nucs/propagators/min_geq_propagator.py
+nucs/propagators/no_sub_cycle_propagator.py
 nucs/propagators/propagators.py
 nucs/propagators/relation_propagator.py
+nucs/propagators/scc_propagator.py
 nucs/solvers/__init__.py
 nucs/solvers/backtrack_solver.py
 nucs/solvers/bound_consistency_algorithm.py
 nucs/solvers/choice_points.py
 nucs/solvers/consistency_algorithms.py
-nucs/solvers/heuristics.py
 nucs/solvers/multiprocessing_solver.py
 nucs/solvers/shaving_consistency_algorithm.py
 nucs/solvers/solver.py
@@ -93,7 +116,13 @@ tests/examples/test_queens.py
 tests/examples/test_schur_lemma.py
 tests/examples/test_sports_tournament_scheduling.py
 tests/examples/test_sudokus.py
+tests/examples/test_tsp.py
+tests/heuristics/__init__.py
+tests/heuristics/test_max_value_dom_heuristic.py
+tests/heuristics/test_mid_value_dom_heuristic.py
+tests/heuristics/test_min_value_dom_heuristic.py
 tests/problems/__init__.py
+tests/problems/test_circuit_problem.py
 tests/problems/test_problem.py
 tests/propagators/__init__.py
 tests/propagators/test_affine_eq.py
@@ -101,6 +130,7 @@ tests/propagators/test_affine_geq.py
 tests/propagators/test_affine_leq.py
 tests/propagators/test_alldifferent.py
 tests/propagators/test_count_eq.py
+tests/propagators/test_element_iv.py
 tests/propagators/test_element_lic.py
 tests/propagators/test_element_liv.py
 tests/propagators/test_exactly_eq.py
@@ -110,7 +140,9 @@ tests/propagators/test_max_eq.py
 tests/propagators/test_max_leq.py
 tests/propagators/test_min_eq.py
 tests/propagators/test_min_geq.py
+tests/propagators/test_no_sub_cycle.py
 tests/propagators/test_relation.py
+tests/propagators/test_scc.py
 tests/solvers/__init__.py
 tests/solvers/test_backtrack_solver.py
 tests/solvers/test_multiprocessing_solver.py

{nucs-3.0.0/NUCS.egg-info → nucs-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 3.0.0
+Version: 4.2.0
 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-3.0.0 → nucs-4.2.0}/docs/source/conf.py

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

{nucs-3.0.0 → nucs-4.2.0}/nucs/constants.py

@@ -14,12 +14,28 @@ import os
 
 from numba import bool, int32, int64, types, uint8, uint16  # type: ignore
 
-START = 0  # index corresponding the start of a values range
-END = 1  # index corresponding the end of a values range
+OPT_RESET = "RESET"
+OPT_PRUNE = "PRUNE"
+OPT_MODES = [OPT_RESET, OPT_PRUNE]
+
+RG_START = 0  # index corresponding the start of a values range
+RG_END = 1  # index corresponding the end of a values range
 
 MIN = 0  # min value of a domain
 MAX = 1  # max value of a domain
 
+DOM_UPDATE_IDX = 0
+DOM_UPDATE_EVENTS = 1
+
+EVENT_MASK_MIN = 1 << 0
+EVENT_MASK_MAX = 1 << 1
+EVENT_MASK_GROUND = 1 << 2
+EVENT_MASK_MIN_MAX = EVENT_MASK_MIN | EVENT_MASK_MAX
+EVENT_MASK_MIN_GROUND = EVENT_MASK_MIN | EVENT_MASK_GROUND
+EVENT_MASK_MAX_GROUND = EVENT_MASK_MAX | EVENT_MASK_GROUND
+EVENT_MASK_MIN_MAX_GROUND = EVENT_MASK_MIN | EVENT_MASK_MAX | EVENT_MASK_GROUND
+
+
 PROP_INCONSISTENCY = 0  # returned by a propagator when inconsistent
 PROP_CONSISTENCY = 1  # returned by a propagator when consistent
 PROP_ENTAILMENT = 2  # returned by a propagator when entailed
@@ -29,10 +45,6 @@ PROBLEM_UNBOUND = 1  # returned when the filtering of a problem has been complet
 PROBLEM_BOUND = 2  # returned when a problem is solved
 
 SIGNATURE_COMPUTE_DOMAINS = int64(int32[:, :], int32[:])  # domains, parameters
-SIGNATURE_DOM_HEURISTIC = int64(
-    int32[:, :, :], uint16[:, :], uint8[:], int64  # shr_domains_stack  # dom_update_stack  # stacks_top  # dom_idx
-)
-SIGNATURE_VAR_HEURISTIC = int64(int32[:, :, :], uint8[:])  # shr_domains_stack, stacks_top
 SIGNATURE_CONSISTENCY_ALG = int64(
     int64[:],  # statistics
     uint8[:],  # algorithms
@@ -43,14 +55,30 @@ SIGNATURE_CONSISTENCY_ALG = int64(
     uint16[:],  # props_dom_indices
     int32[:, :],  # props_dom_offsets
     int32[:],  # props_parameters
-    bool[:, :, :],  # shr_domains_propagators
+    uint8[:, :],  # shr_domains_propagators
     int32[:, :, :],  # shr_domains_stack
     bool[:, :],  # not_entailed_propagators_stack
     uint16[:, :],  # dom_update_stack
-    uint8[:],  # stacks_height
+    uint8[:],  # stacks_top
     bool[:],  # triggered_propagators
     int64[:],  # compute_domains_addrs
+    uint16[:],  # decision_domains
+)
+SIGNATURE_DOM_HEURISTIC = int64(
+    int32[:, :, :],  # shr_domains_stack
+    bool[:, :],  # not_entailed_propagators_stack
+    uint16[:, :],  # dom_update_stack
+    uint8[:],  # stacks_top
+    int64,  # dom_idx
+    int64[:, :],  # dom_heuristic_params
 )
+SIGNATURE_VAR_HEURISTIC = int64(
+    uint16[:],  # decision_variables
+    int32[:, :, :],  # shr_domains_stack
+    uint8[:],  # stacks_top
+    int64[:, :],  # var_heuristic_params
+)
+
 
 TYPE_COMPUTE_DOMAINS = types.FunctionType(SIGNATURE_COMPUTE_DOMAINS)
 TYPE_DOM_HEURISTIC = types.FunctionType(SIGNATURE_DOM_HEURISTIC)
@@ -59,7 +87,7 @@ TYPE_CONSISTENCY_ALG = types.FunctionType(SIGNATURE_CONSISTENCY_ALG)
 
 NUMBA_DISABLE_JIT = os.getenv("NUMBA_DISABLE_JIT")
 
-LOG_FORMAT = "%(asctime)s - %(processName)s - %(levelname)s - %(name)s - %(funcName)s - %(message)s"
+LOG_FORMAT = "[ %(asctime)s | %(processName)s | %(levelname)s ] %(name)s.%(funcName)s - %(message)s"
 LOG_LEVEL_DEBUG = "DEBUG"
 LOG_LEVEL_INFO = "INFO"
 LOG_LEVEL_WARNING = "WARNING"

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/alpha/__main__.py

@@ -16,8 +16,8 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.alpha.alpha_problem import AlphaProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.alpha

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/alpha/alpha_problem.py

@@ -12,7 +12,7 @@
 ###############################################################################
 from typing import Dict
 
-from numpy._typing import NDArray
+from numpy.typing import NDArray
 
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ALLDIFFERENT

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/bibd/__main__.py

@@ -16,8 +16,8 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.bibd.bibd_problem import BIBDProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MAX_VALUE
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.bibd -v 8 -b 14 -r 7 -k 4 -l 3 --symmetry_breaking
@@ -28,10 +28,12 @@ if __name__ == "__main__":
     parser.add_argument("-r", type=int)
     parser.add_argument("-k", type=int)
     parser.add_argument("-l", type=int)
-    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     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)
+    solver = BacktrackSolver(
+        problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level, stack_max_height=128
+    )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/donald/__main__.py

@@ -16,8 +16,8 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.donald.donald_problem import DonaldProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.donald

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/donald/donald_problem.py

@@ -38,9 +38,7 @@ class DonaldProblem(Problem):
                 [200, -1000, 100002, 9900, 100000, 20, 1000, 0, -99010, -1, 0],
             )
         )
-        self.add_propagator(
-            ([A, B, D, E, G, L, N, O, R, T], ALG_ALLDIFFERENT, []),
-        )
+        self.add_propagator(([A, B, D, E, G, L, N, O, R, T], ALG_ALLDIFFERENT, []))
 
     def solution_as_dict(self, solution: NDArray) -> Dict[str, int]:
         """

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/golomb/__main__.py

@@ -14,23 +14,39 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_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
+from nucs.solvers.multiprocessing_solver import MultiprocessingSolver
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.golomb -n 10 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
-    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     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("--processors", type=int, default=1)
+    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = GolombProblem(args.n, args.symmetry_breaking)
     consistency_alg_golomb = register_consistency_algorithm(golomb_consistency_algorithm)
-    solver = BacktrackSolver(problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level)
-    solution = solver.minimize(problem.length_idx)
+    solver = (
+        MultiprocessingSolver(
+            [
+                BacktrackSolver(
+                    prob, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stack_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
+        )
+    )
+    solution = solver.minimize(problem.length_idx, mode=args.opt_mode)
     print(solver.get_statistics())
     if solution is not None:
         print(solution[: (args.n - 1)])

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/golomb/golomb_problem.py

@@ -16,17 +16,17 @@ import numpy as np
 from numba import njit  # type: ignore
 from numpy.typing import NDArray
 
-from nucs.constants import MAX, MIN
+from nucs.constants import EVENT_MASK_GROUND, EVENT_MASK_MIN, MAX, MIN
+from nucs.heuristics.heuristics import first_not_instantiated_var_heuristic
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_AFFINE_LEQ, ALG_ALLDIFFERENT, add_propagators
 from nucs.solvers.bound_consistency_algorithm import bound_consistency_algorithm
-from nucs.solvers.heuristics import first_not_instantiated_var_heuristic
 
 GOLOMB_LENGTHS = np.array([0, 0, 1, 3, 6, 11, 17, 25, 34, 44, 55, 72, 85, 106, 127])
 
 
 @njit(cache=True)
-def sum_first(n: np.uint32) -> np.uint32:
+def sum_first(n: int) -> int:
     """
     Returns the sum of the first n integers.
     :param n: an integer
@@ -36,7 +36,7 @@ def sum_first(n: np.uint32) -> np.uint32:
 
 
 @njit(cache=True)
-def index(mark_nb: np.uint32, i: np.uint32, j: np.uint32) -> np.uint32:
+def index(mark_nb: int, i: int, j: int) -> int:
     """
     Returns the index of the distance variable between two marks.
     :param mark_nb: the total number of marks
@@ -47,22 +47,6 @@ def index(mark_nb: np.uint32, i: np.uint32, j: np.uint32) -> np.uint32:
     return i * mark_nb - sum_first(i) + j - i - 1
 
 
-@njit(cache=True)
-def init_domains(dist_nb: int, mark_nb: int) -> NDArray:
-    """
-    Returns the domains.
-    :param dist_nb: the number of distances
-    :param mark_nb: the number of marks
-    :return: a Numpy array of domains
-    """
-    domains = np.empty((dist_nb, 2), dtype=np.int32)
-    for i in range(0, mark_nb - 1):
-        for j in range(i + 1, mark_nb):
-            domains[index(mark_nb, i, j), MIN] = GOLOMB_LENGTHS[j - i + 1] if j - i + 1 < mark_nb else sum_first(j - i)
-    domains[:, MAX] = sum_first(dist_nb)
-    return domains
-
-
 class GolombProblem(Problem):
     """
     This is the famous Golomb ruler problem.
@@ -77,7 +61,15 @@ class GolombProblem(Problem):
     """
 
     def __init__(self, mark_nb: int, symmetry_breaking: bool = True) -> None:
-        super().__init__(init_domains(sum_first(mark_nb - 1), mark_nb))
+        dist_nb = sum_first(mark_nb - 1)
+        domains = np.empty((dist_nb, 2), dtype=np.int32)
+        for i in range(0, mark_nb - 1):
+            for j in range(i + 1, mark_nb):
+                domains[index(mark_nb, i, j), MIN] = (
+                    GOLOMB_LENGTHS[j - i + 1] if j - i + 1 < mark_nb else sum_first(j - i)
+                )
+        domains[:, MAX] = sum_first(dist_nb) - sum_first(dist_nb - mark_nb)
+        super().__init__(domains)
         self.length_idx = index(mark_nb, 0, mark_nb - 1)  # we want to minimize this
         # dist_ij = mark_j - mark_i for j > i
         # mark_j = dist_0j for j > 0
@@ -90,7 +82,7 @@ class GolombProblem(Problem):
                         [1, -1, -1, 0],
                     )
                 )
-        self.add_propagator((list(range(self.variable_nb)), ALG_ALLDIFFERENT, []))
+        self.add_propagator((list(range(self.shr_domain_nb)), ALG_ALLDIFFERENT, []))
         # redundant constraints
         for i in range(mark_nb - 1):
             for j in range(i + 1, mark_nb):
@@ -130,6 +122,7 @@ def golomb_consistency_algorithm(
     stacks_top: NDArray,
     triggered_propagators: NDArray,
     compute_domains_addrs: NDArray,
+    decision_domains: NDArray,
 ) -> int:
     """
     Applies a custom consistency algorithm for the Golomb Ruler problem.
@@ -137,9 +130,12 @@ def golomb_consistency_algorithm(
     :param problem: the problem
     :return: the status as an int
     """
+    top = stacks_top[0]
     # first prune the search space
     mark_nb = (1 + int(math.sqrt(8 * len(dom_indices_arr) + 1))) // 2
-    ni_var_idx = first_not_instantiated_var_heuristic(shr_domains_stack, stacks_top)  # no domains shared between vars
+    ni_var_idx = first_not_instantiated_var_heuristic(
+        decision_domains, shr_domains_stack, stacks_top, None
+    )  # no domains shared between vars
     if 1 < ni_var_idx < mark_nb - 1:  # otherwise useless
         used_distance = np.zeros(sum_first(mark_nb - 2) + 1, dtype=np.bool)
         # a reusable array for storing the minimal sum of different integers:
@@ -148,7 +144,7 @@ def golomb_consistency_algorithm(
         # the following will mark at most sum(n-3) numbers as used
         # hence there will be at least n-2 unused numbers greater than 0
         for var_idx in range(index(mark_nb, ni_var_idx - 2, ni_var_idx - 1) + 1):
-            dist = shr_domains_stack[stacks_top[0], dom_indices_arr[var_idx], MIN]  # no offset
+            dist = shr_domains_stack[top, dom_indices_arr[var_idx], MIN]  # no offset
             if dist < len(used_distance):
                 used_distance[dist] = True
         # let's compute the sum of non-used numbers
@@ -161,14 +157,16 @@ def golomb_consistency_algorithm(
         for i in range(ni_var_idx - 1, mark_nb - 1):
             for j in range(i + 1, mark_nb):
                 dom_idx = dom_indices_arr[index(mark_nb, i, j)]
-                shr_domains_stack[stacks_top[0], dom_idx, MIN] = minimal_sum[j - i]  # no offset
+                shr_domains_stack[top, dom_idx, MIN] = minimal_sum[j - i]  # no offset
+                events = EVENT_MASK_MIN
+                if shr_domains_stack[top, dom_idx, MIN] == shr_domains_stack[top, dom_idx, MAX]:
+                    events |= EVENT_MASK_GROUND
                 add_propagators(
                     triggered_propagators,
-                    not_entailed_propagators_stack,
-                    stacks_top,
+                    not_entailed_propagators_stack[top],
                     shr_domains_propagators,
                     dom_idx,
-                    MIN,
+                    events,
                 )
     return bound_consistency_algorithm(
         statistics,
@@ -187,4 +185,5 @@ def golomb_consistency_algorithm(
         stacks_top,
         triggered_propagators,
         compute_domains_addrs,
+        decision_domains,
     )

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/knapsack/__main__.py

@@ -14,16 +14,17 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_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
-from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.knapsack
 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)
     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],
@@ -36,6 +37,6 @@ if __name__ == "__main__":
         dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE,
         log_level=args.log_level,
     )
-    solution = solver.maximize(problem.weight)
+    solution = solver.maximize(problem.weight, mode=args.opt_mode)
     print(solver.get_statistics())
     print(solution)

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/magic_sequence/__main__.py

@@ -16,22 +16,24 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.magic_sequence.magic_sequence_problem import MagicSequenceProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_LAST_NOT_INSTANTIATED
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_sequence -n 100
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=100)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=100)
     args = parser.parse_args()
     problem = MagicSequenceProblem(args.n)
     solver = BacktrackSolver(
         problem,
-        var_heuristic_idx=VAR_HEURISTIC_LAST_NOT_INSTANTIATED,
+        decision_domains=list(range(args.n - 1, -1, -1)),
+        var_heuristic_idx=VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
         dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
         log_level=args.log_level,
+        stack_max_height=128,
     )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/magic_sequence/magic_sequence_problem.py

@@ -16,8 +16,7 @@ from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_COUNT_EQ
 
 class MagicSequenceProblem(Problem):
     """
-    Find a sequence x_0, ... x_n-1
-    such that each x_i is the number of occurences of i in the sequence.
+    Find a sequence x_0, ... x_n-1 such that each x_i is the number of occurrences of i in the sequence.
 
     CSPLIB problem #19 - https://www.csplib.org/Problems/prob019/
     """
@@ -27,7 +26,6 @@ class MagicSequenceProblem(Problem):
         Inits the problem.
         :param n: the size of the sequence
         """
-        self.n = n
         super().__init__([(0, n)] * n)
         for i in range(n):
             self.add_propagator((list(range(n)) + [i], ALG_COUNT_EQ, [i]))

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/magic_square/__main__.py

@@ -16,16 +16,16 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.magic_square.magic_square_problem import MagicSquareProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_square -n 4 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
+    parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
     parser.add_argument("-n", type=int)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
-    parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
     args = parser.parse_args()
     problem = MagicSquareProblem(args.n, args.symmetry_breaking)
     solver = BacktrackSolver(

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/quasigroup/__main__.py

@@ -16,16 +16,16 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.quasigroup.quasigroup_problem import Quasigroup5Problem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.quasigroup -n 10 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
+    parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
     parser.add_argument("-n", type=int, default=10)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
-    parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
     args = parser.parse_args()
     problem = Quasigroup5Problem(args.n, args.symmetry_breaking)
     solver = BacktrackSolver(

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/queens/__main__.py

@@ -16,20 +16,20 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.queens.queens_problem import QueensProblem
+from nucs.heuristics.heuristics import VAR_HEURISTIC_FIRST_NOT_INSTANTIATED, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_BC, CONSISTENCY_ALG_SHAVING
-from nucs.solvers.heuristics import VAR_HEURISTIC_FIRST_NOT_INSTANTIATED, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.multiprocessing_solver import MultiprocessingSolver
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.queens -n 10
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=10)
+    parser.add_argument("--ff", type=bool, action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=10)
     parser.add_argument("--processors", type=int, default=1)
     parser.add_argument("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=False)
-    parser.add_argument("--ff", type=bool, action=argparse.BooleanOptionalAction, default=False)
     args = parser.parse_args()
     problem = QueensProblem(args.n)
     solver = (

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/schur_lemma/__main__.py

@@ -22,11 +22,11 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.schur_lemma -n 20 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=20)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=20)
     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)
+    solver = BacktrackSolver(problem, log_level=args.log_level, stack_max_height=128)
     solver.solve_all()
     print(solver.get_statistics())

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/sports_tournament_scheduling/__main__.py

@@ -18,15 +18,15 @@ from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 from nucs.examples.sports_tournament_scheduling.sports_tournament_scheduling_problem import (
     SportsTournamentSchedulingProblem,
 )
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 from nucs.solvers.backtrack_solver import BacktrackSolver
-from nucs.solvers.heuristics import DOM_HEURISTIC_MIN_VALUE, VAR_HEURISTIC_SMALLEST_DOMAIN
 
 # Run with the following command (the second run is much faster because the code has been compiled):
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.sports_tournament_scheduling -n 8
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=8)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=8)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = SportsTournamentSchedulingProblem(args.n, args.symmetry_breaking)

{nucs-3.0.0 → nucs-4.2.0}/nucs/examples/sudoku/sudoku_problem.py

@@ -29,21 +29,7 @@ class SudokuProblem(LatinSquareProblem):
         super().__init__(list(range(1, 10)), givens)
         for i in range(3):
             for j in range(3):
-                offset = i * 27 + j * 3
+                o = i * 27 + j * 3
                 self.add_propagator(
-                    (
-                        [
-                            0 + offset,
-                            1 + offset,
-                            2 + offset,
-                            9 + offset,
-                            10 + offset,
-                            11 + offset,
-                            18 + offset,
-                            19 + offset,
-                            20 + offset,
-                        ],
-                        ALG_ALLDIFFERENT,
-                        [],
-                    )
+                    ([0 + o, 1 + o, 2 + o, 9 + o, 10 + o, 11 + o, 18 + o, 19 + o, 20 + o], ALG_ALLDIFFERENT, [])
                 )