NUCS 4.2.0__tar.gz → 4.3.0__tar.gz

{nucs-4.2.0 → nucs-4.3.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.2.0
+Version: 4.3.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-4.2.0 → nucs-4.3.0}/NUCS.egg-info/SOURCES.txt

@@ -49,11 +49,10 @@ nucs/examples/sudoku/__init__.py
 nucs/examples/sudoku/sudoku_problem.py
 nucs/examples/tsp/__init__.py
 nucs/examples/tsp/__main__.py
-nucs/examples/tsp/mcp_dom_heuristic.py
-nucs/examples/tsp/mrp_var_heuristic.py
 nucs/examples/tsp/total_cost_propagator.py
 nucs/examples/tsp/tsp_instances.py
 nucs/examples/tsp/tsp_problem.py
+nucs/examples/tsp/tsp_var_heuristic.py
 nucs/heuristics/__init__.py
 nucs/heuristics/first_not_instantiated_var_heuristic.py
 nucs/heuristics/greatest_domain_var_heuristic.py
@@ -70,6 +69,7 @@ nucs/heuristics/value_dom_heuristic.py
 nucs/problems/__init__.py
 nucs/problems/circuit_problem.py
 nucs/problems/latin_square_problem.py
+nucs/problems/permutation_problem.py
 nucs/problems/problem.py
 nucs/propagators/__init__.py
 nucs/propagators/affine_eq_propagator.py
@@ -91,6 +91,7 @@ nucs/propagators/max_leq_propagator.py
 nucs/propagators/min_eq_propagator.py
 nucs/propagators/min_geq_propagator.py
 nucs/propagators/no_sub_cycle_propagator.py
+nucs/propagators/permutation_aux_propagator.py
 nucs/propagators/propagators.py
 nucs/propagators/relation_propagator.py
 nucs/propagators/scc_propagator.py
@@ -123,6 +124,7 @@ tests/heuristics/test_mid_value_dom_heuristic.py
 tests/heuristics/test_min_value_dom_heuristic.py
 tests/problems/__init__.py
 tests/problems/test_circuit_problem.py
+tests/problems/test_permutation_problem.py
 tests/problems/test_problem.py
 tests/propagators/__init__.py
 tests/propagators/test_affine_eq.py

{nucs-4.2.0/NUCS.egg-info → nucs-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.2.0
+Version: 4.3.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-4.2.0 → nucs-4.3.0}/docs/source/conf.py

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

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/alpha/alpha_problem.py

@@ -24,7 +24,7 @@ class AlphaProblem(Problem):
     """
     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).
+    (eg for LYRE: L,Y,R,E might be to equal 5,9,20 and 13 or any other combination that add up to 47).
 
     Find the value of each letter under the equations:
     BALLET  45     GLEE  66     POLKA      59     SONG     61
@@ -67,7 +67,8 @@ class AlphaProblem(Problem):
             ]
         )
 
-    def solution_as_dict(self, solution: NDArray) -> Dict[str, int]:
+    @staticmethod
+    def solution_as_dict(solution: NDArray) -> Dict[str, int]:
         """
         Returns the solution as a dict.
         :param solution: the solution as a list of ints

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/donald/donald_problem.py

@@ -10,9 +10,9 @@
 #
 # Copyright 2024 - Yan Georget
 ###############################################################################
-from typing import Dict
+from typing import Any, Dict
 
-from numpy._typing import NDArray
+from numpy.typing import NDArray
 
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ALLDIFFERENT
@@ -40,7 +40,8 @@ class DonaldProblem(Problem):
         )
         self.add_propagator(([A, B, D, E, G, L, N, O, R, T], ALG_ALLDIFFERENT, []))
 
