NUCS 0.1__py3-none-any.whl

nucs/propagators/alldifferent_propagator.py

@@ -0,0 +1,180 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("(uint16[:], uint16, uint16, uint16)", cache=True)
+def path_set(t: NDArray, start: int, end: int, to: int) -> None:
+    while (p := start) != end:
+        start = t[p]
+        t[p] = to
+
+
+@njit("uint16(uint16[:], uint16)", cache=True)
+def path_min(t: NDArray, i: int) -> int:
+    while t[i] < i:
+        i = t[i]
+    return i
+
+
+@njit("uint16(uint16[:], uint16)", cache=True)
+def path_max(t: NDArray, i: int) -> int:
+    while t[i] > i:
+        i = t[i]
+    return i
+
+
+@njit("uint16(int64, int32[::1, :], uint16[:, :], int64[:], int64[:], int32[:])", cache=True)
+def compute_nb(
+    n: int,
+    domains: NDArray,
+    ranks: NDArray,
+    min_sorted_vars: NDArray,
+    max_sorted_vars: NDArray,
+    bounds: NDArray,
+) -> int:
+    min_value = domains[min_sorted_vars[0], MIN]
+    max_value = domains[max_sorted_vars[0], MAX] + 1
+    last = min_value - 2
+    bounds[0] = last
+    i = j = nb = 0
+    while True:
+        if i < n and min_value <= max_value:
+            if min_value != last:
+                nb += 1
+                bounds[nb] = last = min_value
+            ranks[min_sorted_vars[i], MIN] = nb
+            i += 1
+            if i < n:
+                min_value = domains[min_sorted_vars[i], MIN]
+        else:
+            if max_value != last:
+                nb += 1
+                bounds[nb] = last = max_value
+            ranks[max_sorted_vars[j], MAX] = nb
+            j += 1
+            if j == n:
+                break
+            max_value = domains[max_sorted_vars[j], MAX] + 1
+    bounds[nb + 1] = bounds[nb] + 2
+    return nb
+
+
+@njit(
+    "boolean(int64, int64, uint16[:], int32[:], uint16[:], int32[:], int32[::1, :], uint16[:, :], int64[:])",
+    cache=True,
+)
+def filter_lower(
+    n: int,
+    nb: int,
+    t: NDArray,
+    d: NDArray,
+    h: NDArray,
+    bounds: NDArray,
+    domains: NDArray,
+    ranks: NDArray,
+    max_sorted_vars: NDArray,
+) -> bool:
+    for i in range(1, nb + 2):
+        t[i] = h[i] = i - 1
+        d[i] = bounds[i] - bounds[i - 1]
+    for i in range(n):
+        max_sorted_vars_i = max_sorted_vars[i]
+        x = ranks[max_sorted_vars_i, MIN]
+        y = ranks[max_sorted_vars_i, MAX]
+        z = path_max(t, x + 1)
+        j = t[z]
+        d[z] -= 1
+        if d[z] == 0:
+            t[z] = z + 1
+            z = path_max(t, t[z])
+            t[z] = j
+        if d[z] + bounds[y] < bounds[z]:  # moved above the path compression which is not the case in the paper
+            return False
+        path_set(t, x + 1, z, z)  # path compression
+        if h[x] > x:
+            w = path_max(h, h[x])
+            domains[max_sorted_vars_i, MIN] = bounds[w]
+            path_set(h, x, w, w)  # path compression
+        if d[z] + bounds[y] == bounds[z]:
+            path_set(h, h[y], j - 1, y)  # mark hall interval
+            h[y] = j - 1  # hall interval[bounds[j], bounds[y]]
+    return True
+
+
+@njit(
+    "boolean(int64, int64, uint16[:], int32[:], uint16[:], int32[:], int32[::1, :], uint16[:, :], int64[:])",
+    cache=True,
+)
+def filter_upper(
+    n: int,
+    nb: int,
+    t: NDArray,
+    d: NDArray,
+    h: NDArray,
+    bounds: NDArray,
+    domains: NDArray,
+    ranks: NDArray,
+    min_sorted_vars: NDArray,
+) -> bool:
+    for i in range(nb + 1):
+        t[i] = h[i] = i + 1
+        d[i] = bounds[i + 1] - bounds[i]
+    for i in range(n - 1, -1, -1):
+        min_sorted_vars_i = min_sorted_vars[i]
+        x = ranks[min_sorted_vars_i, MAX]
+        y = ranks[min_sorted_vars_i, MIN]
+        z = path_min(t, x - 1)
+        j = t[z]
+        d[z] -= 1
+        if d[z] == 0:
+            t[z] = z - 1
+            z = path_min(t, t[z])
+            t[z] = j
+        if d[z] + bounds[z] < bounds[y]:  # moved above the path compression which is not the case in the paper
+            return False
+        path_set(t, x - 1, z, z)  # path compression
+        if h[x] < x:
+            w = path_min(h, h[x])
+            domains[min_sorted_vars_i, MAX] = bounds[w] - 1
+            path_set(h, x, w, w)  # path compression
+        if d[z] + bounds[z] == bounds[y]:
+            path_set(h, h[y], j + 1, y)  # mark hall interval
+            h[y] = j + 1  # hall interval[bounds[j], bounds[y]]
+    return True
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Adapted from "A fast and simple algorithm for bounds consistency of the alldifferent constraint".
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    n = len(domains)
+    ranks = np.zeros((n, 2), dtype=np.uint16)
+    bounds_nb = 2 * n + 2
+    bounds = np.zeros(bounds_nb, dtype=np.int32)
+    min_sorted_vars = np.argsort(domains[:, MIN])
+    max_sorted_vars = np.argsort(domains[:, MAX])
+    nb = compute_nb(n, domains, ranks, min_sorted_vars, max_sorted_vars, bounds)
+    t = np.zeros(bounds_nb, dtype=np.uint16)  # critical capacity pointers
+    d = np.zeros(bounds_nb, dtype=np.int32)  # differences between critical capacities
+    h = np.zeros(bounds_nb, dtype=np.uint16)  # Hall interval pointers
+    return (
+        PROP_CONSISTENCY
+        if filter_lower(n, nb, t, d, h, bounds, domains, ranks, max_sorted_vars)
+        and filter_upper(n, nb, t, d, h, bounds, domains, ranks, min_sorted_vars)
+        else PROP_INCONSISTENCY
+    )

