NUCS 0.1__py3-none-any.whl

nucs/propagators/propagators.py

@@ -0,0 +1,135 @@
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import END, MAX, MIN, START
+from nucs.propagators import (
+    affine_eq_propagator,
+    affine_geq_propagator,
+    affine_leq_propagator,
+    alldifferent_propagator,
+    count_eq_propagator,
+    dummy_propagator,
+    exactly_eq_propagator,
+    lexicographic_leq_propagator,
+    max_eq_propagator,
+    max_leq_propagator,
+    min_eq_propagator,
+    min_geq_propagator,
+)
+
+# The ordinals of the algorithms for all propagators (sorted by alphabetical ordering).
+ALG_AFFINE_EQ = 0
+ALG_AFFINE_GEQ = 1
+ALG_AFFINE_LEQ = 2
+ALG_ALLDIFFERENT = 3
+ALG_COUNT_EQ = 4
+ALG_DUMMY = 5
+ALG_EXACTLY_EQ = 6
+ALG_LEXICOGRAPHIC_LEQ = 7
+ALG_MAX_EQ = 8
+ALG_MAX_LEQ = 9
+ALG_MIN_EQ = 10
+ALG_MIN_GEQ = 11
+
+PROPAGATOR_MODULES = [
+    affine_eq_propagator,
+    affine_geq_propagator,
+    affine_leq_propagator,
+    alldifferent_propagator,
+    count_eq_propagator,
+    dummy_propagator,
+    exactly_eq_propagator,
+    lexicographic_leq_propagator,
+    max_eq_propagator,
+    max_leq_propagator,
+    min_eq_propagator,
+    min_geq_propagator,
+]
+
+
+def get_triggers(algorithm: int, size: int, data: NDArray) -> NDArray:
+    """
+    Returns the triggers for a propagator.
+    :param algorithm: the ordinal of the algorithm
+    :param size: the number of variables
+    :return: an array of triggers
+    """
+    return PROPAGATOR_MODULES[algorithm].get_triggers(size, data)
+
+
+@njit("int64(uint8, int32[::1,:], int32[:])", cache=True)
+def compute_domains(algorithm: int, domains: NDArray, data: NDArray) -> int:
+    """
+    Computes the new domains for the variables.
+    :param algorithm: the ordinal of the algorithm
+    :param domains: the initial domains of the variables
+    :param data: the parameters of the propagator
+    :return: a status as an integer (INCONSISTENCY, CONSISTENCY, ENTAILMENT)
+    """
+    if algorithm == ALG_AFFINE_EQ:
+        return affine_eq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_AFFINE_GEQ:
+        return affine_geq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_AFFINE_LEQ:
+        return affine_leq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_ALLDIFFERENT:
+        return alldifferent_propagator.compute_domains(domains, data)
+    if algorithm == ALG_COUNT_EQ:
+        return count_eq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_DUMMY:
+        return dummy_propagator.compute_domains(domains, data)
+    if algorithm == ALG_EXACTLY_EQ:
+        return exactly_eq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_LEXICOGRAPHIC_LEQ:
+        return lexicographic_leq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_MAX_EQ:
+        return max_eq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_MAX_LEQ:
+        return max_leq_propagator.compute_domains(domains, data)
+    if algorithm == ALG_MIN_EQ:
+        return min_eq_propagator.compute_domains(domains, data)
+    return min_geq_propagator.compute_domains(domains, data)
+
+
+@njit(cache=True)
+def init_triggered_propagators(
+    triggered_propagators: NDArray,
+    entailed_propagators: NDArray,
+    shr_domain_changes: NDArray,
+    propagator_nb: int,
+    prop_var_bounds: NDArray,
+    prop_dom_indices: NDArray,
+    prop_triggers: NDArray,
+) -> None:
+    triggered_propagators.fill(False)
+    for prop_idx in range(propagator_nb):
+        if not entailed_propagators[prop_idx]:
+            for var_idx in range(prop_var_bounds[prop_idx, START], prop_var_bounds[prop_idx, END]):
+                dom_idx = prop_dom_indices[var_idx]
+                if (shr_domain_changes[dom_idx, MIN] and prop_triggers[var_idx, MIN]) or (
+                    shr_domain_changes[dom_idx, MAX] and prop_triggers[var_idx, MAX]
+                ):
+                    triggered_propagators[prop_idx] = True
+                    break
+
+
+@njit(cache=True)
+def update_triggered_propagators(
+    triggered_propagators: NDArray,
+    entailed_propagators: NDArray,
+    shr_domain_changes: NDArray,
+    propagator_nb: int,
+    prop_var_bounds: NDArray,
+    prop_dom_indices: NDArray,
+    prop_triggers: NDArray,
+    previous_prop_idx: int,
+) -> None:
+    for prop_idx in range(propagator_nb):
+        if not entailed_propagators[prop_idx] and prop_idx != previous_prop_idx and not triggered_propagators[prop_idx]:
+            for var_idx in range(prop_var_bounds[prop_idx, START], prop_var_bounds[prop_idx, END]):
+                dom_idx = prop_dom_indices[var_idx]
+                if (shr_domain_changes[dom_idx, MIN] and prop_triggers[var_idx, MIN]) or (
+                    shr_domain_changes[dom_idx, MAX] and prop_triggers[var_idx, MAX]
+                ):
+                    triggered_propagators[prop_idx] = True
+                    break

