NUCS 4.0.0__tar.gz → 4.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.0.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.0.0 → nucs-4.3.0}/NUCS.egg-info/SOURCES.txt

@@ -52,6 +52,7 @@ nucs/examples/tsp/__main__.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
@@ -62,11 +63,13 @@ nucs/heuristics/mid_value_dom_heuristic.py
 nucs/heuristics/min_cost_dom_heuristic.py
 nucs/heuristics/min_value_dom_heuristic.py
 nucs/heuristics/smallest_domain_var_heuristic.py
+nucs/heuristics/split_high_dom_heuristic.py
 nucs/heuristics/split_low_dom_heuristic.py
 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
@@ -88,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
@@ -120,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.0.0/NUCS.egg-info → nucs-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.0.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.0.0 → nucs-4.3.0}/docs/source/conf.py

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

{nucs-4.0.0 → nucs-4.3.0}/nucs/constants.py

@@ -14,6 +14,10 @@ import os
 
 from numba import bool, int32, int64, types, uint8, uint16  # type: ignore
 
+OPT_RESET = "RESET"
+OPT_PRUNE = "PRUNE"
+OPT_MODES = [OPT_RESET, OPT_PRUNE]
+
 RG_START = 0  # index corresponding the start of a values range
 RG_END = 1  # index corresponding the end of a values range
 
@@ -61,18 +65,18 @@ SIGNATURE_CONSISTENCY_ALG = int64(
     uint16[:],  # decision_domains
 )
 SIGNATURE_DOM_HEURISTIC = int64(
-    int64[:, :],  # dom_heuristic_params
     int32[:, :, :],  # shr_domains_stack
     bool[:, :],  # not_entailed_propagators_stack
     uint16[:, :],  # dom_update_stack
     uint8[:],  # stacks_top
     int64,  # dom_idx
+    int64[:, :],  # dom_heuristic_params
 )
 SIGNATURE_VAR_HEURISTIC = int64(
-    int64[:, :],  # var_heuristic_params
     uint16[:],  # decision_variables
     int32[:, :, :],  # shr_domains_stack
     uint8[:],  # stacks_top
+    int64[:, :],  # var_heuristic_params
 )
 
 

{nucs-4.0.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.0.0 → nucs-4.3.0}/nucs/examples/bibd/__main__.py

@@ -28,10 +28,12 @@ if __name__ == "__main__":
     parser.add_argument("-r", type=int)
     parser.add_argument("-k", type=int)
     parser.add_argument("-l", type=int)
-    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = BIBDProblem(args.v, args.b, args.r, args.k, args.l, args.symmetry_breaking)
-    solver = BacktrackSolver(problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level)
+    solver = BacktrackSolver(
+        problem, dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE, log_level=args.log_level, stack_max_height=128
+    )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-4.0.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.0.0 → nucs-4.3.0}/nucs/examples/golomb/__main__.py

@@ -14,23 +14,39 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_PRUNE
 from nucs.examples.golomb.golomb_problem import GolombProblem, golomb_consistency_algorithm
 from nucs.solvers.backtrack_solver import BacktrackSolver
 from nucs.solvers.consistency_algorithms import register_consistency_algorithm
+from nucs.solvers.multiprocessing_solver import MultiprocessingSolver
 
 # 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.golomb -n 10 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", type=int, default=10)
-    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("--opt_mode", choices=OPT_MODES, default=OPT_PRUNE)
+    parser.add_argument("--processors", type=int, default=1)
+    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = GolombProblem(args.n, args.symmetry_breaking)
     consistency_alg_golomb = register_consistency_algorithm(golomb_consistency_algorithm)
-    solver = BacktrackSolver(problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level)
-    solution = solver.minimize(problem.length_idx)
+    solver = (
+        MultiprocessingSolver(
+            [
+                BacktrackSolver(
+                    prob, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stack_max_height=128
+                )
+                for prob in problem.split(args.processors, 0)
+            ]
+        )
+        if args.processors > 1
+        else BacktrackSolver(
+            problem, consistency_alg_idx=consistency_alg_golomb, log_level=args.log_level, stack_max_height=128
+        )
+    )
+    solution = solver.minimize(problem.length_idx, mode=args.opt_mode)
     print(solver.get_statistics())
     if solution is not None:
         print(solution[: (args.n - 1)])

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

@@ -19,14 +19,14 @@ 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])
 
 
 @njit(cache=True)