nucs/propagators/count_eq_propagator.py

@@ -0,0 +1,47 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import (
+    MAX,
+    MIN,
+    PROP_CONSISTENCY,
+    PROP_ENTAILMENT,
+    PROP_INCONSISTENCY,
+    new_triggers,
+)
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements Sigma_i (x_i == a) = x_{n-1}.
+    :param domains: the domains of the variables
+    :param data: the parameters of the propagator
+    """
+    x = domains[:-1]
+    value = data[0]
+    ok_count_max = len(x) - np.count_nonzero((x[:, MIN] > value) | (x[:, MAX] < value))
+    ok_count_min = np.count_nonzero((x[:, MIN] == value) & (x[:, MAX] == value))
+    counter = domains[-1]
+    counter[MIN] = max(counter[MIN], ok_count_min)
+    counter[MAX] = min(counter[MAX], ok_count_max)
+    if counter[MIN] > counter[MAX]:
+        return PROP_INCONSISTENCY
+    if ok_count_min == ok_count_max:
+        return PROP_ENTAILMENT
+    if ok_count_min == counter[MAX]:  # we cannot have more domains equal to c
+        x[(x[:, MIN] == value) & (x[:, MAX] > value), MIN] = value + 1
+        x[(x[:, MIN] < value) & (x[:, MAX] == value), MAX] = value - 1
+    if ok_count_max == counter[MIN]:  # we cannot have more domains different from c
+        x[(x[:, MIN] <= value) & (value <= x[:, MAX]), :] = value
+    return PROP_CONSISTENCY

nucs/propagators/dummy_propagator.py

@@ -0,0 +1,21 @@
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import PROP_CONSISTENCY, new_triggers
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    A propagator that does nothing.
+    """
+    return PROP_CONSISTENCY