-    def solution_as_dict(self, solution: NDArray) -> Dict[str, int]:
+    @staticmethod
+    def solution_as_dict(solution: NDArray) -> Dict[str, Any]:
         """
         Returns the solution as a dict.
         :param solution: the solution as a list of ints

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/golomb/golomb_problem.py

@@ -19,7 +19,7 @@ from numpy.typing import NDArray
 from nucs.constants import EVENT_MASK_GROUND, EVENT_MASK_MIN, MAX, MIN
 from nucs.heuristics.heuristics import first_not_instantiated_var_heuristic
 from nucs.problems.problem import Problem
-from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_AFFINE_LEQ, ALG_ALLDIFFERENT, add_propagators
+from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_AFFINE_LEQ, ALG_ALLDIFFERENT, update_propagators
 from nucs.solvers.bound_consistency_algorithm import bound_consistency_algorithm
 
 GOLOMB_LENGTHS = np.array([0, 0, 1, 3, 6, 11, 17, 25, 34, 44, 55, 72, 85, 106, 127])
@@ -161,7 +161,7 @@ def golomb_consistency_algorithm(
                 events = EVENT_MASK_MIN
                 if shr_domains_stack[top, dom_idx, MIN] == shr_domains_stack[top, dom_idx, MAX]:
                     events |= EVENT_MASK_GROUND
-                add_propagators(
+                update_propagators(
                     triggered_propagators,
                     not_entailed_propagators_stack[top],
                     shr_domains_propagators,

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/magic_square/__main__.py

@@ -24,7 +24,7 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
-    parser.add_argument("-n", type=int)
+    parser.add_argument("-n", type=int, default=4)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = MagicSquareProblem(args.n, args.symmetry_breaking)

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/queens/queens_problem.py

@@ -37,6 +37,7 @@ class QueensProblem(Problem):
         self.add_propagator((list(range(n, 2 * n)), ALG_ALLDIFFERENT, []))
         self.add_propagator((list(range(2 * n, 3 * n)), ALG_ALLDIFFERENT, []))
 
-    def solution_as_matrix(self, solution: List[int]) -> List[List[str]]:
+    @staticmethod
+    def solution_as_matrix(solution: List[int]) -> List[List[str]]:
         n = len(solution)
         return [([" "] * i + ["X"] + [" "] * (n - i - 1)) for i in range(n)]

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/sports_tournament_scheduling/sports_tournament_scheduling_problem.py

@@ -12,7 +12,7 @@
 ###############################################################################
 from typing import List
 
-from numpy._typing import NDArray
+from numpy.typing import NDArray
 
 from nucs.problems.problem import Problem
 from nucs.propagators.propagators import ALG_ALLDIFFERENT, ALG_EXACTLY_EQ, ALG_GCC, ALG_RELATION

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/tsp/__main__.py

@@ -15,7 +15,8 @@ import argparse
 from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_PRUNE
 from nucs.examples.tsp.tsp_instances import TSP_INSTANCES
 from nucs.examples.tsp.tsp_problem import TSPProblem
-from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_COST, VAR_HEURISTIC_MAX_REGRET
+from nucs.examples.tsp.tsp_var_heuristic import tsp_var_heuristic
+from nucs.heuristics.heuristics import DOM_HEURISTIC_MIN_COST, register_var_heuristic
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import CONSISTENCY_ALG_BC, CONSISTENCY_ALG_SHAVING
 from nucs.solvers.multiprocessing_solver import MultiprocessingSolver
@@ -28,21 +29,25 @@ if __name__ == "__main__":
     parser.add_argument("--name", choices=["GR17", "GR21", "GR24"], default="GR17")
     parser.add_argument("--opt_mode", choices=OPT_MODES, default=OPT_PRUNE)
     parser.add_argument("--processors", type=int, default=1)
-    parser.add_argument("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=True)
+    parser.add_argument("--shaving", type=bool, action=argparse.BooleanOptionalAction, default=False)
     args = parser.parse_args()
     tsp_instance = TSP_INSTANCES[args.name]
+    n = len(tsp_instance)
+    decision_domains = list(range(0, 2 * n))
     problem = TSPProblem(tsp_instance)
+    costs = tsp_instance + tsp_instance  # symmetry of costs
+    tsp_var_heuristic_idx = register_var_heuristic(tsp_var_heuristic)
     solver = (
         MultiprocessingSolver(
             [
                 BacktrackSolver(
                     prob,
                     consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
-                    decision_domains=list(range(len(tsp_instance))),
-                    var_heuristic_idx=VAR_HEURISTIC_MAX_REGRET,  # register_var_heuristic(mrp_var_heuristic),
-                    var_heuristic_params=tsp_instance,
-                    dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,  # register_dom_heuristic(mcp_dom_heuristic),
-                    dom_heuristic_params=tsp_instance,
+                    decision_domains=decision_domains,
+                    var_heuristic_idx=tsp_var_heuristic_idx,
+                    var_heuristic_params=costs,
+                    dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,
+                    dom_heuristic_params=costs,
                     log_level=args.log_level,
                 )
                 for prob in problem.split(args.processors, 0)
@@ -52,13 +57,13 @@ if __name__ == "__main__":
         else BacktrackSolver(
             problem,
             consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
-            decision_domains=list(range(len(tsp_instance))),
-            var_heuristic_idx=VAR_HEURISTIC_MAX_REGRET,  # register_var_heuristic(mrp_var_heuristic),
-            var_heuristic_params=tsp_instance,
-            dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,  # register_dom_heuristic(mcp_dom_heuristic),
-            dom_heuristic_params=tsp_instance,
+            decision_domains=decision_domains,
+            var_heuristic_idx=tsp_var_heuristic_idx,
+            var_heuristic_params=costs,
+            dom_heuristic_idx=DOM_HEURISTIC_MIN_COST,
+            dom_heuristic_params=costs,
             log_level=args.log_level,
         )
     )
-    solution = solver.minimize(problem.shr_domain_nb - 1, mode=args.opt_mode)
+    solution = solver.minimize(problem.total_cost, mode=args.opt_mode)
     print(solver.get_statistics())

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/tsp/total_cost_propagator.py

@@ -26,7 +26,7 @@ def get_complexity_total_cost(n: int, parameters: NDArray) -> float:
     :param parameters: the parameters, unused here
     :return: a float
     """
