NUCS 4.0.0__tar.gz → 4.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.0.0
+Version: 4.2.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.2.0}/NUCS.egg-info/SOURCES.txt

@@ -49,6 +49,8 @@ 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
@@ -62,6 +64,7 @@ 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-4.0.0/NUCS.egg-info → nucs-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 4.0.0
+Version: 4.2.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.2.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.2.0'
+version = '4.2.0'
 
 # -- General configuration
 

{nucs-4.0.0 → nucs-4.2.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.2.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.2.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.2.0}/nucs/examples/golomb/golomb_problem.py

@@ -26,7 +26,7 @@ GOLOMB_LENGTHS = np.array([0, 0, 1, 3, 6, 11, 17, 25, 34, 44, 55, 72, 85, 106, 1
 
 
 @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)

{nucs-4.0.0 → nucs-4.2.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.2.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.2.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.2.0/nucs/examples/tsp/__main__.py

@@ -0,0 +1,64 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# 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.heuristics.heuristics import DOM_HEURISTIC_MIN_COST, VAR_HEURISTIC_MAX_REGRET
+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=True)
+    args = parser.parse_args()
+    tsp_instance = TSP_INSTANCES[args.name]
+    problem = TSPProblem(tsp_instance)
+    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,
+                    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=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,
+            log_level=args.log_level,
+        )
+    )
+    solution = solver.minimize(problem.shr_domain_nb - 1, mode=args.opt_mode)
+    print(solver.get_statistics())

nucs-4.2.0/nucs/examples/tsp/mcp_dom_heuristic.py

@@ -0,0 +1,59 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import sys
+
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.constants import MAX, MIN
+from nucs.heuristics.value_dom_heuristic import value_dom_heuristic
+
+
+@njit(cache=True)
+def mcp_dom_heuristic(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_top: NDArray,
+    dom_idx: int,
+    params: NDArray,
+) -> int:
+    """
+    Chooses the value that minimizes the cost.
+    :param shr_domains_stack: the stack of shared domains
+    :param not_entailed_propagators_stack: the stack of not entailed propagators
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the index of the top of the stacks as a Numpy array
+    :param dom_idx: the index of the shared domain
+    :param params: a two-dimensional (first dimension correspond to variables, second to values) costs array
+    :return: the events
+    """
+    top = stacks_top[0]
+    n = len(params)
+    used = np.zeros(n, dtype=np.bool)
+    for i in range(n):
+        if shr_domains_stack[top, i, MIN] == shr_domains_stack[top, i, MAX]:
+            used[shr_domains_stack[top, i, MIN]] = True
+    best_cost = sys.maxsize
+    best_value = -1
+    shr_domain = shr_domains_stack[top, dom_idx]
+    for value in range(shr_domain[MIN], shr_domain[MAX] + 1):
+        if not used[value]:
+            cost = params[dom_idx][value]
+            if 0 < cost < best_cost:
+                best_cost = cost
+                best_value = value
+    return value_dom_heuristic(
+        shr_domains_stack, not_entailed_propagators_stack, dom_update_stack, stacks_top, dom_idx, best_value, params
+    )

nucs-4.2.0/nucs/examples/tsp/mrp_var_heuristic.py

@@ -0,0 +1,60 @@
+###############################################################################
+# __   _            _____    _____
+# | \ | |          / ____|  / ____|
+# |  \| |  _   _  | |      | (___
+# | . ` | | | | | | |       \___ \
+# | |\  | | |_| | | |____   ____) |
+# |_| \_|  \__,_|  \_____| |_____/
+#
+# Fast constraint solving in Python  - https://github.com/yangeorget/nucs
+#
+# Copyright 2024 - Yan Georget
+###############################################################################
+import sys
+
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.constants import MAX, MIN
+
+
+@njit(cache=True)
+def mrp_var_heuristic(
+    decision_domains: NDArray, shr_domains_stack: NDArray, stacks_top: NDArray, params: NDArray
+) -> int:
+    """
+    Chooses the variable with the maximal regret (difference between best and second-best value).
+    :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
+    """
+    top = stacks_top[0]
+    n = len(decision_domains)
+    used = np.zeros(n, dtype=np.bool)
+    for i in range(n):
+        if shr_domains_stack[top, i, MIN] == shr_domains_stack[top, i, MAX]:
+            used[shr_domains_stack[top, i, MIN]] = True
+    max_regret = 0
+    best_idx = -1
+    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:
+            best_cost = second_cost = sys.maxsize
+            for value in range(shr_domain[MIN], shr_domain[MAX] + 1):
+                if not used[value]:
+                    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:
+                best_idx = dom_idx
+                max_regret = regret
+    return best_idx

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

@@ -55,11 +55,11 @@ def compute_domains_total_cost(domains: NDArray, parameters: NDArray) -> int:
             used[domains[i, MIN]] = True
     global_min = 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]

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

@@ -38,13 +38,10 @@ class TSPProblem(CircuitProblem):
         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(
             (
                 list(range(0, n)) + [total_cost_var],
-                alg_total_cost,
+                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],
             )
         )

{nucs-4.0.0 → nucs-4.2.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.2.0}/nucs/heuristics/greatest_domain_var_heuristic.py

@@ -18,21 +18,21 @@ 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]
+    top = stacks_top[0]
     for dom_idx in decision_domains:
