NUCS 4.4__tar.gz → 4.4.4__tar.gz

{nucs-4.4 → nucs-4.4.4/NuCS.egg-info}/PKG-INFO

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
-Name: NUCS
-Version: 4.4
+Name: NuCS
+Version: 4.4.4
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
 Project-URL: Issues, https://github.com/yangeorget/nucs/issues
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -18,7 +22,8 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numba==0.60.0
-Requires-Dist: numpy==2.0.1
+Requires-Dist: numpy<2.1
+Requires-Dist: rich
 
 ![NucS logo](https://github.com/yangeorget/nucs/blob/main/assets/nucs.png?raw=true)
 

{nucs-4.4/NUCS.egg-info → nucs-4.4.4/NuCS.egg-info}/SOURCES.txt

@@ -1,11 +1,11 @@
 LICENSE.md
 README.md
 pyproject.toml
-NUCS.egg-info/PKG-INFO
-NUCS.egg-info/SOURCES.txt
-NUCS.egg-info/dependency_links.txt
-NUCS.egg-info/requires.txt
-NUCS.egg-info/top_level.txt
+NuCS.egg-info/PKG-INFO
+NuCS.egg-info/SOURCES.txt
+NuCS.egg-info/dependency_links.txt
+NuCS.egg-info/requires.txt
+NuCS.egg-info/top_level.txt
 docs/source/conf.py
 nucs/__init__.py
 nucs/constants.py

nucs-4.4.4/NuCS.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numba==0.60.0
+numpy<2.1
+rich

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

@@ -1,16 +1,20 @@
 Metadata-Version: 2.1
-Name: NUCS
-Version: 4.4
+Name: NuCS
+Version: 4.4.4
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
 Project-URL: Issues, https://github.com/yangeorget/nucs/issues
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
@@ -18,7 +22,8 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numba==0.60.0
-Requires-Dist: numpy==2.0.1
+Requires-Dist: numpy<2.1
+Requires-Dist: rich
 
 ![NucS logo](https://github.com/yangeorget/nucs/blob/main/assets/nucs.png?raw=true)
 

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

@@ -2,12 +2,12 @@
 
 # -- Project information
 
-project = 'NUCS'
+project = 'NuCS'
 copyright = '2024, Yan Georget'
 author = 'Yan Georget'
 
-release = '4.4'
-version = '4.4'
+release = '4.4.4'
+version = '4.4.4'
 
 # -- General configuration
 

{nucs-4.4 → nucs-4.4.4}/nucs/examples/quasigroup/__main__.py

@@ -15,9 +15,10 @@ import argparse
 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.examples.quasigroup.quasigroup_problem import QuasigroupProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_SPLIT_LOW, VAR_HEURISTIC_SMALLEST_DOMAIN
 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.quasigroup -n 10 --symmetry_breaking
@@ -25,13 +26,18 @@ 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("--idempotent", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--kind", type=int, choices=[3, 4, 5, 6, 7], default=5)
     args = parser.parse_args()
-    problem = Quasigroup5Problem(args.n, args.symmetry_breaking)
+    problem = QuasigroupProblem(args.kind, args.n, args.idempotent, args.symmetry_breaking)
     solver = BacktrackSolver(
         problem,
+        decision_domains=list(range(0, args.n * args.n)),
+        consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
         var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN,
-        dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
+        dom_heuristic_idx=DOM_HEURISTIC_SPLIT_LOW,
         log_level=args.log_level,
     )
     solver.solve_all()

nucs-4.4.4/nucs/examples/quasigroup/quasigroup_problem.py

@@ -0,0 +1,116 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+from nucs.problems.latin_square_problem import M_COLOR, M_COLUMN, M_ROW, LatinSquareRCProblem
+from nucs.propagators.propagators import ALG_ELEMENT_LIV
+
+
+class QuasigroupProblem(LatinSquareRCProblem):
+    """
+    CSPLIB problem #3 - https://www.csplib.org/Problems/prob003/
+    """
+
+    def __init__(self, kind: int, n: int, idempotent: bool, symmetry_breaking: bool = True):
+        """
+        Inits the problem.
+        :param n: the size of the quasigroup
+        :param idempotent: a boolean indicating if the quasigroup is idempotent
+        :param symmetry_breaking: a boolean indicating if symmetry constraints should be added to the model
+        """
+        super().__init__(n)
+        if kind == 3:  # (a∗b)∗(b*a)=a
+            # Equivalent to: color[color[i, j], color[j, i]] = i
+            # Equivalent to: column[color[i, j], i] = color[j, i] which avoids the creation of additional variables
+            self.add_propagators(
+                [
+                    (
+                        [*self.column(i, M_COLUMN), self.cell(i, j, M_COLOR), self.cell(j, i, M_COLOR)],
+                        ALG_ELEMENT_LIV,
+                        [],
+                    )
+                    for i in range(n)
+                    for j in range(n)
+                ]
+            )
+        elif kind == 4:  # (b∗a)∗(a*b) = a
+            # Equivalent to: color[color[j, i], color[i, j]] = i
+            # Equivalent to: column[color[j, i], i] = color[i, j] which avoids the creation of additional variables
+            self.add_propagators(
+                [
+                    (
+                        [*self.column(i, M_COLUMN), self.cell(j, i, M_COLOR), self.cell(i, j, M_COLOR)],
+                        ALG_ELEMENT_LIV,
+                        [],
+                    )
+                    for i in range(n)
+                    for j in range(n)
+                ]
+            )
+        elif kind == 5:  # ((b∗a)∗b)∗b = a
+            # Equivalent to: color[color[color[j, i], j], j] = i
+            # Equivalent to: row[i, j] = color[color[j, i], j] which avoids the creation of additional variables
+            self.add_propagators(
+                [
+                    (
+                        [*self.column(j, M_COLOR), self.cell(j, i, M_COLOR), self.cell(i, j, M_ROW)],
+                        ALG_ELEMENT_LIV,
+                        [],
+                    )
+                    for i in range(n)
+                    for j in range(n)
+                ]
+            )
+        elif kind == 6:  # (a∗b)∗b = a*(a*b)
+            # Equivalent to: color[color[i, j], j] = color[i, color[i, j]]
+            additional_vars_idx = self.add_variables([(0, n - 1)] * n**2)  # additional variables
+            for i in range(n):
+                for j in range(n):
+                    self.add_propagator(
+                        (
+                            [*self.column(j, M_COLOR), self.cell(i, j, M_COLOR), additional_vars_idx + i * n + j],
+                            ALG_ELEMENT_LIV,
+                            [],
+                        )
+                    )
+                    self.add_propagator(
+                        (
+                            [*self.row(i, M_COLOR), self.cell(i, j, M_COLOR), additional_vars_idx + i * n + j],
+                            ALG_ELEMENT_LIV,
+                            [],
+                        )
+                    )
+        elif kind == 7:  # (b∗a)∗b = a*(b*a)
+            # Equivalent to: color[color[j, i], j] = color[i, color[j, i]]
+            additional_vars_idx = self.add_variables([(0, n - 1)] * n**2)  # additional variables
+            for i in range(n):
+                for j in range(n):
+                    self.add_propagator(
+                        (
+                            [*self.column(j, M_COLOR), self.cell(j, i, M_COLOR), additional_vars_idx + i * n + j],
+                            ALG_ELEMENT_LIV,
+                            [],
+                        )
+                    )
+                    self.add_propagator(
+                        (
+                            [*self.row(i, M_COLOR), self.cell(j, i, M_COLOR), additional_vars_idx + i * n + j],
+                            ALG_ELEMENT_LIV,
+                            [],
+                        )
+                    )
+        if idempotent:
+            for model in [M_COLOR, M_ROW, M_COLUMN]:
+                for i in range(n):
+                    self.shr_domains_lst[self.cell(i, i, model)] = [i, i]
+        if symmetry_breaking:
+            for i in range(1, n):
+                self.shr_domains_lst[self.cell(i, n - 1)] = [i - 1, n - 1]

{nucs-4.4 → nucs-4.4.4}/nucs/propagators/element_iv_propagator.py

@@ -11,7 +11,6 @@
 # Copyright 2024 - Yan Georget
 ###############################################################################
 import sys
-from typing import List
 
 import numpy as np
 from numba import njit  # type: ignore
@@ -58,23 +57,23 @@ def compute_domains_element_iv(domains: NDArray, parameters: NDArray) -> int:
     i[MAX] = min(i[MAX], len(l) - 1)
     v_min = sys.maxsize
     v_max = -sys.maxsize
-    indices: List[int] = []
+    start = -1
     for idx in range(i[MIN], i[MAX] + 1):
         if v[MAX] < l[idx] or v[MIN] > l[idx]:  # no intersection
-            indices.append(idx)
+            if start == -1:
+                start = idx
             if idx == i[MIN]:
                 i[MIN] += 1
         else:  # intersection
+            start = -1
             if l[idx] < v_min:
                 v_min = l[idx]
             if l[idx] > v_max:
                 v_max = l[idx]
-    for ix in range(len(indices) - 1, -1, -1):
-        if indices[ix] != i[MAX]:
-            break
-        i[MAX] -= 1
-    if i[MAX] < i[MIN]:
-        return PROP_INCONSISTENCY
+    if start >= 0:
+        i[MAX] = start - 1
+        if i[MAX] < i[MIN]:
+            return PROP_INCONSISTENCY
     v[MIN] = max(v[MIN], v_min)
     v[MAX] = min(v[MAX], v_max)
     if i[MIN] == i[MAX]:

{nucs-4.4 → nucs-4.4.4}/nucs/propagators/element_lic_propagator.py

@@ -10,8 +10,6 @@
 #
 # Copyright 2024 - Yan Georget
 ###############################################################################
-from typing import List
-
 import numpy as np
 from numba import njit  # type: ignore
 from numpy.typing import NDArray
@@ -53,18 +51,19 @@ def compute_domains_element_lic(domains: NDArray, parameters: NDArray) -> int:
     # i could be updated only once
     i[MIN] = max(i[MIN], 0)
     i[MAX] = min(i[MAX], len(l) - 1)
-    indices: List[int] = []
+    start = -1
     for idx in range(i[MIN], i[MAX] + 1):
         if c < l[idx, MIN] or c > l[idx, MAX]:  # no intersection
-            indices.insert(0, idx)
+            if start == -1:
+                start = idx
             if idx == i[MIN]:
                 i[MIN] += 1
-    for idx in indices:
-        if idx != i[MAX]:
-            break
-        i[MAX] -= 1
-    if i[MAX] < i[MIN]:
-        return PROP_INCONSISTENCY
+        else:  # intersection
+            start = -1
+    if start >= 0:
+        i[MAX] = start - 1
+        if i[MAX] < i[MIN]:
+            return PROP_INCONSISTENCY
     if i[MIN] == i[MAX]:
         l[i[MIN]] = c
         return PROP_ENTAILMENT

{nucs-4.4 → nucs-4.4.4}/nucs/propagators/element_liv_propagator.py

@@ -11,7 +11,6 @@
 # Copyright 2024 - Yan Georget
 ###############################################################################
 import sys
-from typing import List
 
 import numpy as np
 from numba import njit  # type: ignore
@@ -59,23 +58,23 @@ def compute_domains_element_liv(domains: NDArray, parameters: NDArray) -> int:
     i[MAX] = min(i[MAX], len(l) - 1)
     v_min = sys.maxsize
     v_max = -sys.maxsize
-    indices: List[int] = []
+    start = -1
     for idx in range(i[MIN], i[MAX] + 1):
         if v[MAX] < l[idx, MIN] or v[MIN] > l[idx, MAX]:  # no intersection
-            indices.insert(0, idx)
+            if start == -1:
+                start = idx
             if idx == i[MIN]:
                 i[MIN] += 1
         else:  # intersection
+            start = -1
             if l[idx, MIN] < v_min:
                 v_min = l[idx, MIN]
             if l[idx, MAX] > v_max:
                 v_max = l[idx, MAX]
-    for idx in indices:
-        if idx != i[MAX]:
-            break
-        i[MAX] -= 1
-    if i[MAX] < i[MIN]:
-        return PROP_INCONSISTENCY
+    if start >= 0:
+        i[MAX] = start - 1
+        if i[MAX] < i[MIN]:
+            return PROP_INCONSISTENCY
     v[MIN] = max(v[MIN], v_min)
     v[MAX] = min(v[MAX], v_max)
     if i[MIN] == i[MAX]:

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

@@ -1,6 +1,6 @@
 [project]
-name="NUCS"
-version="4.4"
+name="NuCS"
+version="4.4.4"
 authors = [
   { name="Yan Georget", email="yan.georget@gmail.com" },
 ]
@@ -8,19 +8,24 @@ description="A Numpy and Numba based Python library for solving Constraint Satis
 readme = "README.md"
 requires-python = ">=3.9"
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
     "Topic :: Scientific/Engineering :: Mathematics",
     "Topic :: Software Development :: Libraries :: Python Modules"
 ]
 dependencies = [
     "numba==0.60.0",
-    "numpy==2.0.1",
+    "numpy<2.1",
+    "rich"
 ]
 [project.urls]
 Homepage = "https://github.com/yangeorget/nucs"

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

@@ -10,26 +10,19 @@
 #
 # Copyright 2024 - Yan Georget
 ###############################################################################
+import pytest
+
 from nucs.constants import STATS_IDX_SOLVER_SOLUTION_NB
 from nucs.examples.bibd.bibd_problem import BIBDProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 
 
 class TestBIBD:
-    def test_6_10_5_3_2(self) -> None:
-        problem = BIBDProblem(6, 10, 5, 3, 2)
-        solver = BacktrackSolver(problem, stacks_max_height=128)
-        solver.solve_all()
-        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1
-
-    def test_7_7_3_3_1(self) -> None:
-        problem = BIBDProblem(7, 7, 3, 3, 1)
-        solver = BacktrackSolver(problem, stacks_max_height=128)
-        solver.solve_all()
-        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1
-
-    def test_8_14_7_4_3(self) -> None:
-        problem = BIBDProblem(8, 14, 7, 4, 3)
+    @pytest.mark.parametrize(
+        "v, b, r, k, l, solution_nb", [(6, 10, 5, 3, 2, 1), (7, 7, 3, 3, 1, 1), (8, 14, 7, 4, 3, 92)]
+    )
+    def test_bibd(self, v: int, b: int, r: int, k: int, l: int, solution_nb: int) -> None:
+        problem = BIBDProblem(v, b, r, k, l)
         solver = BacktrackSolver(problem, stacks_max_height=128)
         solver.solve_all()
-        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 92
+        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == solution_nb

nucs-4.4.4/tests/examples/test_quasigroup.py

@@ -0,0 +1,62 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import pytest
+
+from nucs.constants import STATS_IDX_SOLVER_SOLUTION_NB
+from nucs.examples.quasigroup.quasigroup_problem import QuasigroupProblem
+from nucs.heuristics.heuristics import DOM_HEURISTIC_SPLIT_LOW, VAR_HEURISTIC_SMALLEST_DOMAIN
+from nucs.solvers.backtrack_solver import BacktrackSolver
+
+
+class TestQuasigroup:
+    @pytest.mark.parametrize(
+        "kind, size, idempotent, solution_nb",
+        [
+            (3, 5, True, 0),
+            (3, 6, True, 0),
+            (3, 7, True, 0),
+            (3, 8, True, 18),
+            (4, 5, True, 3),
+            (4, 6, True, 0),
+            (4, 7, True, 0),
+            (4, 8, True, 0),
+            (5, 5, True, 1),
+            (5, 6, True, 0),
+            (5, 7, True, 3),
+            (5, 8, True, 1),
+            (5, 9, True, 0),
+            (5, 10, True, 0),
+            # (5, 11, True, 5),
+            # (5, 12, True, 0),
+            (6, 5, True, 0),
+            (6, 6, True, 0),
+            (6, 7, True, 0),
+            (6, 8, True, 2),
+            (6, 9, True, 4),
+            (7, 5, True, 3),
+            (7, 6, True, 0),
+            (7, 7, True, 0),
+            (7, 8, True, 0),
+            # (7, 9, True, 1),
+        ],
+    )
+    def test_qg(self, kind: int, size: int, idempotent: bool, solution_nb: int) -> None:
+        problem = QuasigroupProblem(kind, size, idempotent, True)
+        solver = BacktrackSolver(
+            problem,
+            decision_domains=list(range(0, size * size)),
+            var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN,
+            dom_heuristic_idx=DOM_HEURISTIC_SPLIT_LOW,
+        )
+        solver.solve_all()
+        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == solution_nb

{nucs-4.4 → nucs-4.4.4}/tests/examples/test_sudokus.py

@@ -10,14 +10,19 @@
 #
 # Copyright 2024 - Yan Georget
 ###############################################################################
+from typing import List
+
+import pytest
+
 from nucs.constants import STATS_IDX_SOLVER_SOLUTION_NB
 from nucs.examples.sudoku.sudoku_problem import SudokuProblem
 from nucs.solvers.backtrack_solver import BacktrackSolver
 
 
 class TestSudokus:
-    def test_sudokus_1(self) -> None:
-        problem = SudokuProblem(
+    @pytest.mark.parametrize(
+        "givens",
+        [
             [
                 [0, 0, 0, 0, 3, 0, 0, 0, 0],
                 [2, 8, 9, 0, 0, 0, 0, 0, 0],
@@ -28,14 +33,7 @@ class TestSudokus:
                 [0, 6, 3, 0, 0, 0, 0, 0, 0],
                 [0, 0, 0, 0, 4, 0, 2, 0, 0],
                 [0, 0, 1, 0, 5, 0, 6, 0, 0],
-            ]
-        )
-        solver = BacktrackSolver(problem)
-        solver.solve_all()
-        assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1
-
-    def test_sudokus_2(self) -> None:
-        problem = SudokuProblem(
+            ],
             [
                 [6, 0, 0, 0, 1, 0, 0, 8, 0],
                 [5, 1, 7, 4, 0, 0, 0, 0, 0],
@@ -46,8 +44,11 @@ class TestSudokus:
                 [2, 5, 9, 6, 0, 0, 0, 0, 0],
                 [0, 0, 0, 0, 7, 0, 0, 0, 0],
                 [0, 0, 0, 0, 5, 0, 4, 0, 0],
-            ]
-        )
+            ],
+        ],
+    )
+    def test_sudokus(self, givens: List[List[int]]) -> None:
+        problem = SudokuProblem(givens)
         solver = BacktrackSolver(problem)
         solver.solve_all()
         assert solver.statistics[STATS_IDX_SOLVER_SOLUTION_NB] == 1