-def sum_first(n: np.uint32) -> np.uint32:
+def sum_first(n: int) -> int:
     """
     Returns the sum of the first n integers.
     :param n: an integer
@@ -36,7 +36,7 @@ def sum_first(n: np.uint32) -> np.uint32:
 
 
 @njit(cache=True)
-def index(mark_nb: np.uint32, i: np.uint32, j: np.uint32) -> np.uint32:
+def index(mark_nb: int, i: int, j: int) -> int:
     """
     Returns the index of the distance variable between two marks.
     :param mark_nb: the total number of marks
@@ -47,22 +47,6 @@ def index(mark_nb: np.uint32, i: np.uint32, j: np.uint32) -> np.uint32:
     return i * mark_nb - sum_first(i) + j - i - 1
 
 
-@njit(cache=True)
-def init_domains(dist_nb: int, mark_nb: int) -> NDArray:
-    """
-    Returns the domains.
-    :param dist_nb: the number of distances
-    :param mark_nb: the number of marks
-    :return: a Numpy array of domains
-    """
-    domains = np.empty((dist_nb, 2), dtype=np.int32)
-    for i in range(0, mark_nb - 1):
-        for j in range(i + 1, mark_nb):
-            domains[index(mark_nb, i, j), MIN] = GOLOMB_LENGTHS[j - i + 1] if j - i + 1 < mark_nb else sum_first(j - i)
-    domains[:, MAX] = sum_first(dist_nb)
-    return domains
-
-
 class GolombProblem(Problem):
     """
     This is the famous Golomb ruler problem.
@@ -77,7 +61,15 @@ class GolombProblem(Problem):
     """
 
     def __init__(self, mark_nb: int, symmetry_breaking: bool = True) -> None:
-        super().__init__(init_domains(sum_first(mark_nb - 1), mark_nb))
+        dist_nb = sum_first(mark_nb - 1)
+        domains = np.empty((dist_nb, 2), dtype=np.int32)
+        for i in range(0, mark_nb - 1):
+            for j in range(i + 1, mark_nb):
+                domains[index(mark_nb, i, j), MIN] = (
+                    GOLOMB_LENGTHS[j - i + 1] if j - i + 1 < mark_nb else sum_first(j - i)
+                )
+        domains[:, MAX] = sum_first(dist_nb) - sum_first(dist_nb - mark_nb)
+        super().__init__(domains)
         self.length_idx = index(mark_nb, 0, mark_nb - 1)  # we want to minimize this
         # dist_ij = mark_j - mark_i for j > i
         # mark_j = dist_0j for j > 0
@@ -142,7 +134,7 @@ def golomb_consistency_algorithm(
     # first prune the search space
     mark_nb = (1 + int(math.sqrt(8 * len(dom_indices_arr) + 1))) // 2
     ni_var_idx = first_not_instantiated_var_heuristic(
-        None, decision_domains, shr_domains_stack, stacks_top
+        decision_domains, shr_domains_stack, stacks_top, None
     )  # no domains shared between vars
     if 1 < ni_var_idx < mark_nb - 1:  # otherwise useless
         used_distance = np.zeros(sum_first(mark_nb - 2) + 1, dtype=np.bool)
@@ -169,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.0.0 → nucs-4.3.0}/nucs/examples/knapsack/__main__.py

@@ -14,7 +14,7 @@ import argparse
 
 from rich import print
 
-from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS
+from nucs.constants import LOG_LEVEL_INFO, LOG_LEVELS, OPT_MODES, OPT_RESET
 from nucs.examples.knapsack.knapsack_problem import KnapsackProblem
 from nucs.heuristics.heuristics import DOM_HEURISTIC_MAX_VALUE, VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
 from nucs.solvers.backtrack_solver import BacktrackSolver
@@ -24,6 +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("--opt_mode", choices=OPT_MODES, default=OPT_RESET)
     args = parser.parse_args()
     problem = KnapsackProblem(
         [40, 40, 38, 38, 36, 36, 34, 34, 32, 32, 30, 30, 28, 28, 26, 26, 24, 24, 22, 22],
@@ -36,6 +37,6 @@ if __name__ == "__main__":
         dom_heuristic_idx=DOM_HEURISTIC_MAX_VALUE,
         log_level=args.log_level,
     )
-    solution = solver.maximize(problem.weight)
+    solution = solver.maximize(problem.weight, mode=args.opt_mode)
     print(solver.get_statistics())
     print(solution)

{nucs-4.0.0 → nucs-4.3.0}/nucs/examples/magic_sequence/__main__.py

@@ -23,8 +23,8 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_sequence -n 100
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=100)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=100)
     args = parser.parse_args()
     problem = MagicSequenceProblem(args.n)
     solver = BacktrackSolver(
@@ -33,6 +33,7 @@ if __name__ == "__main__":
         var_heuristic_idx=VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
         dom_heuristic_idx=DOM_HEURISTIC_MIN_VALUE,
         log_level=args.log_level,
+        stack_max_height=128,
     )
     solver.solve_all()
     print(solver.get_statistics())

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

