NUCS 2.3.0__tar.gz → 4.0.0__tar.gz

{nucs-2.3.0 → nucs-4.0.0/NUCS.egg-info}/PKG-INFO

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

@@ -47,7 +47,25 @@ 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/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_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 +76,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 +87,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 +113,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 +127,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 +137,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-2.3.0/NUCS.egg-info → nucs-4.0.0}/PKG-INFO

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

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

{nucs-2.3.0 → nucs-4.0.0}/nucs/constants.py

@@ -14,12 +14,24 @@ 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
+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,8 +41,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[:], int32[:])  # shr_domain, shr_domain_copy
-SIGNATURE_VAR_HEURISTIC = int64(int32[:, :])  # shr_domains
 SIGNATURE_CONSISTENCY_ALG = int64(
     int64[:],  # statistics
     uint8[:],  # algorithms
@@ -41,14 +51,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(
+    int64[:, :],  # dom_heuristic_params
+    int32[:, :, :],  # shr_domains_stack
+    bool[:, :],  # not_entailed_propagators_stack
+    uint16[:, :],  # dom_update_stack
+    uint8[:],  # stacks_top
+    int64,  # dom_idx
 )
+SIGNATURE_VAR_HEURISTIC = int64(
+    int64[:, :],  # var_heuristic_params
+    uint16[:],  # decision_variables
+    int32[:, :, :],  # shr_domains_stack
+    uint8[:],  # stacks_top
+)
+
 
 TYPE_COMPUTE_DOMAINS = types.FunctionType(SIGNATURE_COMPUTE_DOMAINS)
 TYPE_DOM_HEURISTIC = types.FunctionType(SIGNATURE_DOM_HEURISTIC)
@@ -57,7 +83,7 @@ TYPE_CONSISTENCY_ALG = types.FunctionType(SIGNATURE_CONSISTENCY_ALG)
 
 NUMBA_DISABLE_JIT = os.getenv("NUMBA_DISABLE_JIT")
 
-LOG_FORMAT = "%(asctime)s - %(levelname)s - %(name)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-2.3.0 → nucs-4.0.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-2.3.0 → nucs-4.0.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-2.3.0 → nucs-4.0.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

{nucs-2.3.0 → nucs-4.0.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-2.3.0 → nucs-4.0.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-2.3.0 → nucs-4.0.0}/nucs/examples/golomb/golomb_problem.py

@@ -16,11 +16,11 @@ 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])
 
@@ -90,7 +90,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):
@@ -127,9 +127,10 @@ def golomb_consistency_algorithm(
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
-    stacks_height: NDArray,
+    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 +138,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[0])  # no domains shared between vars
+    ni_var_idx = first_not_instantiated_var_heuristic(
+        None, decision_domains, shr_domains_stack, stacks_top
+    )  # 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 +152,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[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,9 +165,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[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[0], shr_domains_propagators, dom_idx, MIN
+                    triggered_propagators,
+                    not_entailed_propagators_stack[top],
+                    shr_domains_propagators,
+                    dom_idx,
+                    events,
                 )
     return bound_consistency_algorithm(
         statistics,
@@ -179,7 +190,8 @@ def golomb_consistency_algorithm(
         shr_domains_stack,
         not_entailed_propagators_stack,
         dom_update_stack,
-        stacks_height,
+        stacks_top,
         triggered_propagators,
         compute_domains_addrs,
+        decision_domains,
     )

{nucs-2.3.0 → nucs-4.0.0}/nucs/examples/knapsack/__main__.py

@@ -16,8 +16,8 @@ from rich import print
 
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
 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

{nucs-2.3.0 → nucs-4.0.0}/nucs/examples/magic_sequence/__main__.py

@@ -16,8 +16,8 @@ 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
@@ -29,7 +29,8 @@ if __name__ == "__main__":
     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,
     )

{nucs-2.3.0 → nucs-4.0.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-2.3.0 → nucs-4.0.0}/nucs/examples/magic_square/__main__.py

@@ -16,8 +16,8 @@ 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

{nucs-2.3.0 → nucs-4.0.0}/nucs/examples/quasigroup/__main__.py

@@ -16,8 +16,8 @@ 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

{nucs-2.3.0 → nucs-4.0.0}/nucs/examples/queens/__main__.py

@@ -16,9 +16,9 @@ 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):
@@ -32,17 +32,27 @@ if __name__ == "__main__":
     parser.add_argument("--ff", type=bool, action=argparse.BooleanOptionalAction, default=False)
     args = parser.parse_args()
     problem = QueensProblem(args.n)
