NUCS 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 0.2.0
-Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Version: 0.3.0
+Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
 Project-URL: Issues, https://github.com/yangeorget/nucs

nucs-0.3.0/NUCS.egg-info/SOURCES.txt

@@ -0,0 +1,75 @@
+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/__init__.py
+nucs/memory.py
+nucs/statistics.py
+nucs/heuristics/heuristic.py
+nucs/heuristics/variable_heuristic.py
+nucs/problems/__init__.py
+nucs/problems/alpha_problem.py
+nucs/problems/bibd_problem.py
+nucs/problems/donald_problem.py
+nucs/problems/golomb_problem.py
+nucs/problems/knapsack_problem.py
+nucs/problems/latin_square_problem.py
+nucs/problems/problem.py
+nucs/problems/quasigroup_problem.py
+nucs/problems/queens_problem.py
+nucs/problems/schur_lemma_problem.py
+nucs/problems/sudoku_problem.py
+nucs/propagators/__init__.py
+nucs/propagators/affine_eq_propagator.py
+nucs/propagators/affine_geq_propagator.py
+nucs/propagators/affine_leq_propagator.py
+nucs/propagators/alldifferent_propagator.py
+nucs/propagators/count_eq_propagator.py
+nucs/propagators/dummy_propagator.py
+nucs/propagators/element_lic_propagator.py
+nucs/propagators/element_liv_propagator.py
+nucs/propagators/exactly_eq_propagator.py
+nucs/propagators/lexicographic_leq_propagator.py
+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/propagators.py
+nucs/propagators/relation_propagator.py
+nucs/solvers/__init__.py
+nucs/solvers/backtrack_solver.py
+nucs/solvers/solver.py
+tests/__init__.py
+tests/examples/test_alpha.py
+tests/examples/test_bibd.py
+tests/examples/test_donald.py
+tests/examples/test_golomb.py
+tests/examples/test_knapsack.py
+tests/examples/test_latin_square.py
+tests/examples/test_quasigroup.py
+tests/examples/test_queens.py
+tests/examples/test_schur_lemma.py
+tests/examples/test_sudokus.py
+tests/problems/__init__.py
+tests/problems/test_problem.py
+tests/propagators/__init__.py
+tests/propagators/test_affine_eq.py
+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_lic.py
+tests/propagators/test_element_liv.py
+tests/propagators/test_exactly_eq.py
+tests/propagators/test_lexicographic_leq.py
+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_relation.py
+tests/solvers/__init__.py
+tests/solvers/test_backtrack_solver.py

nucs-0.3.0/NUCS.egg-info/top_level.txt

@@ -0,0 +1,5 @@
+assets
+dist
+nucs
+scripts
+tests

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 0.2.0
-Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Version: 0.3.0
+Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs
 Project-URL: Issues, https://github.com/yangeorget/nucs

nucs-0.3.0/nucs/problems/donald_problem.py