-        shr_domain = shr_domains_stack[cp_top_idx, dom_idx]
+        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

{nucs-4.0.0 → nucs-4.2.0}/nucs/heuristics/heuristics.py

@@ -20,6 +20,7 @@ from nucs.heuristics.mid_value_dom_heuristic import mid_value_dom_heuristic
 from nucs.heuristics.min_cost_dom_heuristic import min_cost_dom_heuristic
 from nucs.heuristics.min_value_dom_heuristic import min_value_dom_heuristic
 from nucs.heuristics.smallest_domain_var_heuristic import smallest_domain_var_heuristic
+from nucs.heuristics.split_high_dom_heuristic import split_high_dom_heuristic
 from nucs.heuristics.split_low_dom_heuristic import split_low_dom_heuristic
 
 VAR_HEURISTIC_FCTS = []
@@ -47,12 +48,13 @@ def register_dom_heuristic(dom_heuristic_fct: Callable) -> int:
 
 
 VAR_HEURISTIC_FIRST_NOT_INSTANTIATED = register_var_heuristic(first_not_instantiated_var_heuristic)
-VAR_HEURISTIC_SMALLEST_DOMAIN = register_var_heuristic(smallest_domain_var_heuristic)
 VAR_HEURISTIC_GREATEST_DOMAIN = register_var_heuristic(greatest_domain_var_heuristic)
 VAR_HEURISTIC_MAX_REGRET = register_var_heuristic(max_regret_var_heuristic)
+VAR_HEURISTIC_SMALLEST_DOMAIN = register_var_heuristic(smallest_domain_var_heuristic)
 
-DOM_HEURISTIC_MIN_VALUE = register_dom_heuristic(min_value_dom_heuristic)
 DOM_HEURISTIC_MAX_VALUE = register_dom_heuristic(max_value_dom_heuristic)
-DOM_HEURISTIC_SPLIT_LOW = register_dom_heuristic(split_low_dom_heuristic)
 DOM_HEURISTIC_MID_VALUE = register_dom_heuristic(mid_value_dom_heuristic)
 DOM_HEURISTIC_MIN_COST = register_dom_heuristic(min_cost_dom_heuristic)
+DOM_HEURISTIC_MIN_VALUE = register_dom_heuristic(min_value_dom_heuristic)
+DOM_HEURISTIC_SPLIT_HIGH = register_dom_heuristic(split_high_dom_heuristic)
+DOM_HEURISTIC_SPLIT_LOW = register_dom_heuristic(split_low_dom_heuristic)

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

@@ -20,23 +20,22 @@ from nucs.constants import MAX, MIN
 
 @njit(cache=True)
 def max_regret_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 variable with the maximal regret (difference between best and second-best value).
-    :param params: a two-dimensional (first dimension correspond to variables, second to values) costs array
     :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
     """
     max_regret = 0
     best_idx = -1
-    cp_top_idx = stacks_top[0]
+    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 0 < size:
+        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):

{nucs-4.0.0 → nucs-4.2.0}/nucs/heuristics/max_value_dom_heuristic.py

@@ -27,32 +27,32 @@ from nucs.solvers.choice_points import cp_put
 
 @njit(cache=True)
 def max_value_dom_heuristic(
-    params: NDArray,
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
     stacks_top: NDArray,
     dom_idx: int,
+    params: NDArray,
 ) -> int:
     """
     Chooses the max value of the domain.
-    :param params: a two-dimensional parameters array, unused here
     :param shr_domains_stack: the stack of shared domains
     :param not_entailed_propagators_stack: the stack of not entailed propagators
     :param dom_update_stack: the stack of domain updates
     :param stacks_top: the index of the top of the stacks as a Numpy array
     :param dom_idx: the index of the shared domain
+    :param params: a two-dimensional parameters array, unused here
     :return: the events
     """
-    cp_cur_idx = stacks_top[0]
-    value = shr_domains_stack[cp_cur_idx, dom_idx, MAX]
+    top = stacks_top[0]
+    value = shr_domains_stack[top, dom_idx, MAX]
     cp_put(shr_domains_stack, not_entailed_propagators_stack, stacks_top)
-    shr_domains_stack[cp_cur_idx + 1, dom_idx, MIN] = value
-    shr_domains_stack[cp_cur_idx, dom_idx, MAX] = value - 1
-    dom_update_stack[cp_cur_idx, DOM_UPDATE_IDX] = dom_idx
-    dom_update_stack[cp_cur_idx, DOM_UPDATE_EVENTS] = (
+    shr_domains_stack[top + 1, dom_idx, MIN] = value
+    shr_domains_stack[top, dom_idx, MAX] = value - 1
+    dom_update_stack[top, DOM_UPDATE_IDX] = dom_idx
+    dom_update_stack[top, DOM_UPDATE_EVENTS] = (
         EVENT_MASK_MAX_GROUND
-        if shr_domains_stack[cp_cur_idx, dom_idx, MIN] == shr_domains_stack[cp_cur_idx, dom_idx, MAX]
+        if shr_domains_stack[top, dom_idx, MIN] == shr_domains_stack[top, dom_idx, MAX]
         else EVENT_MASK_MAX
     )
     return EVENT_MASK_MIN_GROUND