nucs/propagators/exactly_eq_propagator.py

@@ -0,0 +1,44 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import (
+    MAX,
+    MIN,
+    PROP_CONSISTENCY,
+    PROP_ENTAILMENT,
+    PROP_INCONSISTENCY,
+    new_triggers,
+)
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(x: NDArray, data: NDArray) -> int:
+    """
+    Implements Sigma_i (x_i == a_0) = a_1.
+    :param domains: the domains of the variables
+    :param data: the parameters of the propagator
+    """
+    value = data[0]
+    ok_count_max = len(x) - np.count_nonzero((x[:, MIN] > value) | (x[:, MAX] < value))
+    ok_count_min = np.count_nonzero((x[:, MIN] == value) & (x[:, MAX] == value))
+    counter = data[1]
+    if ok_count_min > counter or ok_count_max < counter:
+        return PROP_INCONSISTENCY
+    if ok_count_min == counter and ok_count_max == counter:
+        return PROP_ENTAILMENT
+    if ok_count_min == counter:  # we cannot have more domains equal to c
+        x[(x[:, MIN] == value) & (x[:, MAX] > value), MIN] = value + 1
+        x[(x[:, MIN] < value) & (x[:, MAX] == value), MAX] = value - 1
+    if ok_count_max == counter:  # we cannot have more domains different from c
+        x[(x[:, MIN] <= value) & (value <= x[:, MAX]), :] = value
+    return PROP_CONSISTENCY

nucs/propagators/lexicographic_leq_propagator.py