{nucs-4.4 → nucs-4.4.4}/tests/propagators/test_element_liv.py

@@ -34,6 +34,7 @@ class TestElementLIV:
         domains = new_shr_domains_by_values([3, 0, 1, 2, 4, (0, 4), (-2, 0)])
         data = new_parameters_by_values([])
         assert compute_domains_element_liv(domains, data) == PROP_ENTAILMENT
+        assert np.all(domains == np.array([[3, 3], [0, 0], [1, 1], [2, 2], [4, 4], [1, 1], [0, 0]]))
 
     def test_compute_domains_4(self) -> None:
         domains = new_shr_domains_by_values([(-4, -2), (1, 2), (0, 1), (0, 0)])

nucs-4.4/NUCS.egg-info/requires.txt

@@ -1,2 +0,0 @@
-numba==0.60.0
-numpy==2.0.1

nucs-4.4/nucs/examples/quasigroup/quasigroup_problem.py

@@ -1,63 +0,0 @@
-###############################################################################
-# __   _            _____    _____
-# | \ | |          / ____|  / ____|
-# |  \| |  _   _  | |      | (___
-# | . ` | | | | | | |       \___ \
-# | |\  | | |_| | | |____   ____) |
-# |_| \_|  \__,_|  \_____| |_____/
-#
-# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
-#
-# Copyright 2024 - Yan Georget
-###############################################################################
-from nucs.problems.latin_square_problem import M_COLOR, M_COLUMN, M_ROW, LatinSquareRCProblem
-from nucs.propagators.propagators import ALG_ELEMENT_LIV
-
-
-class QuasigroupProblem(LatinSquareRCProblem):
-    """
-    CSPLIB problem #3 - https://www.csplib.org/Problems/prob003/
-    """
-
-    def __init__(self, n: int, symmetry_breaking: bool = True):
-        """
-        Inits the problem.
-        :param n: the size of the quasigroup
-        :param symmetry_breaking: a boolean indicating if symmetry constraints should be added to the model
-        """
-        super().__init__(n)
-        # idempotence
-        for model in [M_COLOR, M_ROW, M_COLUMN]:
-            for i in range(n):
-                self.shr_domains_lst[self.cell(i, i, model)] = [i, i]
-        if symmetry_breaking:
-            for i in range(1, n):
-                self.shr_domains_lst[self.cell(i, n - 1)] = [i - 1, n - 1]
-
-
-class Quasigroup5Problem(QuasigroupProblem):
-    """
-    Defined by:
-       ((b∗a)∗b)∗b=a
-    Can be enforced by:
-       color[color[j, i] ,j] = row[i, j]
-    which avoids the creation of additional variables
-    """
-
-    def __init__(self, n: int, symmetry_breaking: bool = True):
-        """
-        Inits the problem
-        :param n: the size of the quasigroup
-        :param symmetry_breaking: a boolean indicating if symmetry constraints should be added to the model
-        """
-        super().__init__(n, symmetry_breaking)
-        for j in range(n):
-            for i in range(n):
-                if i != j:
-                    self.add_propagator(
-                        (
-                            [*self.column(j, M_COLOR), self.cell(j, i, M_COLOR), self.cell(i, j, M_ROW)],
-                            ALG_ELEMENT_LIV,
-                            [],
-                        )
-                    )