-    return 2 * n
+    return n * n
 
 
 def get_triggers_total_cost(n: int, parameters: NDArray) -> NDArray:
@@ -53,7 +53,18 @@ def compute_domains_total_cost(domains: NDArray, parameters: NDArray) -> int:
     for i in range(n):
         if domains[i, MIN] == domains[i, MAX]:
             used[domains[i, MIN]] = True
-    global_min = global_max = 0
+    global_min = 0
+    # for j in range(n):
+    #     max_regret = 0
+    #     min_cost = min([costs[i, j] for i in range(n) if costs[i,j] > 0])
+    #     for i in range(n):
+    #         if costs[i, j] == min_cost:
+    #             regret = compute_regret(domains[i], costs[i])
+    #             if regret > max_regret:
+    #                 max_regret = regret
+    #             global_min += regret
+    #     global_min -= max_regret
+    global_max = 0
     for i in range(n):
         if domains[i, MIN] == domains[i, MAX]:
             local_min = local_max = parameters[i * n + domains[i, MIN]]
@@ -68,8 +79,8 @@ def compute_domains_total_cost(domains: NDArray, parameters: NDArray) -> int:
                             local_min = cost
                         if cost > local_max:
                             local_max = cost
-            if local_min > local_max:
-                return PROP_INCONSISTENCY
+            # if local_min > local_max:
+            #     return PROP_INCONSISTENCY
         global_min += local_min
         global_max += local_max
     domains[-1, MIN] = max(domains[-1, MIN], global_min)

{nucs-4.2.0 → nucs-4.3.0}/nucs/examples/tsp/tsp_problem.py

@@ -33,15 +33,21 @@ class TSPProblem(CircuitProblem):
         super().__init__(n)
         max_costs = [max(cost_row) for cost_row in cost_rows]
         min_costs = [min([cost for cost in cost_row if cost > 0]) for cost_row in cost_rows]
-        cost_vars = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])  # the costs
-        total_cost_var = self.add_variable((sum(min_costs), sum(max_costs)))  # the total cost
+        self.next_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
+        self.prev_costs = self.add_variables([(min_costs[i], max_costs[i]) for i in range(n)])
+        self.total_cost = self.add_variable((sum(min_costs), sum(max_costs)))  # the total cost
         for i in range(n):