@@ -0,0 +1,139 @@
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import (
+    MAX,
+    MIN,
+    PROP_CONSISTENCY,
+    PROP_ENTAILMENT,
+    PROP_INCONSISTENCY,
+    new_triggers,
+)
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    This propagator is triggered whenever there is a change in the domain of a variable.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    return new_triggers(n, True)
+
+
+@njit("int64(int32[:,:], int32[:,:], int64, int64, int64, int64, int64)", cache=True)
+def compute_domains_4(x: NDArray, y: NDArray, n: int, i: int, q: int, r: int, s: int) -> int:
+    while i < n and x[i, MIN] == y[i, MAX]:
+        i += 1
+        # s = i
+    if i < n and x[i, MIN] > y[i, MAX]:
+        # xq < yq
+        x[q, MAX] = min(x[q, MAX], y[q, MAX] - 1)
+        if x[q, MAX] < x[q, MIN]:
+            return PROP_INCONSISTENCY
+        y[q, MIN] = max(y[q, MIN], x[q, MIN] + 1)
+        if y[q, MAX] < y[q, MIN]:
+            return PROP_INCONSISTENCY
+        return PROP_ENTAILMENT if x[q, MAX] < y[q, MIN] else PROP_CONSISTENCY
+    # u = 4
+    return PROP_CONSISTENCY
+
+
+@njit("int64(int32[:,:], int32[:,:], int64, int64, int64, int64, int64)", cache=True)
+def compute_domains_3(x: NDArray, y: NDArray, n: int, i: int, q: int, r: int, s: int) -> int:
+    while i < n and x[i, MAX] == y[i, MIN]:
+        i += 1
+        # s = i
+    if i == n or x[i, MAX] < y[i, MIN]:
+        # xq <= yq
+        x[q, MAX] = min(x[q, MAX], y[q, MAX])
+        if x[q, MAX] < x[q, MIN]:
+            return PROP_INCONSISTENCY
+        y[q, MIN] = max(y[q, MIN], x[q, MIN])
+        if y[q, MAX] < y[q, MIN]:
+            return PROP_INCONSISTENCY
+        return PROP_ENTAILMENT if x[q, MAX] <= y[q, MIN] else PROP_CONSISTENCY
+    # u = 3
+    return PROP_CONSISTENCY
+
+
+@njit("int64(int32[:,:], int32[:,:], int64, int64, int64, int64, int64)", cache=True)
+def compute_domains_2(x: NDArray, y: NDArray, n: int, i: int, q: int, r: int, s: int) -> int:
+    while i < n and x[i, MIN] == x[i, MAX] == y[i, MIN] == y[i, MAX]:
+        i += 1
+        r = i
+    if i == n or x[i, MAX] < y[i, MIN]:
+        # xq <= yq
+        x[q, MAX] = min(x[q, MAX], y[q, MAX])
+        if x[q, MAX] < x[q, MIN]:
+            return PROP_INCONSISTENCY
+        y[q, MIN] = max(y[q, MIN], x[q, MIN])
+        if y[q, MAX] < y[q, MIN]:
+            return PROP_INCONSISTENCY
+        return PROP_ENTAILMENT if x[q, MAX] <= y[q, MIN] else PROP_CONSISTENCY
+    if x[i, MIN] > y[i, MAX]:
+        # xq < yq
+        x[q, MAX] = min(x[q, MAX], y[q, MAX] - 1)
+        if x[q, MAX] < x[q, MIN]:
+            return PROP_INCONSISTENCY
+        y[q, MIN] = max(y[q, MIN], x[q, MIN] + 1)
+        if y[q, MAX] < y[q, MIN]:
+            return PROP_INCONSISTENCY
+        return PROP_ENTAILMENT if x[q, MAX] < y[q, MIN] else PROP_CONSISTENCY
+    if x[i, MAX] == y[i, MIN] and x[i, MIN] < y[i, MAX]:
+        if s > i + 1:
+            i = s
+        else:
+            i += 1
+            s = i
+        return compute_domains_3(x, y, n, i, q, r, s)
+    if x[i, MIN] == y[i, MAX] and x[i, MAX] > y[i, MIN]:
+        if s > i + 1:
+            i = s
+        else:
+            i += 1
+            s = i
+        return compute_domains_4(x, y, n, i, q, r, s)
+    # u = 2
+    return PROP_CONSISTENCY
+
+
+@njit("int64(int32[:,:], int32[:,:], int64, int64, int64, int64, int64)", cache=True)
+def compute_domains_1(x: NDArray, y: NDArray, n: int, i: int, q: int, r: int, s: int) -> int:
+    while i < n and x[i, MIN] == y[i, MAX]:
+        # enforce xi = yi
+        x[i, MAX] = min(x[i, MAX], y[i, MAX])
+        if x[i, MAX] < x[i, MIN]:
+            return PROP_INCONSISTENCY
+        y[i, MIN] = max(y[i, MIN], x[i, MIN])
+        if y[i, MAX] < y[i, MIN]:
+            return PROP_INCONSISTENCY
+        i += 1
+        q = i
+    if i == n or x[i, MAX] < y[i, MIN]:
+        return PROP_ENTAILMENT
+    # enforce xq <= yq
+    x[i, MAX] = min(x[i, MAX], y[i, MAX])
+    if x[i, MAX] < x[i, MIN]:
+        return PROP_INCONSISTENCY
+    y[i, MIN] = max(y[i, MIN], x[i, MIN])
+    if y[i, MAX] < y[i, MIN]:
+        return PROP_INCONSISTENCY
+    if r > i + 1:
+        i = r
+    else:
+        i += 1
+        r = i
+    return compute_domains_2(x, y, n, i, q, r, s)
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements lexicographic leq.
+    See https://www.diva-portal.org/smash/record.jsf?pid=diva2:1041533.
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    # TODO: make incremental
+    n = len(domains) // 2
+    return compute_domains_1(domains[:n], domains[n:], n, 0, 0, 0, 0)

nucs/propagators/max_eq_propagator.py

