NUCS 2.0.0__tar.gz → 2.1.0__tar.gz

{nucs-2.0.0 → nucs-2.1.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.0.0
+Version: 2.1.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
@@ -35,8 +35,9 @@ Requires-Dist: numpy==2.0.1
 
 ## TLDR
 NuCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-Because it is 100% written in Python, NuCS is easy to install and use.
-NuCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+Because it is 100% written in Python, 
+NuCS is easy to install and allows to model complex problems in a few lines of code.
+The NuCS solver is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
 
 ## Installation
 ```bash

{nucs-2.0.0 → nucs-2.1.0}/NUCS.egg-info/SOURCES.txt

@@ -74,9 +74,11 @@ nucs/propagators/relation_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
 tests/__init__.py
 tests/examples/test_alpha.py

{nucs-2.0.0/NUCS.egg-info → nucs-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.0.0
+Version: 2.1.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
@@ -35,8 +35,9 @@ Requires-Dist: numpy==2.0.1
 
 ## TLDR
 NuCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-Because it is 100% written in Python, NuCS is easy to install and use.
-NuCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+Because it is 100% written in Python, 
+NuCS is easy to install and allows to model complex problems in a few lines of code.
+The NuCS solver is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
 
 ## Installation
 ```bash

{nucs-2.0.0 → nucs-2.1.0}/README.md

@@ -13,8 +13,9 @@
 
 ## TLDR
 NuCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
-Because it is 100% written in Python, NuCS is easy to install and use.
-NuCS is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
+Because it is 100% written in Python, 
+NuCS is easy to install and allows to model complex problems in a few lines of code.
+The NuCS solver is also very fast because it is powered by [Numpy](https://numpy.org/) and [Numba](https://numba.pydata.org/).
 
 ## Installation
 ```bash

{nucs-2.0.0 → nucs-2.1.0}/docs/source/conf.py

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

{nucs-2.0.0 → nucs-2.1.0}/nucs/constants.py

@@ -42,8 +42,10 @@ SIGNATURE_CONSISTENCY_ALG = int64(
     int32[:, :],  # props_dom_offsets
     int32[:],  # props_parameters
     bool[:, :, :],  # shr_domains_propagators
-    int32[:, :],  # shr_domains_arr
-    bool[:],  # not_entailed_propagators
+    int32[:, :, :],  # shr_domains_stack
+    bool[:, :],  # not_entailed_propagators_stack
+    uint16[:, :],  # dom_update_stack
+    uint8[:],  # stacks_height
     bool[:],  # triggered_propagators
     int64[:],  # compute_domains_addrs
 )

{nucs-2.0.0 → nucs-2.1.0}/nucs/examples/golomb/golomb_problem.py

@@ -18,7 +18,7 @@ from numpy.typing import NDArray
 
 from nucs.constants import MAX, MIN
 from nucs.problems.problem import Problem
-from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_AFFINE_LEQ, ALG_ALLDIFFERENT
+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
 
@@ -124,8 +124,10 @@ def golomb_consistency_algorithm(
     props_dom_offsets: NDArray,
     props_parameters: NDArray,
     shr_domains_propagators: NDArray,
-    shr_domains_arr: NDArray,
-    not_entailed_propagators: NDArray,
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
     triggered_propagators: NDArray,
     compute_domains_addrs: NDArray,
 ) -> int:
@@ -137,7 +139,7 @@ def golomb_consistency_algorithm(
     """
     # 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_arr)  # no domains shared between vars
+    ni_var_idx = first_not_instantiated_var_heuristic(shr_domains_stack[0])  # 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:
@@ -146,7 +148,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_arr[dom_indices_arr[var_idx], MIN]  # no offset
+            dist = shr_domains_stack[0, 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
@@ -158,7 +160,11 @@ def golomb_consistency_algorithm(
             distance += 1
         for i in range(ni_var_idx - 1, mark_nb - 1):
             for j in range(i + 1, mark_nb):
-                shr_domains_arr[dom_indices_arr[index(mark_nb, i, j)], MIN] = minimal_sum[j - i]  # no offset
+                dom_idx = dom_indices_arr[index(mark_nb, i, j)]
+                shr_domains_stack[0, dom_idx, MIN] = minimal_sum[j - i]  # no offset
+                add_propagators(
+                    triggered_propagators, not_entailed_propagators_stack[0], shr_domains_propagators, dom_idx, MIN
+                )
     return bound_consistency_algorithm(
         statistics,
         algorithms,
@@ -170,8 +176,10 @@ def golomb_consistency_algorithm(
         props_dom_offsets,
         props_parameters,
         shr_domains_propagators,
-        shr_domains_arr,
-        not_entailed_propagators,
+        shr_domains_stack,
+        not_entailed_propagators_stack,
+        dom_update_stack,
+        stacks_height,
         triggered_propagators,
         compute_domains_addrs,
     )

{nucs-2.0.0 → nucs-2.1.0}/nucs/examples/queens/__main__.py

@@ -16,6 +16,7 @@ from rich import print
 
 from nucs.examples.queens.queens_problem import QueensProblem
 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
 from nucs.statistics import get_statistics
@@ -26,6 +27,7 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     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)
@@ -34,6 +36,7 @@ if __name__ == "__main__":
         [
             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,
             )
             for problem in problems

{nucs-2.0.0 → nucs-2.1.0}/nucs/propagators/propagators.py

@@ -124,16 +124,30 @@ ALG_RELATION = register_propagator(get_triggers_relation, get_complexity_relatio
 
 
 @njit(cache=True)
-def pop_propagator(triggered_propagators: NDArray, not_entailed_propagators: NDArray, previous_prop_idx: int) -> int:
+def pop_propagator(triggered_propagators: NDArray, previous_prop_idx: int) -> int:
     """
     Pops a propagator to be filtered.
     :param triggered_propagators: the candidate propagators
-    :param not_entailed_propagators: the propagators that are not entailed yet
     :param previous_prop_idx: the index of the previous propagator which has been selected
     :return: an index
     """
-    for prop_idx, triggered_prop in enumerate(triggered_propagators):
-        if triggered_prop and not_entailed_propagators[prop_idx] and prop_idx != previous_prop_idx:
+    for prop_idx in range(len(triggered_propagators)):
+        if triggered_propagators[prop_idx] and prop_idx != previous_prop_idx:
             triggered_propagators[prop_idx] = False
             return prop_idx
     return -1
+
+
+@njit(cache=True)
+def add_propagators(
+    triggered_propagators: NDArray,
+    not_entailed_propagators: NDArray,
+    shr_domains_propagators: NDArray,
+    dom_idx: int,
+    bound: int,
+) -> None:
+    for prop_idx in range(len(triggered_propagators)):
+        if shr_domains_propagators[dom_idx, bound, prop_idx] and not_entailed_propagators[prop_idx]:
+            triggered_propagators[prop_idx] = True
+    # np.logical_or(triggered_propagators, shr_domains_propagators[dom_idx, bound], triggered_propagators)
+    # np.logical_and(triggered_propagators, not_entailed_propagators, triggered_propagators)

{nucs-2.0.0 → nucs-2.1.0}/nucs/solvers/backtrack_solver.py

@@ -31,7 +31,8 @@ from nucs.constants import (
 )
 from nucs.numba_helper import build_function_address_list, function_from_address
 from nucs.problems.problem import Problem
-from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS
+from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS, add_propagators
+from nucs.solvers.choice_points import backtrack, cp_init, cp_put
 from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_BC, CONSISTENCY_ALG_FCTS
 from nucs.solvers.heuristics import (
     DOM_HEURISTIC_FCTS,
@@ -44,7 +45,6 @@ from nucs.statistics import (
     STATS_IDX_OPTIMIZER_SOLUTION_NB,
     STATS_IDX_PROBLEM_PROPAGATOR_NB,
     STATS_IDX_PROBLEM_VARIABLE_NB,
-    STATS_IDX_SOLVER_BACKTRACK_NB,
     STATS_IDX_SOLVER_CHOICE_DEPTH,
     STATS_IDX_SOLVER_CHOICE_NB,
     STATS_IDX_SOLVER_SOLUTION_NB,
@@ -83,7 +83,7 @@ class BacktrackSolver(Solver):
     ):
         """
         Inits the solver.
-        :param problem: the problem
+        :param problem: the problem to be solved
         :param consistency_alg_idx: the index of the consistency algorithm
         :param var_heuristic_idx: the index of the heuristic for selecting a variable/domain
         :param dom_heuristic_idx: the index of the heuristic for reducing a domain
@@ -98,10 +98,16 @@ class BacktrackSolver(Solver):
         self.problem = problem
         # choice points
         self.shr_domains_stack = np.empty((stack_max_height, self.problem.variable_nb, 2), dtype=np.int32)
-        self.shr_domains_stack[0] = problem.shr_domains_lst
         self.not_entailed_propagators_stack = np.empty((stack_max_height, self.problem.propagator_nb), dtype=np.bool)
-        self.not_entailed_propagators_stack[0] = True
+        self.dom_update_stack = np.empty((stack_max_height, 2), dtype=np.uint16)
         self.stacks_height = np.ones((1,), dtype=np.uint8)
+        cp_init(
+            self.shr_domains_stack,
+            self.not_entailed_propagators_stack,
+            self.dom_update_stack,
+            self.stacks_height,
+            np.array(problem.shr_domains_lst),
+        )
         # statistics
         self.statistics = init_statistics()
         self.statistics[STATS_IDX_PROBLEM_PROPAGATOR_NB] = self.problem.propagator_nb
@@ -148,6 +154,7 @@ class BacktrackSolver(Solver):
                 self.problem.shr_domains_propagators,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
@@ -165,6 +172,7 @@ class BacktrackSolver(Solver):
                 self.problem,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
             )
@@ -199,6 +207,7 @@ class BacktrackSolver(Solver):
                 self.problem.shr_domains_propagators,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
@@ -216,8 +225,10 @@ class BacktrackSolver(Solver):
                 self.statistics,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
+                self.problem.shr_domains_propagators,
             ):
                 break
 
@@ -265,6 +276,7 @@ class BacktrackSolver(Solver):
                 self.problem.shr_domains_propagators,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
@@ -283,6 +295,7 @@ class BacktrackSolver(Solver):
                 self.problem,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
             )
@@ -318,6 +331,7 @@ class BacktrackSolver(Solver):
                 self.problem.shr_domains_propagators,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
@@ -335,43 +349,20 @@ class BacktrackSolver(Solver):
                 self.statistics,
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
+                self.dom_update_stack,
                 self.stacks_height,
                 self.triggered_propagators,
+                self.problem.shr_domains_propagators,
             ):
                 break
         solution_queue.put((processor_idx, None, self.statistics))
 
 
-@njit(cache=True)
-def backtrack(
-    statistics: NDArray,
-    shr_domains_stack: NDArray,
-    not_entailed_propagators_stack: NDArray,
-    stacks_height: NDArray,
-    triggered_propagators: NDArray,
-) -> bool:
-    """
-    Backtracks and updates the problem's domains.
-    :param statistics: the statistics array
-    :param shr_domains_stack: the stack of shared domains
-    :param not_entailed_propagators_stack: the stack of not entailed propagators
-    :param stacks_height: the height of both stacks
-    :return: true iff it is possible to backtrack
-    """
-    if stacks_height[0] == 1:
-        return False
-    stacks_height[0] -= 1
-    shr_domains_stack[0, :, :] = shr_domains_stack[stacks_height[0], :, :]
-    not_entailed_propagators_stack[0, :] = not_entailed_propagators_stack[stacks_height[0], :]
-    statistics[STATS_IDX_SOLVER_BACKTRACK_NB] += 1
-    triggered_propagators[:] = not_entailed_propagators_stack[0, :]  # numba does not support copyto
-    return True
-
-
 def reset(
     problem: Problem,
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
     stacks_height: NDArray,
     triggered_propagators: NDArray,
 ) -> None:
@@ -383,9 +374,13 @@ def reset(
     :param stacks_height: the height of both stacks
     :param triggered_propagators: the list of triggered propagators
     """
-    shr_domains_stack[0] = problem.shr_domains_lst
-    not_entailed_propagators_stack[0, :] = True
-    stacks_height[0] = 1
+    cp_init(
+        shr_domains_stack,
+        not_entailed_propagators_stack,
+        dom_update_stack,
+        stacks_height,
+        np.array(problem.shr_domains_lst),
+    )
     triggered_propagators.fill(True)
 
 
@@ -403,6 +398,7 @@ def solve_one(
     shr_domains_propagators: NDArray,
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
     stacks_height: NDArray,
     triggered_propagators: NDArray,
     consistency_alg_idx: int,
@@ -462,8 +458,10 @@ def solve_one(
             props_dom_offsets,
             props_parameters,
             shr_domains_propagators,
-            shr_domains_stack[0],
-            not_entailed_propagators_stack[0],
+            shr_domains_stack,
+            not_entailed_propagators_stack,
+            dom_update_stack,
+            stacks_height,
             triggered_propagators,
             compute_domains_addrs,
         )
@@ -472,15 +470,27 @@ def solve_one(
             return get_solution(shr_domains_stack[0], dom_indices_arr, dom_offsets_arr)
         elif status == PROBLEM_UNBOUND:
             dom_idx = var_heuristic_fct(shr_domains_stack[0])
-            shr_domains_stack[stacks_height[0], :, :] = shr_domains_stack[0, :, :]
-            not_entailed_propagators_stack[stacks_height[0], :] = not_entailed_propagators_stack[0, :]
-            stacks_height[0] += 1
-            event = dom_heuristic_fct(shr_domains_stack[0, dom_idx], shr_domains_stack[stacks_height[0] - 1, dom_idx])
-            np.logical_or(triggered_propagators, shr_domains_propagators[dom_idx, event], triggered_propagators)
+            cp_put(shr_domains_stack, not_entailed_propagators_stack, dom_update_stack, stacks_height, dom_idx)
+            cp_idx = stacks_height[0] - 1
+            event = dom_heuristic_fct(shr_domains_stack[0, dom_idx], shr_domains_stack[cp_idx, dom_idx])
+            dom_update_stack[cp_idx, 1] = event
+            add_propagators(
+                triggered_propagators,
+                not_entailed_propagators_stack[0],
+                shr_domains_propagators,
+                dom_idx,
+                event,
+            )
             statistics[STATS_IDX_SOLVER_CHOICE_NB] += 1
             if stacks_height[0] - 1 > statistics[STATS_IDX_SOLVER_CHOICE_DEPTH]:
                 statistics[STATS_IDX_SOLVER_CHOICE_DEPTH] = stacks_height[0] - 1
         elif not backtrack(
-            statistics, shr_domains_stack, not_entailed_propagators_stack, stacks_height, triggered_propagators
+            statistics,
+            shr_domains_stack,
+            not_entailed_propagators_stack,
+            dom_update_stack,
+            stacks_height,
+            triggered_propagators,
+            shr_domains_propagators,
         ):
             return None

{nucs-2.0.0 → nucs-2.1.0}/nucs/solvers/bound_consistency_algorithm.py

@@ -28,7 +28,7 @@ from nucs.constants import (
     TYPE_COMPUTE_DOMAINS,
 )
 from nucs.numba_helper import function_from_address
-from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS, pop_propagator
+from nucs.propagators.propagators import COMPUTE_DOMAINS_FCTS, add_propagators, pop_propagator
 from nucs.solvers.solver import is_solved
 from nucs.statistics import (
     STATS_IDX_PROBLEM_FILTER_NB,
@@ -51,8 +51,10 @@ def bound_consistency_algorithm(
     props_dom_offsets: NDArray,
     props_parameters: NDArray,
     shr_domains_propagators: NDArray,
-    shr_domains_arr: NDArray,
-    not_entailed_propagators: NDArray,
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
     triggered_propagators: NDArray,
     compute_domains_addrs: NDArray,
 ) -> int:
@@ -70,8 +72,11 @@ def bound_consistency_algorithm(
     :param shr_domains_propagators: a Numpy array of booleans indexed
     by shared domain indices, MIN/MAX and propagators; true means that the propagator has to be triggered when the MIN
     or MAX of the shared domain has changed
-    :param shr_domains_arr: the current shared domains
-    :param not_entailed_propagators: the propagators currently not entailed
+    :param shr_domains_stack: a stack of shared domains;
+    the first level correspond to the current shared domains, the rest correspond to the choice points
+    :param not_entailed_propagators_stack: a stack not entailed propagators;
+    the first level correspond to the propagators currently not entailed, the rest correspond to the choice points
+    :param stacks_height: the height of the stacks as a Numpy array
     :param triggered_propagators: the Numpy array of triggered propagators
     :param compute_domains_addrs: the addresses of the compute_domains functions
     :return: a status (consistency, inconsistency or entailment) as an integer
@@ -79,9 +84,9 @@ def bound_consistency_algorithm(
     statistics[STATS_IDX_PROBLEM_FILTER_NB] += 1
     prop_idx = -1
     while True:
-        prop_idx = pop_propagator(triggered_propagators, not_entailed_propagators, prop_idx)
+        prop_idx = pop_propagator(triggered_propagators, prop_idx)
         if prop_idx == -1:
-            return PROBLEM_BOUND if is_solved(shr_domains_arr) else PROBLEM_UNBOUND
+            return PROBLEM_BOUND if is_solved(shr_domains_stack[0]) else PROBLEM_UNBOUND
         statistics[STATS_IDX_PROPAGATOR_FILTER_NB] += 1
         prop_var_start = var_bounds[prop_idx, START]
         prop_var_end = var_bounds[prop_idx, END]
@@ -89,7 +94,7 @@ def bound_consistency_algorithm(
         prop_offsets = props_dom_offsets[prop_var_start:prop_var_end]
         prop_var_nb = prop_var_end - prop_var_start
         prop_domains = np.empty((prop_var_nb, 2), dtype=np.int32)
-        np.add(shr_domains_arr[prop_indices], prop_offsets, prop_domains)
+        np.add(shr_domains_stack[0, prop_indices], prop_offsets, prop_domains)
         compute_domains_function = (
             COMPUTE_DOMAINS_FCTS[algorithms[prop_idx]]
             if NUMBA_DISABLE_JIT
@@ -102,19 +107,23 @@ def bound_consistency_algorithm(
             statistics[STATS_IDX_PROPAGATOR_INCONSISTENCY_NB] += 1
             return PROBLEM_INCONSISTENT
         if status == PROP_ENTAILMENT:
-            not_entailed_propagators[prop_idx] = False
+            not_entailed_propagators_stack[0, prop_idx] = False
             statistics[STATS_IDX_PROPAGATOR_ENTAILMENT_NB] += 1
         shr_domains_changes = False
         for var_idx in range(prop_var_nb):
             shr_domain_idx = prop_indices[var_idx]
-            prop_offset = prop_offsets[var_idx, 0]
+            prop_offset = prop_offsets[var_idx, 0]  # because of vertical shape
             for bound in [MIN, MAX]:
                 shr_domain_bound = prop_domains[var_idx, bound] - prop_offset
-                if shr_domains_arr[shr_domain_idx, bound] != shr_domain_bound:
-                    shr_domains_arr[shr_domain_idx, bound] = shr_domain_bound
+                if shr_domains_stack[0, shr_domain_idx, bound] != shr_domain_bound:
+                    shr_domains_stack[0, shr_domain_idx, bound] = shr_domain_bound
                     shr_domains_changes = True
-                    np.logical_or(
-                        triggered_propagators, shr_domains_propagators[shr_domain_idx, bound], triggered_propagators
+                    add_propagators(
+                        triggered_propagators,
+                        not_entailed_propagators_stack[0],
+                        shr_domains_propagators,
+                        shr_domain_idx,
+                        bound,
                     )
         if not shr_domains_changes:
             statistics[STATS_IDX_PROPAGATOR_FILTER_NO_CHANGE_NB] += 1

nucs-2.1.0/nucs/solvers/choice_points.py

@@ -0,0 +1,84 @@
+from typing import Optional
+
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.propagators.propagators import add_propagators
+from nucs.statistics import STATS_IDX_SOLVER_BACKTRACK_NB
+
+
+@njit(cache=True)
+def cp_init(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
+    shr_domains_arr: NDArray,
+) -> None:
+    shr_domains_stack[0] = shr_domains_arr
+    not_entailed_propagators_stack[0] = True
+    dom_update_stack[0, :] = 0
+    stacks_height[0] = 1
+
+
+@njit(cache=True)
+def cp_put(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
+    dom_index: int,
+    bound: Optional[int] = 0,
+) -> None:
+    shr_domains_stack[stacks_height[0], :, :] = shr_domains_stack[0, :, :]
+    not_entailed_propagators_stack[stacks_height[0], :] = not_entailed_propagators_stack[0, :]
+    dom_update_stack[stacks_height[0], 0] = dom_index
+    dom_update_stack[stacks_height[0], 1] = bound
+    stacks_height[0] += 1
+
+
+@njit(cache=True)
+def cp_pop(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
+) -> bool:
+    if stacks_height[0] == 1:
+        return False
+    stacks_height[0] -= 1
+    shr_domains_stack[0, :, :] = shr_domains_stack[stacks_height[0], :, :]
+    not_entailed_propagators_stack[0, :] = not_entailed_propagators_stack[stacks_height[0], :]
+    dom_update_stack[0] = dom_update_stack[stacks_height[0]]
+    return True
+
+
+@njit(cache=True)
+def backtrack(
+    statistics: NDArray,
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_height: NDArray,
+    triggered_propagators: NDArray,
+    shr_domains_propagators: NDArray,
+) -> bool:
+    """
+    Backtracks and updates the problem's domains.
+    :param statistics: the statistics array
+    :param shr_domains_stack: the stack of shared domains
+    :param not_entailed_propagators_stack: the stack of not entailed propagators
+    :param stacks_height: the height of both stacks
+    :return: true iff it is possible to backtrack
+    """
+    if not cp_pop(shr_domains_stack, not_entailed_propagators_stack, dom_update_stack, stacks_height):
+        return False
+    statistics[STATS_IDX_SOLVER_BACKTRACK_NB] += 1
+    add_propagators(
+        triggered_propagators,
+        not_entailed_propagators_stack[0],
+        shr_domains_propagators,
+        dom_update_stack[0, 0],
+        1 - dom_update_stack[0, 1],
+    )
+    return True

{nucs-2.0.0 → nucs-2.1.0}/nucs/solvers/consistency_algorithms.py

@@ -13,6 +13,7 @@
 from typing import Callable
 
 from nucs.solvers.bound_consistency_algorithm import bound_consistency_algorithm
+from nucs.solvers.shaving_consistency_algorithm import shaving_consistency_algorithm
 
 CONSISTENCY_ALG_FCTS = []
 
@@ -28,3 +29,4 @@ def register_consistency_algorithm(consistency_algorithm_fct: Callable) -> int:
 
 
 CONSISTENCY_ALG_BC = register_consistency_algorithm(bound_consistency_algorithm)
+CONSISTENCY_ALG_SHAVING = register_consistency_algorithm(shaving_consistency_algorithm)

{nucs-2.0.0 → nucs-2.1.0}/nucs/solvers/heuristics.py

@@ -26,8 +26,21 @@ def first_not_instantiated_var_heuristic(shr_domains: NDArray) -> int:
     :param shr_domains: the shared domains of the problem
     :return: the index of the shared domain
     """
-    for dom_idx, shr_domain in enumerate(shr_domains):
-        if shr_domain[MIN] < shr_domain[MAX]:
+    for dom_idx in range(len(shr_domains)):
+        if shr_domains[dom_idx, MIN] < shr_domains[dom_idx, MAX]:
+            return dom_idx
+    return -1  # cannot happen
+
+
+@njit(cache=True)
+def first_not_instantiated_var_heuristic_from_index(shr_domains: NDArray, start_idx: int) -> int:
+    """
+    Chooses the first non-instantiated shared domain.
+    :param shr_domains: the shared domains of the problem
+    :return: the index of the shared domain
+    """
+    for dom_idx in range(start_idx, len(shr_domains)):
+        if shr_domains[dom_idx, MIN] < shr_domains[dom_idx, MAX]:
             return dom_idx
     return -1  # cannot happen
 
@@ -40,8 +53,7 @@ def last_not_instantiated_var_heuristic(shr_domains: NDArray) -> int:
     :return: the index of the shared domain
     """
     for dom_idx in range(len(shr_domains) - 1, -1, -1):
-        shr_domain = shr_domains[dom_idx]
-        if shr_domain[MIN] < shr_domain[MAX]:
+        if shr_domains[dom_idx, MIN] < shr_domains[dom_idx, MAX]:
             return dom_idx
     return -1  # cannot happen