-            self.add_propagator(([i, cost_vars + i], ALG_ELEMENT_IV, cost_rows[i]))
-        self.add_propagator((list(range(cost_vars, cost_vars + n + 1)), ALG_AFFINE_EQ, [1] * n + [-1, 0]))
+            self.add_propagator(([i, self.next_costs + i], ALG_ELEMENT_IV, cost_rows[i]))
+            self.add_propagator(([n + i, self.prev_costs + i], ALG_ELEMENT_IV, cost_rows[i]))
         self.add_propagator(
-            (
-                list(range(0, n)) + [total_cost_var],
-                register_propagator(get_triggers_total_cost, get_complexity_total_cost, compute_domains_total_cost),
-                [cost for cost_row in cost_rows for cost in cost_row],
-            )
+            (list(range(self.next_costs, self.next_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
         )
+        self.add_propagator(
+            (list(range(self.prev_costs, self.prev_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
+        )
+        total_cost_prop_idx = register_propagator(
+            get_triggers_total_cost, get_complexity_total_cost, compute_domains_total_cost
+        )
+        costs = [cost for cost_row in cost_rows for cost in cost_row]
+        self.add_propagator((list(range(n)) + [self.total_cost], total_cost_prop_idx, costs))
+        self.add_propagator((list(range(n, 2 * n)) + [self.total_cost], total_cost_prop_idx, costs))

nucs-4.3.0/nucs/examples/tsp/tsp_var_heuristic.py

@@ -0,0 +1,52 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import sys
+
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.constants import MAX, MIN
+from nucs.heuristics.max_regret_var_heuristic import regret
+
+
+@njit(cache=True)
+def tsp_var_heuristic(
+    decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray, params: NDArray
+) -> int:
+    """
+    :param decision_domains: the indices of a subset of the shared domains
+    :param shr_domains_stack: the stack of shared domains
+    :param stacks_top: the index of the top of the stacks as a Numpy array
+    :param params: a two-dimensional (first dimension correspond to variables, second to values) costs array
+    :return: the index of the shared domain
+    """
+    best_score = -sys.maxsize
+    best_idx = -1
+    top = stacks_top[0]
+    for dom_idx in decision_domains:
+        shr_domain = shr_domains_stack[top, dom_idx]
+        if 0 < shr_domain[MAX] - shr_domain[MIN]:
+            score = compute_score(shr_domain, dom_idx, params)
+            if best_score < score:
+                best_idx = dom_idx
+                best_score = score
+    return best_idx
+
+
+@njit(cache=True)
+def compute_score(shr_domain: NDArray, dom_idx: int, params: NDArray) -> int:
+    """
+    Minimize [min(5, size(X)), -regret(X)] for lexicographic order.
+    """
+    size = min(12, shr_domain[MAX] - shr_domain[MIN] + 1)
+    return -size * 1024 + regret(shr_domain, params[dom_idx])

{nucs-4.2.0 → nucs-4.3.0}/nucs/heuristics/greatest_domain_var_heuristic.py

@@ -28,13 +28,13 @@ def greatest_domain_var_heuristic(
     :param params: a two-dimensional parameters array, unused here
     :return: the index of the shared domain
     """
-    max_size = 0
-    max_idx = -1
+    best_score = 0
+    best_idx = -1
     top = stacks_top[0]
     for dom_idx in decision_domains:
         shr_domain = shr_domains_stack[top, dom_idx]
-        size = shr_domain[MAX] - shr_domain[MIN]  # actually this is size - 1
-        if max_size < size:
-            max_idx = dom_idx
-            max_size = size
-    return max_idx
+        score = shr_domain[MAX] - shr_domain[MIN]  # this is size - 1
+        if best_score < score:
+            best_idx = dom_idx
+            best_score = score
+    return best_idx

{nucs-4.2.0 → nucs-4.3.0}/nucs/heuristics/max_regret_var_heuristic.py

@@ -30,24 +30,28 @@ def max_regret_var_heuristic(
     :param params: a two-dimensional (first dimension correspond to variables, second to values) costs array
     :return: the index of the shared domain
     """
-    max_regret = 0
+    best_score = 0
     best_idx = -1
     top = stacks_top[0]
     for dom_idx in decision_domains:
         shr_domain = shr_domains_stack[top, dom_idx]
         if 0 < shr_domain[MAX] - shr_domain[MIN]:
-            best_cost = sys.maxsize
-            second_cost = sys.maxsize
-            for value in range(shr_domain[MIN], shr_domain[MAX] + 1):
-                cost = params[dom_idx][value]
-                if cost > 0:
-                    if cost < best_cost:
-                        second_cost = best_cost
-                        best_cost = cost
-                    elif cost < second_cost:
-                        second_cost = cost
-            regret = second_cost - best_cost
-            if max_regret < regret:
+            score = regret(shr_domain, params[dom_idx])
+            if best_score < score:
                 best_idx = dom_idx
-                max_regret = regret
+                best_score = score
     return best_idx
+
+
+@njit(cache=True)
+def regret(domain: NDArray, costs: NDArray) -> int:
+    best_cost = sys.maxsize
+    second_cost = sys.maxsize
+    for value in range(domain[MIN], domain[MAX] + 1):
+        cost = costs[value]
+        if 0 < cost < best_cost:
+            second_cost = best_cost
+            best_cost = cost
+        elif 0 < cost < second_cost:
+            second_cost = cost
+    return second_cost - best_cost

{nucs-4.2.0 → nucs-4.3.0}/nucs/heuristics/smallest_domain_var_heuristic.py

@@ -30,13 +30,13 @@ def smallest_domain_var_heuristic(
     :param params: a two-dimensional parameters array, unused here
     :return: the index of the shared domain
     """
-    min_size = sys.maxsize
-    min_idx = -1
+    best_score = -sys.maxsize
+    best_idx = -1
     top = stacks_top[0]
     for dom_idx in decision_domains:
         shr_domain = shr_domains_stack[top, dom_idx]
-        size = shr_domain[MAX] - shr_domain[MIN]  # actually this is size - 1
-        if 0 < size < min_size:
-            min_idx = dom_idx
-            min_size = size
-    return min_idx
+        score = shr_domain[MIN] - shr_domain[MAX]
+        if best_score < score < 0:
+            best_idx = dom_idx
+            best_score = score
+    return best_idx

{nucs-4.2.0 → nucs-4.3.0}/nucs/numba_helper.py

@@ -26,9 +26,9 @@ def function_from_address(typingctx, func_type_ref: types.FunctionType, addr: in
     func_type = func_type_ref.instance_type
 
     def codegen(context, builder, sig, args):  # type: ignore
-        _, addr = args
+        _, address = args
         sfunc = cgutils.create_struct_proxy(func_type)(context, builder)
-        sfunc.addr = builder.inttoptr(addr, context.get_value_type(types.voidptr))
+        sfunc.addr = builder.inttoptr(address, context.get_value_type(types.voidptr))
         return sfunc._getvalue()
 
     return func_type(func_type_ref, addr), codegen

nucs-4.3.0/nucs/problems/circuit_problem.py

@@ -0,0 +1,36 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+from nucs.problems.permutation_problem import PermutationProblem
+from nucs.propagators.propagators import ALG_NO_SUB_CYCLE
+
+
+class CircuitProblem(PermutationProblem):
+    """
+    A model for circuit.
+    """
+
+    def __init__(self, n: int):
+        """
+        Inits the circuit problem.
+        :param n: the number of vertices
+        """
+        self.n = n
+        super().__init__(n)
+        self.shr_domains_lst[0] = [1, n - 1]
+        self.shr_domains_lst[n - 1] = [0, n - 2]
+        self.shr_domains_lst[n] = [1, n - 1]
+        self.shr_domains_lst[2 * n - 1] = [0, n - 2]
+        self.add_propagator((list(range(n)), ALG_NO_SUB_CYCLE, []))
+        self.add_propagator((list(range(n, 2 * n)), ALG_NO_SUB_CYCLE, []))
+        # self.add_propagator((list(range(n)), ALG_SCC, []))  # not worth the cost
+        # self.add_propagator((list(range(n, 2*n)), ALG_SCC, []))  # not worth the cost

nucs-4.2.0/nucs/problems/circuit_problem.py → nucs-4.3.0/nucs/problems/permutation_problem.py

@@ -11,23 +11,24 @@
 # Copyright 2024 - Yan Georget
 ###############################################################################
 from nucs.problems.problem import Problem
-from nucs.propagators.propagators import ALG_ALLDIFFERENT, ALG_NO_SUB_CYCLE
+from nucs.propagators.propagators import ALG_ALLDIFFERENT, ALG_PERMUTATION_AUX
 
 
-class CircuitProblem(Problem):
+class PermutationProblem(Problem):
     """
-    A model for circuit.
+    A model for permutation.
     """
 
     def __init__(self, n: int):
         """
-        Inits the circuit problem.
-        :param n: the number of vertices
+        Inits the permutation problem.
+        :param n: the number variables/values
         """
         self.n = n
-        shr_domains = [(1, n - 1)] + [(0, n - 1)] * (n - 2) + [(0, n - 2)]
+        shr_domains = [(0, n - 1)] * 2 * n
         super().__init__(shr_domains)
-        s_indices = list(range(n))
-        self.add_propagator((s_indices, ALG_ALLDIFFERENT, []))
-        self.add_propagator((s_indices, ALG_NO_SUB_CYCLE, []))
-        # self.add_propagator((s_indices, ALG_SCC, []))  # not worth the cost
+        for i in range(n):
+            self.add_propagator((list(range(n)) + [n + i], ALG_PERMUTATION_AUX, [i]))
+            self.add_propagator((list(range(n, 2 * n)) + [i], ALG_PERMUTATION_AUX, [i]))
+        self.add_propagator((list(range(n)), ALG_ALLDIFFERENT, []))
+        self.add_propagator((list(range(n, 2 * n)), ALG_ALLDIFFERENT, []))

{nucs-4.2.0 → nucs-4.3.0}/nucs/propagators/gcc_propagator.py

@@ -44,7 +44,7 @@ def init_partial_sum(first_value: int, m: int, values: NDArray) -> NDArray:
     """
     Inits the partial_sum data structure:
     ---------------------
-    | sum | first_value |
+    | sm | first_value |
     ---------------------
     | ds  | last_value  |
     ---------------------
@@ -52,19 +52,19 @@ def init_partial_sum(first_value: int, m: int, values: NDArray) -> NDArray:
     partial_sum = np.zeros((2, m + 6), dtype=np.int32)
     partial_sum[0, -1] = first_value - 3
     partial_sum[1, -1] = first_value + m + 1
-    sum = partial_sum[0, :-1]
-    sum[0] = 0
-    sum[1] = 1
-    sum[2] = 2
+    sm = partial_sum[0, :-1]
+    sm[0] = 0
+    sm[1] = 1
+    sm[2] = 2
     for i in range(2, m + 2):
-        sum[i + 1] = sum[i] + values[i - 2]
-    sum[m + 3] = sum[m + 2] + 1
-    sum[m + 4] = sum[m + 3] + 1
+        sm[i + 1] = sm[i] + values[i - 2]
+    sm[m + 3] = sm[m + 2] + 1
+    sm[m + 4] = sm[m + 3] + 1
     ds = partial_sum[1, :-1]
     i = m + 3
     j = m + 4
     while i > 0:
-        while sum[i] == sum[i - 1]:
+        while sm[i] == sm[i - 1]:
             ds[i] = j
             i -= 1
         ds[j] = i

{nucs-4.2.0 → nucs-4.3.0}/nucs/propagators/no_sub_cycle_propagator.py

@@ -56,23 +56,26 @@ def compute_domains_no_sub_cycle(domains: NDArray, parameters: NDArray) -> int:
     while loop:
         loop = False
         for i in range(n):
-            if domains[i, MIN] == domains[i, MAX] and paths[i, PATH_END] == i:
+            if domains[i, MIN] == domains[i, MAX]:
                 j = domains[i, MIN]
-                end = paths[i, PATH_END] = paths[j, PATH_END]
-                start = paths[j, PATH_START] = paths[i, PATH_START]
-                paths[start, PATH_END] = end
-                paths[end, PATH_START] = start
-                length = paths[i, PATH_LENGTH] + 1 + paths[j, PATH_LENGTH]
-                paths[i, PATH_LENGTH] = paths[j, PATH_LENGTH] = paths[start, PATH_LENGTH] = paths[end, PATH_LENGTH] = (
-                    length
-                )
-                if length < n - 1:
-                    if domains[end, MIN] == start:
-                        domains[end, MIN] = start + 1
-                    if domains[end, MAX] == start:
-                        domains[end, MAX] = start - 1
-                    if domains[end, MIN] > domains[end, MAX]:
-                        return PROP_INCONSISTENCY
-                    if end < i:
-                        loop = True
+                if i == j:
+                    return PROP_INCONSISTENCY
+                if paths[i, PATH_END] == i:
+                    end = paths[i, PATH_END] = paths[j, PATH_END]
+                    start = paths[j, PATH_START] = paths[i, PATH_START]
+                    paths[start, PATH_END] = end
+                    paths[end, PATH_START] = start
+                    length = paths[i, PATH_LENGTH] + 1 + paths[j, PATH_LENGTH]
+                    paths[i, PATH_LENGTH] = paths[j, PATH_LENGTH] = paths[start, PATH_LENGTH] = paths[
+                        end, PATH_LENGTH
+                    ] = length
+                    if length < n - 1:
+                        if domains[end, MIN] == start:
+                            domains[end, MIN] = start + 1
+                        if domains[end, MAX] == start:
+                            domains[end, MAX] = start - 1
+                        if domains[end, MIN] > domains[end, MAX]:
+                            return PROP_INCONSISTENCY
+                        if end < i:
+                            loop = True
     return PROP_CONSISTENCY