@@ -0,0 +1,36 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    Returns the triggers for this propagator.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    triggers = new_triggers(n, True)
+    triggers[-1, MIN] = False
+    return triggers
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements Max_i x_i = x_{n-1}.
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    x = domains[:-1]
+    y = domains[-1]
+    y[MIN] = max(y[MIN], np.max(x[:, MIN]))
+    y[MAX] = min(y[MAX], np.max(x[:, MAX]))
+    if y[MIN] > y[MAX]:
+        return PROP_INCONSISTENCY
+    for i in range(len(x)):
+        x[i, MAX] = min(x[i, MAX], y[MAX])
+        if x[i, MAX] < x[i, MIN]:
+            return PROP_INCONSISTENCY
+    return PROP_CONSISTENCY

nucs/propagators/max_leq_propagator.py

@@ -0,0 +1,46 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import (
+    MAX,
+    MIN,
+    PROP_CONSISTENCY,
+    PROP_ENTAILMENT,
+    PROP_INCONSISTENCY,
+    new_triggers,
+)
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    Returns the triggers for this propagator.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    triggers = new_triggers(n, False)
+    for i in range(n - 1):
+        triggers[i, MIN] = True
+    triggers[-1, MAX] = True
+    return triggers
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements Max_i x_i <= x_{n-1}.
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    x = domains[:-1]
+    y = domains[-1]
+    if np.max(x[:, MAX]) <= y[MIN]:
+        return PROP_ENTAILMENT
+    y[MIN] = max(y[MIN], np.max(x[:, MIN]))
+    if y[MIN] > y[MAX]:
+        return PROP_INCONSISTENCY
+    for i in range(len(x)):
+        x[i, MAX] = min(x[i, MAX], y[MAX])
+        if x[i, MAX] < x[i, MIN]:
+            return PROP_INCONSISTENCY
+    return PROP_CONSISTENCY

nucs/propagators/min_eq_propagator.py

@@ -0,0 +1,36 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import MAX, MIN, PROP_CONSISTENCY, PROP_INCONSISTENCY, new_triggers
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    Returns the triggers for this propagator.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    triggers = new_triggers(n, True)
+    triggers[-1, MAX] = False
+    return triggers
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements Min_i x_i = x_{n-1}.
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    x = domains[:-1]
+    y = domains[-1]
+    y[MIN] = max(y[MIN], np.min(x[:, MIN]))
+    y[MAX] = min(y[MAX], np.min(x[:, MAX]))
+    if y[MIN] > y[MAX]:
+        return PROP_INCONSISTENCY
+    for i in range(len(x)):
+        x[i, MIN] = max(x[i, MIN], y[MIN])
+        if x[i, MAX] < x[i, MIN]:
+            return PROP_INCONSISTENCY
+    return PROP_CONSISTENCY

nucs/propagators/min_geq_propagator.py

@@ -0,0 +1,46 @@
+import numpy as np
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.memory import (
+    MAX,
+    MIN,
+    PROP_CONSISTENCY,
+    PROP_ENTAILMENT,
+    PROP_INCONSISTENCY,
+    new_triggers,
+)
+
+
+def get_triggers(n: int, data: NDArray) -> NDArray:
+    """
+    Returns the triggers for this propagator.
+    :param n: the number of variables
+    :return: an array of triggers
+    """
+    triggers = new_triggers(n, False)
+    for i in range(n - 1):
+        triggers[i, MAX] = True
+    triggers[-1, MIN] = True
+    return triggers
+
+
+@njit("int64(int32[::1,:], int32[:])", cache=True)
+def compute_domains(domains: NDArray, data: NDArray) -> int:
+    """
+    Implements Min_i x_i >= x_{n-1}.
+    :param domains: the domains of the variables
+    :param data: unused here
+    """
+    x = domains[:-1]
+    y = domains[-1]
+    if y[MAX] <= np.min(x[:, MIN]):
+        return PROP_ENTAILMENT
+    y[MAX] = min(y[MAX], np.min(x[:, MAX]))
+    if y[MIN] > y[MAX]:
+        return PROP_INCONSISTENCY
+    for i in range(len(x)):
+        x[i, MIN] = max(x[i, MIN], y[MIN])
+        if x[i, MAX] < x[i, MIN]:
+            return PROP_INCONSISTENCY
+    return PROP_CONSISTENCY