@@ -23,9 +23,9 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.magic_square -n 4 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int)
-    parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    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)
     solver = BacktrackSolver(

{nucs-4.0.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.0.0 → nucs-4.3.0}/nucs/examples/schur_lemma/__main__.py

@@ -22,11 +22,11 @@ from nucs.solvers.backtrack_solver import BacktrackSolver
 # NUMBA_CACHE_DIR=.numba/cache python -m nucs.examples.schur_lemma -n 20 --symmetry_breaking
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
-    parser.add_argument("-n", type=int, default=20)
     parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    parser.add_argument("-n", type=int, default=20)
     parser.add_argument("--symmetry_breaking", action=argparse.BooleanOptionalAction, default=True)
     args = parser.parse_args()
     problem = SchurLemmaProblem(args.n, args.symmetry_breaking)
-    solver = BacktrackSolver(problem, log_level=args.log_level)
+    solver = BacktrackSolver(problem, log_level=args.log_level, stack_max_height=128)
     solver.solve_all()
     print(solver.get_statistics())

{nucs-4.0.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.3.0/nucs/examples/tsp/__main__.py

@@ -0,0 +1,69 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+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.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
+
+# 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.alpha
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--log_level", choices=LOG_LEVELS, default=LOG_LEVEL_INFO)
+    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=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=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)
+            ]
+        )
+        if args.processors > 1
+        else BacktrackSolver(
+            problem,
+            consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+            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.total_cost, mode=args.opt_mode)
+    print(solver.get_statistics())

{nucs-4.0.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,13 +53,24 @@ 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):
-        local_min = sys.maxsize
-        local_max = 0
         if domains[i, MIN] == domains[i, MAX]:
             local_min = local_max = parameters[i * n + domains[i, MIN]]
         else:
+            local_min = sys.maxsize
+            local_max = 0
             for value in range(domains[i, MIN], domains[i, MAX] + 1):
                 if not used[value]:
                     cost = parameters[i * n + value]
@@ -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.0.0 → nucs-4.3.0}/nucs/examples/tsp/tsp_problem.py

@@ -33,18 +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]))
-        alg_total_cost = register_propagator(
-            get_triggers_total_cost, get_complexity_total_cost, compute_domains_total_cost
+            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(self.next_costs, self.next_costs + n)) + [self.total_cost], ALG_AFFINE_EQ, [1] * n + [-1, 0])
         )
         self.add_propagator(
-            (
-                list(range(0, n)) + [total_cost_var],
-                alg_total_cost,
-                [cost for cost_row in cost_rows for cost in cost_row],
-            )
+            (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.0.0 → nucs-4.3.0}/nucs/heuristics/first_not_instantiated_var_heuristic.py

@@ -18,18 +18,18 @@ from nucs.constants import MAX, MIN
 
 @njit(cache=True)
 def first_not_instantiated_var_heuristic(
-    params: NDArray, decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray
+    decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray, params: NDArray
 ) -> int:
     """
     Chooses the first non-instantiated shared domain.
-    :param params: a two-dimensional parameters array, unused here
     :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 parameters array, unused here
     :return: the index of the shared domain
     """
-    cp_top_idx = stacks_top[0]
+    top = stacks_top[0]
     for dom_idx in decision_domains:
-        if shr_domains_stack[cp_top_idx, dom_idx, MIN] < shr_domains_stack[cp_top_idx, dom_idx, MAX]:
+        if shr_domains_stack[top, dom_idx, MIN] < shr_domains_stack[top, dom_idx, MAX]:
             return dom_idx
     return -1  # cannot happen

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

@@ -18,23 +18,23 @@ from nucs.constants import MAX, MIN
 
 @njit(cache=True)
 def greatest_domain_var_heuristic(
-    params: NDArray, decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray
+    decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray, params: NDArray
 ) -> int:
     """
     Chooses the greatest shared domain and which is not instantiated.
-    :param params: a two-dimensional parameters array, unused here
     :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 parameters array, unused here
     :return: the index of the shared domain
     """
-    max_size = 0
-    max_idx = -1
-    cp_top_idx = stacks_top[0]
+    best_score = 0
+    best_idx = -1
+    top = stacks_top[0]
     for dom_idx in decision_domains:
-        shr_domain = shr_domains_stack[cp_top_idx, 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
+        shr_domain = shr_domains_stack[top, dom_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