-    problems = problem.split(args.processors, 0)
-    solver = MultiprocessingSolver(
-        [
-            BacktrackSolver(
-                problem,
-                consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
-                var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
-                log_level=args.log_level,
-            )
-            for problem in problems
-        ]
+    solver = (
+        MultiprocessingSolver(
+            [
+                BacktrackSolver(
+                    problem,
+                    consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+                    var_heuristic_idx=(
+                        VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
+                    ),
+                    log_level=args.log_level,
+                )
+                for problem in problem.split(args.processors, 0)
+            ]
+        )
+        if args.processors > 1
+        else BacktrackSolver(
+            problem,
+            consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+            var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
+            log_level=args.log_level,
+        )
     )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-2.3.0 → nucs-4.0.0}/nucs/examples/sports_tournament_scheduling/__main__.py

@@ -18,8 +18,8 @@ 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

{nucs-2.3.0 → nucs-4.0.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, [])
                 )

nucs-4.0.0/nucs/examples/tsp/__main__.py

@@ -0,0 +1,43 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import argparse
+
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
+from nucs.examples.tsp.tsp_instances import TSP_INSTANCES
+from nucs.examples.tsp.tsp_problem import TSPProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_COST, VAR_HEURISTIC_MAX_REGRET
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_BC, CONSISTENCY_ALG_SHAVING
+
+# 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
+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("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=False)
+    args = parser.parse_args()
+    tsp_instance = TSP_INSTANCES[args.name]
+    problem = TSPProblem(tsp_instance)
+    solver = BacktrackSolver(
+        problem,
+        consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+        decision_domains=list(range(len(tsp_instance))),
+        var_heuristic_idx=VAR_HEURISTIC_MAX_REGRET,
+        var_heuristic_params=tsp_instance,
+        dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,
+        dom_heuristic_params=tsp_instance,
+        log_level=args.log_level,
+    )
+    solution = solver.minimize(problem.shr_domain_nb - 1)
+    print(solver.get_statistics())

nucs-4.0.0/nucs/examples/tsp/total_cost_propagator.py

@@ -0,0 +1,79 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import sys
+
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.constants import EVENT_MASK_MIN_MAX, MAX, MIN, PROP_CONSISTENCY, PROP_INCONSISTENCY
+
+
+def get_complexity_total_cost(n: int, parameters: NDArray) -> float:
+    """
+    Returns the time complexity of the propagator as a float.
+    :param n: the number of variables
+    :param parameters: the parameters, unused here
+    :return: a float
+    """
+    return 2 * n
+
+
+def get_triggers_total_cost(n: int, parameters: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :param parameters: the parameters, unused here
+    :return: an array of triggers
+    """
+    triggers = np.full(n, dtype=np.uint8, fill_value=EVENT_MASK_MIN_MAX)
+    triggers[-1] = 0
+    return triggers
+
+
+@njit(cache=True)
+def compute_domains_total_cost(domains: NDArray, parameters: NDArray) -> int:
+    """
+    :param domains: the domains of the variables
+    :param parameters: the parameters of the propagator
+    :return: the status of the propagation (consistency, inconsistency or entailment) as an int
+    """
+    n = len(domains) - 1
+    used = np.zeros(n, dtype=np.bool)
+    for i in range(n):
+        if domains[i, MIN] == domains[i, MAX]:
+            used[domains[i, MIN]] = True
+    global_min = global_max = 0
+    for i in range(n):
+        local_min = sys.maxsize
+        local_max = 0
+        if domains[i, MIN] == domains[i, MAX]:
+            local_min = local_max = parameters[i * n + domains[i, MIN]]
+        else:
+            for value in range(domains[i, MIN], domains[i, MAX] + 1):
+                if not used[value]:
+                    cost = parameters[i * n + value]
+                    if cost > 0:
+                        if cost < local_min:
+                            local_min = cost
+                        if cost > local_max:
+                            local_max = cost
+            if local_min > local_max:
+                return PROP_INCONSISTENCY
+        global_min += local_min
+        global_max += local_max
+    domains[-1, MIN] = max(domains[-1, MIN], global_min)
+    domains[-1, MAX] = min(domains[-1, MAX], global_max)
+    if domains[-1, MIN] > domains[-1, MAX]:
+        return PROP_INCONSISTENCY
+    return PROP_CONSISTENCY