nucs/solvers/backtrack_solver.py

@@ -0,0 +1,105 @@
+from typing import Iterator, List, Optional
+
+from nucs.heuristics.heuristic import Heuristic
+from nucs.heuristics.variable_heuristic import (
+    VariableHeuristic,
+    first_not_instantiated_var_heuristic,
+    min_value_dom_heuristic,
+)
+from nucs.memory import new_domain_changes
+from nucs.problems.problem import Problem, is_solved
+from nucs.solvers.solver import Solver
+from nucs.statistics import (
+    STATS_OPTIMIZER_SOLUTION_NB,
+    STATS_SOLVER_BACKTRACK_NB,
+    STATS_SOLVER_CHOICE_DEPTH,
+    STATS_SOLVER_CHOICE_NB,
+    STATS_SOLVER_SOLUTION_NB,
+)
+
+
+class BacktrackSolver(Solver):
+    """
+    A solver relying on a backtracking mechanism.
+    """
+
+    def __init__(
+        self,
+        problem: Problem,
+        heuristic: Heuristic = VariableHeuristic(first_not_instantiated_var_heuristic, min_value_dom_heuristic),
+    ):
+        super().__init__(problem)
+        self.choice_points = []  # type: ignore
+        self.shr_domain_changes = new_domain_changes(len(self.problem.shr_domains))
+        self.heuristic = heuristic
+
+    def solve(self) -> Iterator[List[int]]:
+        while True:
+            solution = self.solve_one()
+            if solution is None:
+                break
+            yield solution
+            if not self.backtrack():
+                break
+
+    def solve_one(self) -> Optional[List[int]]:
+        """
+        Find at most one solution.
+        :return: the solution if it exists or None
+        """
+        while self.filter():
+            if is_solved(self.problem.shr_domains):
+                self.problem.statistics[STATS_SOLVER_SOLUTION_NB] += 1
+                return self.problem.get_values()  # problem is solved
+            self.heuristic.choose(
+                self.choice_points,
+                self.problem.shr_domains,
+                self.shr_domain_changes,
+                self.problem.dom_indices,
+            )
+            self.problem.statistics[STATS_SOLVER_CHOICE_NB] += 1
+            self.problem.statistics[STATS_SOLVER_CHOICE_DEPTH] = max(
+                self.problem.statistics[STATS_SOLVER_CHOICE_DEPTH], len(self.choice_points)
+            )
+        return None
+
+    def minimize(self, variable_idx: int) -> Optional[List[int]]:
+        solution = None
+        while (new_solution := self.solve_one()) is not None:
+            solution = new_solution
+            self.problem.statistics[STATS_OPTIMIZER_SOLUTION_NB] += 1
+            self.reset()
+            self.problem.set_max_value(variable_idx, solution[variable_idx] - 1)
+        return solution
+
+    def backtrack(self) -> bool:
+        """
+        Backtracks and updates the problem's domains
+        :return: true iff it is possible to backtrack
+        """
+        if len(self.choice_points) == 0:
+            return False
+        self.problem.statistics[STATS_SOLVER_BACKTRACK_NB] += 1
+        self.shr_domain_changes[:, :] = True
+        self.problem.shr_domains = self.choice_points.pop()
+        self.problem.reset_entailed_propagators()
+        return True
+
+    def filter(self) -> bool:
+        """
+        Achieves bound consistency and backtracks if necessary.
+        :return: true iff bound consistency has been achieved
+        """
+        while not self.problem.filter(self.shr_domain_changes):
+            if not self.backtrack():
+                return False
+        return True
+
+    def reset(self) -> None:
+        """
+        Resets the solver by resetting the problem and the choice points.
+        """
+        self.choice_points.clear()
+        self.shr_domain_changes[:, :] = True
+        self.problem.reset_shr_domains()
+        self.problem.reset_entailed_propagators()