@@ -0,0 +1,42 @@
+from typing import List
+
+from nucs.problems.problem import Problem
+from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ALLDIFFERENT
+
+A, B, D, E, G, L, N, O, R, T = tuple(range(10))
+
+
+class DonaldProblem(Problem):
+    """
+    This is the famous crypto-arithmetic puzzle DONALD+GERALD=ROBERT.
+    The letters represent digits that have to be all different.
+    """
+
+    def __init__(self) -> None:
+        super().__init__([(0, 9)] * 10)
+        self.add_propagator(
+            (
+                [A, B, D, E, G, L, N, O, R, T],
+                ALG_AFFINE_EQ,
+                [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, []),
+        )
+
+    def pretty_print_solution(self, solution: List[int]) -> None:
+        print(
+            {
+                "A": solution[A],
+                "B": solution[B],
+                "D": solution[D],
+                "E": solution[E],
+                "G": solution[G],
+                "L": solution[L],
+                "N": solution[N],
+                "O": solution[O],
+                "R": solution[R],
+                "T": solution[T],
+            }
+        )

{nucs-0.2.0 → nucs-0.3.0}/nucs/problems/golomb_problem.py

@@ -1,5 +1,5 @@
 import numpy as np
-from numba import njit
+from numba import njit  # type: ignore
 from numpy.typing import NDArray
 
 from nucs.heuristics.variable_heuristic import first_not_instantiated_var_heuristic

nucs-0.3.0/nucs/problems/knapsack_problem.py

@@ -0,0 +1,17 @@
+from typing import List
+
+from nucs.problems.problem import Problem
+from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_AFFINE_LEQ
+
+
+class KnapsackProblem(Problem):
+    """
+    This is problem #133 on https://www.csplib.org/Problems/prob133/.
+    """
+
+    def __init__(self, weights: List[int], volumes: List[int], capacity: int) -> None:
+        n = len(weights)
+        super().__init__([(0, 1)] * n + [(0, sum(weights))])
+        self.add_propagator((list(range(n)), ALG_AFFINE_LEQ, [*volumes, capacity]))
+        self.add_propagator((list(range(n + 1)), ALG_AFFINE_EQ, [*weights, -1, 0]))
+        self.weight = n

nucs-0.3.0/nucs/problems/latin_square_problem.py

@@ -0,0 +1,88 @@
+from typing import List, Optional
+
+from nucs.problems.problem import Problem
+from nucs.propagators.propagators import ALG_ALLDIFFERENT, ALG_ELEMENT_LIC
+
+M_COLOR = 0
+M_ROW = 1
+M_COLUMN = 2
+
+
+class LatinSquareProblem(Problem):
+    """
+    A simple model for latin squares.
+    """
+
+    def __init__(self, colors: List[int], givens: Optional[List[List[int]]] = None):
+        """
+        Inits the latin square.
+        :colors: the possible values for the cells,
+        usually [0, ..., n-1] except in some cases (eg Sudokus) where [1, ..., n] is preferred;
+        the number of colors is also the size of the square
+        :givens: initial values for the cells, any value different from the possible colors is used as a wildcard
+        """
+        self.colors = colors
+        self.n = len(colors)
+        if givens is None:
+            shr_domains = [(colors[0], colors[-1])] * self.n**2
+        else:
+            shr_domains = [
+                (colors[0], colors[-1]) if given not in self.colors else (given, given)
+                for line in givens
+                for given in line
+            ]
+        super().__init__(shr_domains)
+        self.add_propagators([(self.row(i), ALG_ALLDIFFERENT, []) for i in range(self.n)])
+        self.add_propagators([(self.column(j), ALG_ALLDIFFERENT, []) for j in range(self.n)])
+
+    def cell(self, i: int, j: int, model: int = M_COLOR) -> int:
+        offset = model * (self.n**2)
+        return offset + i * self.n + j
+
+    def row(self, i: int, model: int = M_COLOR) -> List[int]:
+        offset = model * (self.n**2)
+        return list(range(offset + i * self.n, offset + self.n + i * self.n))
+
+    def column(self, j: int, model: int = M_COLOR) -> List[int]:
+        offset = model * (self.n**2)
+        return list(range(offset + j, offset + self.n**2 + j, self.n))
+
+    def pretty_print_solution(self, solution: List[int]) -> None:
+        for i in range(0, self.n**2, self.n):
+            print(solution[i : i + self.n])
+
+
+class LatinSquareRCProblem(LatinSquareProblem):
+    """
+    A full model for latin squares with 3 kinds of variables:
+    - n*n variables for the values (aka colors), these variables are indexed by rows then columns
+    - n*n variables for the rows, these variables are indexed by colors then columns
+    - n*n variables for the columns, these variables are indexed by rows then colors
+    """
+
+    def __init__(self, n: int):
+        super().__init__(list(range(n)))  # the color model
+        self.add_variables([(0, n - 1)] * n**2)  # the row model
+        self.add_variables([(0, n - 1)] * n**2)  # the column model
+        self.add_propagators([(self.row(i, M_ROW), ALG_ALLDIFFERENT, []) for i in range(self.n)])
+        self.add_propagators([(self.column(j, M_ROW), ALG_ALLDIFFERENT, []) for j in range(self.n)])
+        self.add_propagators([(self.row(i, M_COLUMN), ALG_ALLDIFFERENT, []) for i in range(self.n)])
+        self.add_propagators([(self.column(j, M_COLUMN), ALG_ALLDIFFERENT, []) for j in range(self.n)])
+        # row[c,j]=i <=> column[i,c]=j
+        for c in range(n):
+            for i in range(n):
+                self.add_propagator(([*self.row(c, M_ROW), self.cell(i, c, M_COLUMN)], ALG_ELEMENT_LIC, [i]), 0)
+            for j in range(n):
+                self.add_propagator(([*self.column(c, M_COLUMN), self.cell(c, j, M_ROW)], ALG_ELEMENT_LIC, [j]), 0)
+        # row[c,j]=i <=> color[i,j]=c
+        for j in range(n):
+            for i in range(n):
+                self.add_propagator(([*self.column(j, M_ROW), self.cell(i, j, M_COLOR)], ALG_ELEMENT_LIC, [i]), 0)
+            for c in range(n):
+                self.add_propagator(([*self.column(j, M_COLOR), self.cell(c, j, M_ROW)], ALG_ELEMENT_LIC, [c]), 0)
+        # color[i,j]=c <=> column[i,c]=j
+        for i in range(n):
+            for c in range(n):
+                self.add_propagator(([*self.row(i, M_COLOR), self.cell(i, c, M_COLUMN)], ALG_ELEMENT_LIC, [c]), 0)
+            for j in range(n):
+                self.add_propagator(([*self.row(i, M_COLUMN), self.cell(i, j, M_COLOR)], ALG_ELEMENT_LIC, [j]), 0)

nucs-0.3.0/nucs/problems/quasigroup_problem.py

@@ -0,0 +1,42 @@
+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):
+    """
+    This is problem #3 on CSPLIB (https://www.csplib.org/Problems/prob003/).
+    """
+
+    def __init__(self, n: int):
+        super().__init__(n)
+        # idempotence
+        for model in [M_COLOR, M_ROW, M_COLUMN]:
+            for i in range(n):
+                self.shr_domains_list[self.cell(i, i, model)] = i
+        # symmetry breaking
+        for i in range(1, n):
+            self.shr_domains_list[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):
+        super().__init__(n)
+        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,
+                            [],
+                        ),
+                        0,
+                    )

