NUCS 0.1.2__tar.gz → 0.2.0__tar.gz

{nucs-0.1.2 → nucs-0.2.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 0.1.2
+Version: 0.2.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
@@ -22,14 +22,16 @@ NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and
 
 With NUCS, in a few seconds you can ...
 
-Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+Compute the 92 solutions to the [BIBD(8,14,7,4,3) problem](https://www.csplib.org/Problems/prob028/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 2797,
+    'PROBLEM_FILTER_NB': 2797,
+    'PROBLEM_PROPAGATOR_NB': 462,
+    'PROBLEM_VARIABLE_NB': 504,
     'PROPAGATOR_ENTAILMENT_NB': 36977,
-    'PROPAGATOR_FILTERS_NB': 564122,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_FILTER_NB': 564122,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 534436,
     'PROPAGATOR_INCONSISTENCY_NB': 1307,
     'SOLVER_BACKTRACK_NB': 1398,
     'SOLVER_CHOICE_DEPTH': 41,
@@ -37,29 +39,33 @@ Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
     'SOLVER_SOLUTION_NB': 92
 }
 ```
-Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+Demonstrate that the optimal [10-marks Golomb ruler](https://www.csplib.org/Problems/prob006/) length is 55:
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTERS_NB': 49623,
-    'PROPAGATOR_ENTAILMENT_NB': 855996,
-    'PROPAGATOR_FILTERS_NB': 5160649,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
-    'PROPAGATOR_INCONSISTENCY_NB': 24773,
-    'SOLVER_BACKTRACK_NB': 24772,
+    'PROBLEM_FILTER_NB': 22204,
+    'PROBLEM_PROPAGATOR_NB': 82,
+    'PROBLEM_VARIABLE_NB': 45,
+    'PROPAGATOR_ENTAILMENT_NB': 416934,
+    'PROPAGATOR_FILTER_NB': 2145268,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 1129818,
+    'PROPAGATOR_INCONSISTENCY_NB': 11065,
+    'SOLVER_BACKTRACK_NB': 11064,
     'SOLVER_CHOICE_DEPTH': 9,
-    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_CHOICE_NB': 11129,
     'SOLVER_SOLUTION_NB': 10
-}
+ }
 ```
-Find all 14200 solutions to the 12-queens problem:
+Find all 14200 solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 262011,
+    'PROBLEM_FILTER_NB': 262011,
+    'PROBLEM_PROPAGATOR_NB': 3,
+    'PROBLEM_VARIABLE_NB': 36,
     'PROPAGATOR_ENTAILMENT_NB': 0,
-    'PROPAGATOR_FILTERS_NB': 1910609,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_FILTER_NB': 1910609,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 631079,
     'PROPAGATOR_INCONSISTENCY_NB': 116806,
     'SOLVER_BACKTRACK_NB': 131005,
     'SOLVER_CHOICE_DEPTH': 10,
@@ -77,8 +83,8 @@ Let's install the Pip package for NUCS:
 ```bash
 pip install nucs
 ````
-Now we can write the following `queens.py` program, 
-refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+Now we can write the following `queens.py` program (please refer to [the technical documentation](DOCUMENTATION.md) 
+to better understand how NUCS works under the hood):
 ```python
 from nucs.problems.problem import Problem
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -86,20 +92,18 @@ from nucs.propagators.propagators import ALG_ALLDIFFERENT
 
 n = 8  # the number of queens
 problem = Problem(
-    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
-    dom_indices=list(range(n)) * 3,  # for each variable, its domain
-    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+    [(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    list(range(n)) * 3,  # for each variable, its domain
+    [0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
 )
-problem.set_propagators([
-    (list(range(n)), ALG_ALLDIFFERENT, []), 
-    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
-    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
-])
+problem.add_propagator((list(range(n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(n, 2 * n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, []))
 print(BacktrackSolver(problem).solve_one()[:n])
 ```
 Let's run this model with the following command:
 ```bash
-PYTHONPATH=. python queens.py
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python queens.py
 ```
 The first solution found is:
 ```bash
@@ -130,11 +134,14 @@ NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -
 ```
 
 ## Other constraint solvers in Python
-### python-constraint
-_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
-
 ### CCPMpy
 _CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
 
+### Numberjack
+_Numberjack is a modelling package written in Python for combinatorial optimisation._
+
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
 ### PyCSP
 _PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

{nucs-0.1.2/NUCS.egg-info → nucs-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 0.1.2
+Version: 0.2.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
@@ -22,14 +22,16 @@ NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and
 
 With NUCS, in a few seconds you can ...
 
-Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+Compute the 92 solutions to the [BIBD(8,14,7,4,3) problem](https://www.csplib.org/Problems/prob028/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 2797,
+    'PROBLEM_FILTER_NB': 2797,
+    'PROBLEM_PROPAGATOR_NB': 462,
+    'PROBLEM_VARIABLE_NB': 504,
     'PROPAGATOR_ENTAILMENT_NB': 36977,
-    'PROPAGATOR_FILTERS_NB': 564122,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_FILTER_NB': 564122,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 534436,
     'PROPAGATOR_INCONSISTENCY_NB': 1307,
     'SOLVER_BACKTRACK_NB': 1398,
     'SOLVER_CHOICE_DEPTH': 41,
@@ -37,29 +39,33 @@ Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
     'SOLVER_SOLUTION_NB': 92
 }
 ```
-Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+Demonstrate that the optimal [10-marks Golomb ruler](https://www.csplib.org/Problems/prob006/) length is 55:
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTERS_NB': 49623,
-    'PROPAGATOR_ENTAILMENT_NB': 855996,
-    'PROPAGATOR_FILTERS_NB': 5160649,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
-    'PROPAGATOR_INCONSISTENCY_NB': 24773,
-    'SOLVER_BACKTRACK_NB': 24772,
+    'PROBLEM_FILTER_NB': 22204,
+    'PROBLEM_PROPAGATOR_NB': 82,
+    'PROBLEM_VARIABLE_NB': 45,
+    'PROPAGATOR_ENTAILMENT_NB': 416934,
+    'PROPAGATOR_FILTER_NB': 2145268,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 1129818,
+    'PROPAGATOR_INCONSISTENCY_NB': 11065,
+    'SOLVER_BACKTRACK_NB': 11064,
     'SOLVER_CHOICE_DEPTH': 9,
-    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_CHOICE_NB': 11129,
     'SOLVER_SOLUTION_NB': 10
-}
+ }
 ```
-Find all 14200 solutions to the 12-queens problem:
+Find all 14200 solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 262011,
+    'PROBLEM_FILTER_NB': 262011,
+    'PROBLEM_PROPAGATOR_NB': 3,
+    'PROBLEM_VARIABLE_NB': 36,
     'PROPAGATOR_ENTAILMENT_NB': 0,
-    'PROPAGATOR_FILTERS_NB': 1910609,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_FILTER_NB': 1910609,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 631079,
     'PROPAGATOR_INCONSISTENCY_NB': 116806,
     'SOLVER_BACKTRACK_NB': 131005,
     'SOLVER_CHOICE_DEPTH': 10,
@@ -77,8 +83,8 @@ Let's install the Pip package for NUCS:
 ```bash
 pip install nucs
 ````
-Now we can write the following `queens.py` program, 
-refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+Now we can write the following `queens.py` program (please refer to [the technical documentation](DOCUMENTATION.md) 
+to better understand how NUCS works under the hood):
 ```python
 from nucs.problems.problem import Problem
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -86,20 +92,18 @@ from nucs.propagators.propagators import ALG_ALLDIFFERENT
 
 n = 8  # the number of queens
 problem = Problem(
-    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
-    dom_indices=list(range(n)) * 3,  # for each variable, its domain
-    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+    [(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    list(range(n)) * 3,  # for each variable, its domain
+    [0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
 )
-problem.set_propagators([
-    (list(range(n)), ALG_ALLDIFFERENT, []), 
-    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
-    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
-])
+problem.add_propagator((list(range(n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(n, 2 * n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, []))
 print(BacktrackSolver(problem).solve_one()[:n])
 ```
 Let's run this model with the following command:
 ```bash
-PYTHONPATH=. python queens.py
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python queens.py
 ```
 The first solution found is:
 ```bash
@@ -130,11 +134,14 @@ NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -
 ```
 
 ## Other constraint solvers in Python
-### python-constraint
-_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
-
 ### CCPMpy
 _CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
 
+### Numberjack
+_Numberjack is a modelling package written in Python for combinatorial optimisation._
+
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
 ### PyCSP
 _PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

{nucs-0.1.2 → nucs-0.2.0}/README.md

@@ -7,14 +7,16 @@ NUCS is also very fast because it is powered by [Numpy](https://numpy.org/) and
 
 With NUCS, in a few seconds you can ...
 
-Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
+Compute the 92 solutions to the [BIBD(8,14,7,4,3) problem](https://www.csplib.org/Problems/prob028/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 2797,
+    'PROBLEM_FILTER_NB': 2797,
+    'PROBLEM_PROPAGATOR_NB': 462,
+    'PROBLEM_VARIABLE_NB': 504,
     'PROPAGATOR_ENTAILMENT_NB': 36977,
-    'PROPAGATOR_FILTERS_NB': 564122,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 534436,
+    'PROPAGATOR_FILTER_NB': 564122,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 534436,
     'PROPAGATOR_INCONSISTENCY_NB': 1307,
     'SOLVER_BACKTRACK_NB': 1398,
     'SOLVER_CHOICE_DEPTH': 41,
@@ -22,29 +24,33 @@ Compute the 92 solutions to the BIBD(8,14,7,4,3) problem:
     'SOLVER_SOLUTION_NB': 92
 }
 ```
-Demonstrate that the optimal 10-marks Golomb ruler length is 55:
+Demonstrate that the optimal [10-marks Golomb ruler](https://www.csplib.org/Problems/prob006/) length is 55:
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 10,
-    'PROBLEM_FILTERS_NB': 49623,
-    'PROPAGATOR_ENTAILMENT_NB': 855996,
-    'PROPAGATOR_FILTERS_NB': 5160649,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 2893864,
-    'PROPAGATOR_INCONSISTENCY_NB': 24773,
-    'SOLVER_BACKTRACK_NB': 24772,
+    'PROBLEM_FILTER_NB': 22204,
+    'PROBLEM_PROPAGATOR_NB': 82,
+    'PROBLEM_VARIABLE_NB': 45,
+    'PROPAGATOR_ENTAILMENT_NB': 416934,
+    'PROPAGATOR_FILTER_NB': 2145268,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 1129818,
+    'PROPAGATOR_INCONSISTENCY_NB': 11065,
+    'SOLVER_BACKTRACK_NB': 11064,
     'SOLVER_CHOICE_DEPTH': 9,
-    'SOLVER_CHOICE_NB': 24840,
+    'SOLVER_CHOICE_NB': 11129,
     'SOLVER_SOLUTION_NB': 10
-}
+ }
 ```
-Find all 14200 solutions to the 12-queens problem:
+Find all 14200 solutions to the [12-queens problem](https://www.csplib.org/Problems/prob054/):
 ```python
 {
     'OPTIMIZER_SOLUTION_NB': 0,
-    'PROBLEM_FILTERS_NB': 262011,
+    'PROBLEM_FILTER_NB': 262011,
+    'PROBLEM_PROPAGATOR_NB': 3,
+    'PROBLEM_VARIABLE_NB': 36,
     'PROPAGATOR_ENTAILMENT_NB': 0,
-    'PROPAGATOR_FILTERS_NB': 1910609,
-    'PROPAGATOR_FILTERS_NO_CHANGE_NB': 631079,
+    'PROPAGATOR_FILTER_NB': 1910609,
+    'PROPAGATOR_FILTER_NO_CHANGE_NB': 631079,
     'PROPAGATOR_INCONSISTENCY_NB': 116806,
     'SOLVER_BACKTRACK_NB': 131005,
     'SOLVER_CHOICE_DEPTH': 10,
@@ -62,8 +68,8 @@ Let's install the Pip package for NUCS:
 ```bash
 pip install nucs
 ````
-Now we can write the following `queens.py` program, 
-refer to [the technical documentation](DOCUMENTATION.md) to better understand how NUCS works under the hood:
+Now we can write the following `queens.py` program (please refer to [the technical documentation](DOCUMENTATION.md) 
+to better understand how NUCS works under the hood):
 ```python
 from nucs.problems.problem import Problem
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -71,20 +77,18 @@ from nucs.propagators.propagators import ALG_ALLDIFFERENT
 
 n = 8  # the number of queens
 problem = Problem(
-    shr_domains=[(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
-    dom_indices=list(range(n)) * 3,  # for each variable, its domain
-    dom_offsets=[0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
+    [(0, n - 1)] * n,  # these n domains are shared between 3n variables with different offsets
+    list(range(n)) * 3,  # for each variable, its domain
+    [0] * n + list(range(n)) + list(range(0, -n, -1))  # for each variable, its offset
 )
-problem.set_propagators([
-    (list(range(n)), ALG_ALLDIFFERENT, []), 
-    (list(range(n, 2 * n)), ALG_ALLDIFFERENT, []), 
-    (list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, [])
-])
+problem.add_propagator((list(range(n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(n, 2 * n)), ALG_ALLDIFFERENT, []))
+problem.add_propagator((list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, []))
 print(BacktrackSolver(problem).solve_one()[:n])
 ```
 Let's run this model with the following command:
 ```bash
-PYTHONPATH=. python queens.py
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python queens.py
 ```
 The first solution found is:
 ```bash
@@ -115,11 +119,14 @@ NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python tests/examples/test_golomb.py -
 ```
 
 ## Other constraint solvers in Python
-### python-constraint
-_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
-
 ### CCPMpy
 _CPMpy is a Constraint Programming and Modeling library in Python, based on numpy, with direct solver access._
 
+### Numberjack
+_Numberjack is a modelling package written in Python for combinatorial optimisation._
+
+### python-constraint
+_The Python constraint module offers solvers for Constraint Solving Problems (CSPs) over finite domains in simple and pure Python._
+
 ### PyCSP
 _PyCSP3 is a Python library for developping models of combinatorial constrained problems in a declarative manner; you can write models of constraint satisfaction (CSP) and constraint optimization (COP) problems._

{nucs-0.1.2 → nucs-0.2.0}/nucs/heuristics/variable_heuristic.py

@@ -63,6 +63,24 @@ def smallest_domain_var_heuristic(shr_domains: NDArray, dom_indices: NDArray) ->
     return min_idx
 
 
+@njit("int16(int32[::1, :], uint16[:])", cache=True)
+def greatest_domain_var_heuristic(shr_domains: NDArray, dom_indices: NDArray) -> int:
+    """
+    Chooses the variable with the greatest domain and which is not instantiated.
+    :param shr_domains: the shared domains of the problem
+    :param dom_indices: the domain indices of the problem variables
+    :return: the index of the variable
+    """
+    max_size = 0
+    max_idx = -1
+    for var_idx, dom_index in enumerate(dom_indices):
+        size = shr_domains[dom_index, MAX] - shr_domains[dom_index, MIN]  # actually this is size - 1
+        if max_size < size:
+            max_idx = var_idx
+            max_size = size
+    return max_idx
+
+
 @njit("(int32[::1, :], boolean[::1, :], int32[::1, :], uint16)", cache=True)
 def min_value_dom_heuristic(
     shr_domains: NDArray, shr_domain_changes: NDArray, shr_domains_copy: NDArray, domain_idx: int
@@ -80,6 +98,23 @@ def min_value_dom_heuristic(
     shr_domain_changes[domain_idx, MAX] = True
 
 
+@njit("(int32[::1, :], boolean[::1, :], int32[::1, :], uint16)", cache=True)
+def max_value_dom_heuristic(
+    shr_domains: NDArray, shr_domain_changes: NDArray, shr_domains_copy: NDArray, domain_idx: int
+) -> None:
+    """
+    Chooses the last value of the domain
+    :param shr_domains: the shared domains of the problem
+    :param: shr_domain_changes: the changes to the shared domains
+    :param: shr_domains_copy: the shared domains to be added to the choice point
+    :param domain_idx: the index of the domain
+    """
+    value = shr_domains[domain_idx, MAX]
+    shr_domains_copy[domain_idx, MAX] = value - 1
+    shr_domains[domain_idx, MIN] = value
+    shr_domain_changes[domain_idx, MIN] = True
+
+
 @njit("(int32[::1, :], boolean[::1, :], int32[::1, :], uint16)", cache=True)
 def split_low_dom_heuristic(
     shr_domains: NDArray, shr_domain_changes: NDArray, shr_domains_copy: NDArray, domain_idx: int

{nucs-0.1.2 → nucs-0.2.0}/nucs/memory.py

@@ -14,7 +14,7 @@ PROP_CONSISTENCY = 1
 PROP_ENTAILMENT = 2
 
 
-def new_domains_by_values(domains: List[Union[int, Tuple[int, int]]]) -> NDArray:
+def new_shr_domains_by_values(domains: List[Union[int, Tuple[int, int]]]) -> NDArray:
     return np.array(
         [(domain, domain) if isinstance(domain, int) else domain for domain in domains],
         dtype=np.int32,
@@ -22,19 +22,19 @@ def new_domains_by_values(domains: List[Union[int, Tuple[int, int]]]) -> NDArray
     )
 
 
-def new_indices_by_values(dom_indices: List[int]) -> NDArray:
+def new_dom_indices_by_values(dom_indices: List[int]) -> NDArray:
     return np.array(dom_indices, dtype=np.uint16, order="C")
 
 
-def new_indices(n: int) -> NDArray:
+def new_dom_indices(n: int) -> NDArray:
     return np.empty(n, dtype=np.uint16, order="C")
 
 
-def new_domain_offsets_by_values(dom_offsets: List[int]) -> NDArray:
+def new_dom_offsets_by_values(dom_offsets: List[int]) -> NDArray:
     return np.array(dom_offsets, dtype=np.int32, order="C")
 
 
-def new_offsets(n: int) -> NDArray:
+def new_dom_offsets(n: int) -> NDArray:
     return np.empty(n, dtype=np.int32, order="C")
 
 
@@ -46,23 +46,23 @@ def new_data(n: int) -> NDArray:
     return np.empty(n, dtype=np.int32, order="C")
 
 
-def new_domain_changes(n: int) -> NDArray:
+def new_shr_domain_changes(n: int) -> NDArray:
     return np.ones((n, 2), dtype=bool, order="F")
 
 
 def new_triggers(n: int, init_value: bool) -> NDArray:
     if init_value:
-        return np.ones((n, 2), dtype=bool, order="F")
+        return np.ones((n, 2), dtype=bool, order="C")
     else:
-        return np.zeros((n, 2), dtype=bool, order="F")
+        return np.zeros((n, 2), dtype=bool, order="C")
 
 
 def new_triggered_propagators(n: int) -> NDArray:
     return np.empty(n, dtype=bool, order="C")
 
 
-def new_entailed_propagators(n: int) -> NDArray:
-    return np.zeros(n, dtype=bool, order="C")
+def new_not_entailed_propagators(n: int) -> NDArray:
+    return np.ones(n, dtype=bool, order="C")
 
 
 def new_algorithms(n: int) -> NDArray:
@@ -70,4 +70,8 @@ def new_algorithms(n: int) -> NDArray:
 
 
 def new_bounds(n: int) -> NDArray:
-    return np.empty((n, 2), dtype=np.uint16)
+    return np.empty((n, 2), dtype=np.uint16, order="C")
+
+
+def new_shr_domains_propagators(n: int, m: int) -> NDArray:
+    return np.zeros((n, 2, m), dtype=bool, order="C")

{nucs-0.1.2 → nucs-0.2.0}/nucs/problems/alpha_problem.py

@@ -3,37 +3,11 @@ from typing import List
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ALLDIFFERENT
 
-A = 0
-B = 1
-C = 2
-D = 3
-E = 4
-F = 5
-G = 6
-H = 7
-I = 8
-J = 9
-K = 10
-L = 11
-M = 12
-N = 13
-O = 14
-P = 15
-Q = 16
-R = 17
-S = 18
-T = 19
-U = 20
-V = 21
-W = 22
-X = 23
-Y = 24
-Z = 25
+A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z = tuple(range(26))
 
 
 class AlphaProblem(Problem):
     """
-    This problem comes from the newsgroup rec.puzzle.
     The numbers from 1 to 26 are assigned to the letters of the alphabet.
     The numbers beside each word are the total of the values assigned to the letters in the word
     (e.g for LYRE: L,Y,R,E might be to equal 5,9,20 and 13 or any other combination that add up to 47).
@@ -44,11 +18,13 @@ class AlphaProblem(Problem):
     CONCERT 74     LYRE  47     SAXOPHONE 134     THEME    72
     FLUTE   30     OBOE  53     SCALE      51     VIOLIN  100
     FUGUE   50     OPERA 65     SOLO       37     WALTZ    34
+
+    This problem comes from the newsgroup rec.puzzle.
     """
 
     def __init__(self) -> None:
-        super().__init__(shr_domains=[(1, 26)] * 26, dom_indices=list(range(26)), dom_offsets=[0] * 26)
-        self.set_propagators(
+        super().__init__([(1, 26)] * 26)
+        self.add_propagators(
             [
                 ([A, B, E, T, L], ALG_AFFINE_EQ, [1, 1, 1, 1, 2, 45]),
                 ([C, E, O, L], ALG_AFFINE_EQ, [1, 1, 1, 2, 43]),

{nucs-0.1.2 → nucs-0.2.0}/nucs/problems/bibd_problem.py

@@ -1,9 +1,5 @@
 from nucs.problems.problem import Problem
-from nucs.propagators.propagators import (
-    ALG_EXACTLY_EQ,
-    ALG_LEXICOGRAPHIC_LEQ,
-    ALG_MIN_EQ,
-)
+from nucs.propagators.propagators import ALG_EXACTLY_EQ, ALG_LEXICOGRAPHIC_LEQ, ALG_MIN_EQ
 
 
 class BIBDProblem(Problem):
@@ -14,35 +10,29 @@ class BIBDProblem(Problem):
     def __init__(self, v: int, b: int, r: int, k: int, l: int):
         s = (v * (v - 1)) // 2
         n = (v + s) * b
-        super().__init__(
-            shr_domains=[(0, 1)] * n,
-            dom_indices=list(range(n)),
-            dom_offsets=[0] * n,
-        )
-        propagators = []
+        super().__init__([(0, 1)] * n)
         # rows: counts
         for i in range(0, v):
-            propagators.append((list(range(i * b, (i + 1) * b)), ALG_EXACTLY_EQ, [1, r]))
+            self.add_propagator((list(range(i * b, (i + 1) * b)), ALG_EXACTLY_EQ, [1, r]))
         # columns: counts
         for j in range(0, b):
-            propagators.append((list(range(j, v * b, b)), ALG_EXACTLY_EQ, [1, k]))
+            self.add_propagator((list(range(j, v * b, b)), ALG_EXACTLY_EQ, [1, k]))
         # scalar products: conjunctions and counts
         conj_idx = v * b
         for i1 in range(0, v - 1):
             for i2 in range(i1 + 1, v):
                 conj_vars = []
                 for j in range(0, b):
-                    propagators.append(
+                    self.add_propagator(
                         ([(i1 * b + j), (i2 * b + j), conj_idx], ALG_MIN_EQ, [])
-                    )  # TODO: replace by AND ?
+                    )  # TODO:replace by AND ?
                     conj_vars.append(conj_idx)
                     conj_idx += 1
-                propagators.append((conj_vars, ALG_EXACTLY_EQ, [1, l]))
+                self.add_propagator((conj_vars, ALG_EXACTLY_EQ, [1, l]))
         # remove symmetries
         # lexleq on rows
         for i in range(0, v - 1):
-            propagators.append((list(range(i * b, (i + 2) * b)), ALG_LEXICOGRAPHIC_LEQ, []))
+            self.add_propagator((list(range(i * b, (i + 2) * b)), ALG_LEXICOGRAPHIC_LEQ, []))
         # lexleq on columns
         for j in range(0, b - 1):
-            propagators.append((list(range(j, v * b, b)) + list(range(j + 1, v * b, b)), ALG_LEXICOGRAPHIC_LEQ, []))
-        self.set_propagators(propagators)
+            self.add_propagator((list(range(j, v * b, b)) + list(range(j + 1, v * b, b)), ALG_LEXICOGRAPHIC_LEQ, []))