nucs/solvers/solver.py

@@ -0,0 +1,41 @@
+from typing import Iterator, List, Optional
+
+from nucs.problems.problem import Problem
+
+
+class Solver:
+    """
+    A solver.
+    """
+
+    def __init__(self, problem: Problem):
+        self.problem = problem
+
+    def solve(self) -> Iterator[List[int]]:  # type: ignore
+        """
+        Returns an iterator over the solutions.
+        :return: an iterator
+        """
+        pass
+
+    def solve_all(self) -> List[List[int]]:
+        """
+        Returns the list of all solutions.
+        :return: a list of list of integers
+        """
+        return [s for s in self.solve()]
+
+    def find_all(self) -> None:
+        """
+        Find all solutions.
+        """
+        for _ in self.solve():
+            pass
+
+    def minimize(self, var_idx: int) -> Optional[List[int]]:  # type: ignore
+        """
+        Finds, if it exists, the solution to the problem that minimizes a given variable.
+        :param variable_idx: the index of the variable
+        :return: the solution if it exists or None
+        """
+        pass

nucs/statistics.py

@@ -0,0 +1,44 @@
+import numpy as np
+from numpy.typing import NDArray
+
+
+def statistics_init() -> NDArray:
+    """
+    Inits a Numpy array for storing the statistics.
+    :return: a Numpy array
+    """
+    return np.array([0] * STATS_MAX, dtype=np.int32, order="C")
+
+
+def statistics_print(stats: NDArray) -> None:
+    """
+    Pretty-prints an array of statistics.
+    :param stats: a Numpy array of statistics
+    """
+    print(
+        {
+            "OPTIMIZER_SOLUTION_NB": int(stats[STATS_OPTIMIZER_SOLUTION_NB]),
+            "PROBLEM_FILTERS_NB": int(stats[STATS_PROBLEM_FILTER_NB]),
+            "PROPAGATOR_ENTAILMENT_NB": int(stats[STATS_PROPAGATOR_ENTAILMENT_NB]),
+            "PROPAGATOR_FILTERS_NB": int(stats[STATS_PROPAGATOR_FILTER_NB]),
+            "PROPAGATOR_FILTERS_NO_CHANGE_NB": int(stats[STATS_PROPAGATOR_FILTER_NO_CHANGE_NB]),
+            "PROPAGATOR_INCONSISTENCY_NB": int(stats[STATS_PROPAGATOR_INCONSISTENCY_NB]),
+            "SOLVER_BACKTRACK_NB": int(stats[STATS_SOLVER_BACKTRACK_NB]),
+            "SOLVER_CHOICE_NB": int(stats[STATS_SOLVER_CHOICE_NB]),
+            "SOLVER_CHOICE_DEPTH": int(stats[STATS_SOLVER_CHOICE_DEPTH]),
+            "SOLVER_SOLUTION_NB": int(stats[STATS_SOLVER_SOLUTION_NB]),
+        }
+    )
+
+
+STATS_MAX = 10
+STATS_OPTIMIZER_SOLUTION_NB = 0
+STATS_PROBLEM_FILTER_NB = 1
+STATS_PROPAGATOR_ENTAILMENT_NB = 2
+STATS_PROPAGATOR_FILTER_NB = 3
+STATS_PROPAGATOR_FILTER_NO_CHANGE_NB = 4
+STATS_PROPAGATOR_INCONSISTENCY_NB = 5
+STATS_SOLVER_BACKTRACK_NB = 6
+STATS_SOLVER_CHOICE_NB = 7
+STATS_SOLVER_CHOICE_DEPTH = 8
+STATS_SOLVER_SOLUTION_NB = 9