nucs-0.3.0/nucs/propagators/element_lic_propagator.py

@@ -0,0 +1,61 @@
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_ENTAILMENT, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers_element_lic(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains_element_lic(domains: NDArray, data: NDArray) -> int:
+    """
+    Enforces l_i = c.
+    :param domains: the domains of the variables
+    :param data: the parameters of the propagator
+    """
+    l = domains[:-1]
+    i = domains[-1]
+    # update i
+    i[MIN] = max(i[MIN], 0)
+    i[MAX] = min(i[MAX], len(l) - 1)
+    if i[MAX] < i[MIN]:
+        return PROP_INCONSISTENCY
+    c = data[0]
+    i_min = i[MIN]
+    i_max = i[MAX]
+    for idx in range(i[MIN], i[MAX] + 1):
+        if c < l[idx, MIN] or c > l[idx, MAX]:  # no intersection
+            if idx == i_min:
+                i_min += 1
+            elif idx == i_max:
+                i_max -= 1
+    if i_max < i_min:
+        return PROP_INCONSISTENCY
+    i[MIN] = i_min
+    i[MAX] = i_max
+    # when strict, update l
+    # for idx in range(0, i[MIN]):
+    #     if l[idx, MIN] == c:
+    #         l[idx, MIN] = c + 1
+    #     elif l[idx, MAX] == c:
+    #         l[idx, MAX] = c - 1
+    #     if l[idx, MIN] > l[idx, MAX]:
+    #         return PROP_INCONSISTENCY
+    # for idx in range(i[MAX] + 1, len(l)):
+    #     if l[idx, MIN] == c:
+    #         l[idx, MIN] = c + 1
+    #     elif l[idx, MAX] == c:
+    #         l[idx, MAX] = c - 1
+    #     if l[idx, MIN] > l[idx, MAX]:
+    #         return PROP_INCONSISTENCY
+    if i_min == i_max:
+        l[i_min, MIN] = l[i_max, MAX] = c
+        return PROP_ENTAILMENT
+    return PROP_CONSISTENCY

nucs-0.3.0/nucs/propagators/element_liv_propagator.py

@@ -0,0 +1,58 @@
+import sys
+
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_ENTAILMENT, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers_element_liv(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains_element_liv(domains: NDArray, data: NDArray) -> int:
+    """
+    Enforces l_i = x.
+    :param domains: the domains of the variables
+    :param data: the parameters of the propagator
+    """
+    l = domains[:-2]
+    i = domains[-2]
+    i[MIN] = max(i[MIN], 0)
+    i[MAX] = min(i[MAX], len(l) - 1)
+    if i[MAX] < i[MIN]:
+        return PROP_INCONSISTENCY
+    x = domains[-1]
+    x_min = sys.maxsize
+    x_max = -sys.maxsize
+    i_min = i[MIN]
+    i_max = i[MAX]
+    for idx in range(i[MIN], i[MAX] + 1):
+        if x[MAX] < l[idx, MIN] or x[MIN] > l[idx, MAX]:  # no intersection
+            if idx == i_min:
+                i_min += 1
+            elif idx == i_max:
+                i_max -= 1
+        else:  # intersection
+            if l[idx, MIN] < x_min:
+                x_min = l[idx, MIN]
+            if l[idx, MAX] > x_max:
+                x_max = l[idx, MAX]
+    if i_max < i_min:
+        return PROP_INCONSISTENCY
+    i[MIN] = i_min
+    i[MAX] = i_max
+    x[MIN] = max(x[MIN], x_min)
+    x[MAX] = min(x[MAX], x_max)
+    if i_min == i_max:
+        l[i_min, MIN] = max(l[i_min, MIN], x[MIN])
+        l[i_max, MAX] = min(l[i_max, MAX], x[MAX])
+        if x[MIN] == x[MAX]:
+            return PROP_ENTAILMENT
+    return PROP_CONSISTENCY

nucs-0.3.0/nucs/propagators/relation_propagator.py

@@ -0,0 +1,35 @@
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_ENTAILMENT, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers_relation(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains_relation(domains: NDArray, data: NDArray) -> int:
+    """
+    :param domains: the domains of the variables
+    :param data: the parameters of the propagator
+    """
+    n = len(domains)
+    tuples = data.copy().reshape((-1, n))
+    for domain_idx in range(n):
+        tuples = tuples[
+            (tuples[:, domain_idx] >= domains[domain_idx, MIN]) & (tuples[:, domain_idx] <= domains[domain_idx, MAX])
+        ]
+        if len(tuples) == 0:
+            return PROP_INCONSISTENCY
+    for domain_idx in range(n):  # no support for .min(axis=0) in Numba
+        domains[domain_idx, MIN] = tuples[:, domain_idx].min()
+        domains[domain_idx, MAX] = tuples[:, domain_idx].max()
+    if len(tuples) == 1:
+        return PROP_ENTAILMENT
+    return PROP_CONSISTENCY

{nucs-0.2.0 → nucs-0.3.0}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name="NUCS"
-version="0.2.0"
+version="0.3.0"
 authors = [
   { name="Yan Georget", email="yan.georget@gmail.com" },
 ]
-description="A Numpy and Numba based Python library for solving Constraint Satifaction Problems"
+description="A Numpy and Numba based Python library for solving Constraint Satisfaction Problems"
 readme = "README.md"
 requires-python = ">=3.9"
 classifiers = [
@@ -30,5 +30,5 @@ line_length = 120
 [tool.black]
 line-length = 120
 
-[tool.setuptools]
-packages = ["nucs"]
+[tool.setuptools.packages]
+find = {}

nucs-0.3.0/tests/examples/test_alpha.py

@@ -0,0 +1,50 @@
+from pprint import pprint
+
+from nucs.heuristics.variable_heuristic import VariableHeuristic, min_value_dom_heuristic, smallest_domain_var_heuristic
+from nucs.problems.alpha_problem import AlphaProblem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.statistics import STATS_SOLVER_SOLUTION_NB, get_statistics
+
+
+class TestAlpha:
+    def test_alpha(self) -> None:
+        problem = AlphaProblem()
+        solver = BacktrackSolver(problem, VariableHeuristic(smallest_domain_var_heuristic, min_value_dom_heuristic))
+        solutions = solver.solve_all()
+        assert problem.statistics[STATS_SOLVER_SOLUTION_NB] == 1
+        assert solutions[0][:26] == [
+            5,
+            13,
+            9,
+            16,
+            20,
+            4,
+            24,
+            21,
+            25,
+            17,
+            23,
+            2,
+            8,
+            12,
+            10,
+            19,
+            7,
+            11,
+            15,
+            3,
+            1,
+            26,
+            6,
+            22,
+            14,
+            18,
+        ]
+
+
+if __name__ == "__main__":
+    problem = AlphaProblem()
+    solver = BacktrackSolver(problem, VariableHeuristic(smallest_domain_var_heuristic, min_value_dom_heuristic))
+    solutions = solver.solve_all()
+    pprint(get_statistics(problem.statistics))
+    print(solutions[0])

nucs-0.3.0/tests/examples/test_bibd.py

@@ -0,0 +1,26 @@
+from pprint import pprint
+
+from nucs.problems.bibd_problem import BIBDProblem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.statistics import STATS_SOLVER_SOLUTION_NB, get_statistics
+
+
+class TestBIBD:
+    def test_6_10_5_3_2(self) -> None:
+        problem = BIBDProblem(6, 10, 5, 3, 2)
+        solver = BacktrackSolver(problem)
+        solver.find_all()
+        assert problem.statistics[STATS_SOLVER_SOLUTION_NB] == 1
+
+    def test_8_14_7_4_3(self) -> None:
+        problem = BIBDProblem(8, 14, 7, 4, 3)
+        solver = BacktrackSolver(problem)
+        solver.find_all()
+        assert problem.statistics[STATS_SOLVER_SOLUTION_NB] == 92
+
+
+if __name__ == "__main__":
+    problem = BIBDProblem(8, 14, 7, 4, 3)
+    solver = BacktrackSolver(problem)
+    solver.find_all()
+    pprint(get_statistics(problem.statistics))

nucs-0.3.0/tests/examples/test_donald.py

@@ -0,0 +1,23 @@
+from pprint import pprint
+
+from nucs.heuristics.variable_heuristic import VariableHeuristic, min_value_dom_heuristic, smallest_domain_var_heuristic
+from nucs.problems.donald_problem import DonaldProblem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.statistics import STATS_SOLVER_SOLUTION_NB, get_statistics
+
+
+class TestDonald:
+    def test_donald(self) -> None:
+        problem = DonaldProblem()
+        solver = BacktrackSolver(problem, VariableHeuristic(smallest_domain_var_heuristic, min_value_dom_heuristic))
+        solutions = solver.solve_all()
+        assert problem.statistics[STATS_SOLVER_SOLUTION_NB] == 1
+        assert solutions[0] == [4, 3, 5, 9, 1, 8, 6, 2, 7, 0]
+
+
+if __name__ == "__main__":
+    problem = DonaldProblem()
+    solver = BacktrackSolver(problem, VariableHeuristic(smallest_domain_var_heuristic, min_value_dom_heuristic))
+    for solution in solver.solve():
+        problem.pretty_print_solution(solution)
+    pprint(get_statistics(problem.statistics))

nucs-0.3.0/tests/examples/test_golomb.py

@@ -0,0 +1,53 @@
+import argparse
+from pprint import pprint
+
+import numpy as np
+import pytest
+
+from nucs.memory import MIN
+from nucs.problems.golomb_problem import GolombProblem, index, init_domains
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.statistics import get_statistics
+
+
+class TestGolomb:
+
+    @pytest.mark.parametrize(
+        "mark_nb,i,j,idx", [(4, 0, 1, 0), (4, 0, 2, 1), (4, 0, 3, 2), (4, 1, 2, 3), (4, 1, 3, 4), (4, 2, 3, 5)]
+    )
+    def test_index(self, mark_nb: int, i: int, j: int, idx: int) -> None:
+        assert index(mark_nb, i, j) == idx
+
+    def test_init_domains(self) -> None:
+        domains = init_domains(6, 4)
+        assert domains[:, MIN].tolist() == [1, 3, 6, 1, 3, 1]
+
+    def test_golomb_4_filter(self) -> None:
+        problem = GolombProblem(4)
+        problem.shr_domains_list[0] = 1
+        problem.shr_domains_list[1] = 4
+        problem.shr_domains_list[2] = 6
+        problem.shr_domains_list[3] = 3
+        problem.shr_domains_list[4] = 5
+        problem.shr_domains_list[5] = 2
+        assert problem.filter(np.ones((6, 2), dtype=bool))
+
+    @pytest.mark.parametrize("mark_nb,solution_nb", [(4, 6), (5, 11), (6, 17), (7, 25), (8, 34), (9, 44)])
+    def test_golomb(self, mark_nb: int, solution_nb: int) -> None:
+        problem = GolombProblem(mark_nb)
+        solver = BacktrackSolver(problem)
+        solution = solver.minimize(problem.length_idx)
+        assert solution
+        assert solution[problem.length_idx] == solution_nb
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-n", type=int, default=10)
+    args = parser.parse_args()
+    problem = GolombProblem(args.n)
+    solver = BacktrackSolver(problem)
+    solution = solver.minimize(problem.length_idx)
+    pprint(get_statistics(problem.statistics))
+    print(solution)
+    print(solution[problem.length_idx])  # type: ignore

nucs-0.3.0/tests/examples/test_knapsack.py

@@ -0,0 +1,37 @@
+from pprint import pprint
+
+from nucs.heuristics.variable_heuristic import (
+    VariableHeuristic,
+    first_not_instantiated_var_heuristic,
+    max_value_dom_heuristic,
+)
+from nucs.problems.knapsack_problem import KnapsackProblem
+from nucs.solvers.backtrack_solver import BacktrackSolver
+from nucs.statistics import get_statistics
+
+
+class TestKnapsack:
+    def test_knapsack(self) -> None:
+        problem = KnapsackProblem(
+            [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],
+            [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],
+            55,
+        )
+        solver = BacktrackSolver(
+            problem, VariableHeuristic(first_not_instantiated_var_heuristic, max_value_dom_heuristic)
+        )
+        solution = solver.maximize(problem.weight)
+        assert solution
+        assert solution[problem.weight] == 54
+
+
+if __name__ == "__main__":
+    problem = KnapsackProblem(
+        [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],
+        [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],
+        55,
+    )
+    solver = BacktrackSolver(problem, VariableHeuristic(first_not_instantiated_var_heuristic, max_value_dom_heuristic))
+    solution = solver.maximize(problem.weight)
+    pprint(get_statistics(problem.statistics))
+    print(solution)