passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/combinat/tuple.py

@@ -0,0 +1,348 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Tuples
+"""
+# ****************************************************************************
+#       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from itertools import product, combinations_with_replacement
+
+from sage.arith.misc import binomial
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.rings.integer_ring import ZZ
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+
+
+class Tuples(Parent, UniqueRepresentation):
+    """
+    Return the enumerated set of ordered tuples of S of length k.
+
+    An ordered tuple of length k of set is an ordered selection with
+    repetition and is represented by a list of length k containing
+    elements of set.
+
+    EXAMPLES::
+
+        sage: S = [1,2]
+        sage: Tuples(S,3).list()
+        [(1, 1, 1), (2, 1, 1), (1, 2, 1), (2, 2, 1), (1, 1, 2),
+         (2, 1, 2), (1, 2, 2), (2, 2, 2)]
+        sage: mset = ["s","t","e","i","n"]
+        sage: Tuples(mset,2).list()
+        [('s', 's'), ('t', 's'), ('e', 's'), ('i', 's'), ('n', 's'),
+         ('s', 't'), ('t', 't'), ('e', 't'), ('i', 't'), ('n', 't'),
+         ('s', 'e'), ('t', 'e'), ('e', 'e'), ('i', 'e'), ('n', 'e'),
+         ('s', 'i'), ('t', 'i'), ('e', 'i'), ('i', 'i'), ('n', 'i'),
+         ('s', 'n'), ('t', 'n'), ('e', 'n'), ('i', 'n'), ('n', 'n')]
+
+    ::
+
+        sage: K.<a> = GF(4, 'a')                                                        # needs sage.rings.finite_rings
+        sage: mset = sorted((x for x in K if x != 0), key=str)                          # needs sage.rings.finite_rings
+        sage: Tuples(mset, 2).list()                                                    # needs sage.rings.finite_rings
+        [(1, 1),     (a, 1),     (a + 1, 1),
+         (1, a),     (a, a),     (a + 1, a),
+         (1, a + 1), (a, a + 1), (a + 1, a + 1)]
+    """
+    @staticmethod
+    def __classcall_private__(cls, S, k):
+        """
+        Normalize input to ensure a unique representation.
+
+        EXAMPLES::
+
+            sage: T = Tuples(['l','i','t'],2); T
+            Tuples of ('l', 'i', 't') of length 2
+        """
+        return super().__classcall__(cls, tuple(S), k)
+
+    def __init__(self, S, k):
+        """
+        TESTS::
+
+            sage: T = Tuples([1,2,3],2)
+            sage: T == loads(dumps(T))
+            True
+        """
+        self.S = S
+        self.k = k
+        self._index_list = list({S.index(s) for s in S})
+        category = FiniteEnumeratedSets()
+        Parent.__init__(self, category=category)
+
+    def __repr__(self):
+        """
+        TESTS::
+
+            sage: repr(Tuples([1,2,3],2))
+            'Tuples of (1, 2, 3) of length 2'
+        """
+        return "Tuples of %s of length %s" % (self.S, self.k)
+
+    def unrank(self, i):
+        """
+        Return the `i`-th element of the set of Tuples.
+
+        INPUT:
+
+        - ``i`` -- integer between `0` and `n-1`, where `n` is the cardinality
+          of this set
+
+        EXAMPLES::
+
+            sage: T = Tuples(range(7), 6)
+            sage: T[73451]
+            (0, 0, 1, 4, 2, 4)
+
+        TESTS:
+
+        Verify that :meth:`unrank` is giving the correct result::
+
+            sage: T = Tuples(range(4), 5)
+            sage: all(T[i] == x for i,x in enumerate(T))
+            True
+
+        Verify that :meth:`unrank` is fast for large inputs::
+
+            sage: Tuples(range(3), 30)[10^12]
+            (1, 0, 0, 1, 1, 1, 2, 0, 1, 2, 0, 1, 1, 0, 2, 1, 1, 0, 1, 2, 1, 2,
+            1, 1, 0, 1, 0, 0, 0, 0)
+
+        Verify that :meth:`unrank` normalizes ``i``::
+
+            sage: T = Tuples(range(3), 2)
+            sage: T[QQ(4/2)]
+            (2, 0)
+            sage: T[QQ(1/2)]
+            Traceback (most recent call last):
+            ...
+            TypeError: no conversion of this rational to integer
+
+        Verify that :meth:`unrank` throws an error when ``i`` is out of bounds::
+
+            sage: T = Tuples(range(3), 3)
+            sage: T[27]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=27) is greater than or equal to the cardinality
+            sage: T[-28]
+            Traceback (most recent call last):
+            ...
+            IndexError: index out of range
+
+        Verify that :meth:`unrank` works correctly for Tuples where `k = 1`::
+
+            sage: T = Tuples(range(6), 1)
+            sage: T[5]
+            (5,)
+
+        Verify that :meth:`unrank` works when called directly::
+
+            sage: T = Tuples(range(4), 3)
+            sage: T.unrank(19)
+            (3, 0, 1)
+            sage: T.unrank(-1)
+            Traceback (most recent call last):
+            ...
+            IndexError: index out of range
+
+        Verify that :meth:`unrank` works with non-integer sets::
+
+            sage: T = Tuples(['a', 'b', 'c'], 3)
+            sage: T[15]
+            ('a', 'c', 'b')
+            sage: T = Tuples([None, 1, ZZ, GF(2)], 5)
+            sage: T[30]
+            (Integer Ring, Finite Field of size 2, 1, None, None)
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| < 1`::
+
+            sage: T = Tuples([],5)
+            sage: T[0]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=0) is greater than or equal to the cardinality
+            sage: list(T)
+            []
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| = 1`::
+
+            sage: T = Tuples([1],5)
+            sage: T[0]
+            (1, 1, 1, 1, 1)
+
+        Verify that :meth:`unrank` gives the correct answer when `k = 0`::
+
+            sage: T = Tuples(range(6), 0)
+            sage: list(T)
+            [()]
+            sage: T[0]
+            ()
+            sage: T[1]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=1) is greater than or equal to the cardinality
+
+        Verify that :meth:`unrank` gives the correct answer when `|S| < 1` and
+        `k = 0`::
+
+            sage: T = Tuples(range(0), 0)
+            sage: T[0]
+            ()
+            sage: T[-1]
+            ()
+            sage: T[1]
+            Traceback (most recent call last):
+            ...
+            IndexError: index i (=1) is greater than or equal to the cardinality
+
+        Verify that :issue:`39534` has been fixed::
+
+            sage: T = Tuples(range(3), 30).random_element()
+            sage: all(v in range(3) for v in T)
+            True
+            sage: len(T)
+            30
+        """
+        i = ZZ(i)
+        if i < 0:
+            raise IndexError("index out of range")
+        if i >= self.cardinality():
+            raise IndexError("index i (={}) is greater than or equal to the cardinality"
+                             .format(i))
+        ts = len(self.S)
+        if ts <= 1:
+            return tuple(self.S[0] for _ in range(self.k))
+        return tuple(i.digits(ts, self.S, self.k))
+
+    def __iter__(self):
+        """
+        EXAMPLES::
+
+            sage: S = [1,2]
+            sage: Tuples(S,3).list()
+            [(1, 1, 1), (2, 1, 1), (1, 2, 1), (2, 2, 1), (1, 1, 2),
+             (2, 1, 2), (1, 2, 2), (2, 2, 2)]
+            sage: mset = ["s","t","e","i","n"]
+            sage: Tuples(mset,2).list()
+            [('s', 's'), ('t', 's'), ('e', 's'), ('i', 's'), ('n', 's'),
+             ('s', 't'), ('t', 't'), ('e', 't'), ('i', 't'), ('n', 't'),
+             ('s', 'e'), ('t', 'e'), ('e', 'e'), ('i', 'e'), ('n', 'e'),
+             ('s', 'i'), ('t', 'i'), ('e', 'i'), ('i', 'i'), ('n', 'i'),
+             ('s', 'n'), ('t', 'n'), ('e', 'n'), ('i', 'n'), ('n', 'n')]
+            sage: Tuples((1,1,2),3).list()
+            [(1, 1, 1), (2, 1, 1), (1, 2, 1), (2, 2, 1), (1, 1, 2),
+             (2, 1, 2), (1, 2, 2), (2, 2, 2)]
+        """
+        for p in product(self._index_list, repeat=self.k):
+            yield tuple(self.S[i] for i in reversed(p))
+
+    def cardinality(self):
+        """
+        EXAMPLES::
+
+            sage: S = [1,2,3,4,5]
+            sage: Tuples(S,2).cardinality()
+            25
+            sage: S = [1,1,2,3,4,5]
+            sage: Tuples(S,2).cardinality()
+            25
+        """
+        return ZZ(len(self._index_list)).__pow__(self.k)
+
+
+Tuples_sk = Tuples
+
+
+class UnorderedTuples(Parent, UniqueRepresentation):
+    """
+    Return the enumerated set of unordered tuples of S of length k.
+
+    An unordered tuple of length k of set is a unordered selection with
+    repetitions of set and is represented by a sorted list of length k
+    containing elements from set.
+
+    EXAMPLES::
+
+        sage: S = [1,2]
+        sage: UnorderedTuples(S,3).list()
+        [(1, 1, 1), (1, 1, 2), (1, 2, 2), (2, 2, 2)]
+        sage: UnorderedTuples(["a","b","c"],2).list()
+        [('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'),
+         ('c', 'c')]
+    """
+    @staticmethod
+    def __classcall_private__(cls, S, k):
+        """
+        Normalize input to ensure a unique representation.
+
+        EXAMPLES::
+
+            sage: T = UnorderedTuples(['l','i','t'],2); T
+            Unordered tuples of ('l', 'i', 't') of length 2
+        """
+        return super().__classcall__(cls, tuple(S), k)
+
+    def __init__(self, S, k):
+        """
+        TESTS::
+
+            sage: T = Tuples([1,2,3],2)
+            sage: T == loads(dumps(T))
+            True
+        """
+        self.S = S
+        self.k = k
+        self._index_list = list({S.index(s) for s in S})
+        category = FiniteEnumeratedSets()
+        Parent.__init__(self, category=category)
+
+    def __repr__(self):
+        """
+        TESTS::
+
+            sage: repr(UnorderedTuples([1,2,3],2))
+            'Unordered tuples of (1, 2, 3) of length 2'
+        """
+        return "Unordered tuples of %s of length %s" % (self.S, self.k)
+
+    def __iter__(self):
+        """
+        EXAMPLES::
+
+            sage: S = [1,2]
+            sage: UnorderedTuples(S,3).list()
+            [(1, 1, 1), (1, 1, 2), (1, 2, 2), (2, 2, 2)]
+            sage: UnorderedTuples(["a","b","c"],2).list()
+            [('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'),
+             ('c', 'c')]
+            sage: UnorderedTuples([1,1,2],3).list()
+            [(1, 1, 1), (1, 1, 2), (1, 2, 2), (2, 2, 2)]
+        """
+        for ans in combinations_with_replacement(self._index_list, self.k):
+            yield tuple(self.S[i] for i in ans)
+
+    def cardinality(self):
+        """
+        EXAMPLES::
+
+            sage: S = [1,2,3,4,5]
+            sage: UnorderedTuples(S,2).cardinality()
+            15
+        """
+        return binomial(len(self._index_list) + self.k - 1, self.k)
+
+
+UnorderedTuples_sk = UnorderedTuples

sage/data_structures/all.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-categories
+from sage.data_structures.all__sagemath_categories import *

sage/data_structures/all__sagemath_categories.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-categories
+from sage.data_structures.bitset import Bitset, FrozenBitset

sage/data_structures/binary_matrix.pxd

@@ -0,0 +1,138 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+A binary matrix datatype in Cython
+
+It's almost a copy of the bitset datatype, but allows a differentiation of the
+rows of the matrix. That's the only advantage compared to storing all the rows
+of a matrix in a loooooonng bitset.
+
+A ``binary_matrix_t`` structure contains:
+
+- ``mp_bitcnt_t n_cols`` -- number of columns
+
+- ``mp_bitcnt_t n_rows`` -- number of rows
+
+- ``bitset_t * rows`` -- ``rows[i]`` points toward a block of type ``bitset_t``
+  containing the bits of row `i`
+"""
+
+from sage.data_structures.bitset_base cimport *
+
+cdef struct binary_matrix_s:
+    mp_bitcnt_t n_cols
+    mp_bitcnt_t n_rows
+    bitset_t* rows
+
+ctypedef binary_matrix_s[1] binary_matrix_t
+
+cdef inline int binary_matrix_init(binary_matrix_t m, mp_bitcnt_t n_rows, mp_bitcnt_t n_cols) except -1:
+    r"""
+    Allocate an empty binary matrix with ``n_rows`` rows and ``n_cols`` columns.
+    """
+    cdef mp_bitcnt_t i
+
+    m.n_cols = n_cols
+    m.n_rows = n_rows
+    m.rows = <bitset_t *>sig_malloc(n_rows * sizeof(bitset_t))
+    if m.rows == NULL:
+        raise MemoryError
+
+    for i in range(n_rows):
+        bitset_init(m.rows[i], n_cols)
+
+cdef inline int binary_matrix_realloc(binary_matrix_t m, mp_bitcnt_t n_rows, mp_bitcnt_t n_cols) except -1:
+    r"""
+    Reallocate a binary matrix to have ``n_rows`` rows and ``n_cols`` columns.
+
+    Possibly new positions do not contain extra bits.
+    """
+    cdef mp_bitcnt_t i
+    for i in range(n_rows, m.n_rows):
+        bitset_free(m.rows[i])
+
+    m.rows = <bitset_t *>check_reallocarray(m.rows, n_rows, sizeof(bitset_t))
+
+    for i in range(min(n_rows, m.n_rows)):
+        bitset_realloc(m.rows[i], n_cols)
+
+    for i in range(m.n_rows, n_rows):
+        bitset_init(m.rows[i], n_cols)
+
+    m.n_cols = n_cols
+    m.n_rows = n_rows
+
+cdef inline void binary_matrix_free(binary_matrix_t m) noexcept:
+    r"""
+    Free the memory allocated by the matrix
+    """
+    cdef mp_bitcnt_t i
+
+    for i in range(m.n_rows):
+        bitset_free(m.rows[i])
+    sig_free(m.rows)
+
+cdef inline void binary_matrix_copy(binary_matrix_t dst, binary_matrix_t src) noexcept:
+    """
+    Copy the binary matrix src over to the binary matrix dst, overwriting dst.
+
+    We assume that ``dst.n_rows == src.n_rows`` and ``dst.n_cols == src.n_cols``.
+    """
+    cdef mp_bitcnt_t i
+    for i in range(dst.n_rows):
+        bitset_copy(dst.rows[i], src.rows[i])
+
+cdef inline void binary_matrix_fill(binary_matrix_t m, bint bit) noexcept:
+    r"""
+    Fill the whole matrix with a bit
+    """
+    cdef mp_bitcnt_t i
+
+    if bit:  # set the matrix to 1
+        for i in range(m.n_rows):
+            bitset_set_first_n(m.rows[i], m.n_cols)
+    else:
+        for i in range(m.n_rows):
+            bitset_clear(m.rows[i])
+
+cdef inline void binary_matrix_complement(binary_matrix_t m) noexcept:
+    r"""
+    Complement all of the matrix' bits.
+    """
+    cdef mp_bitcnt_t i
+    for i in range(m.n_rows):
+        bitset_complement(m.rows[i], m.rows[i])
+
+cdef inline void binary_matrix_set1(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt_t col) noexcept:
+    r"""
+    Set an entry to 1
+    """
+    bitset_add(m.rows[row], col)
+
+cdef inline void binary_matrix_set0(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt_t col) noexcept:
+    r"""
+    Set an entry to 0
+    """
+    bitset_discard(m.rows[row], col)
+
+cdef inline void binary_matrix_set(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt_t col, bint value) noexcept:
+    r"""
+    Set an entry
+    """
+    bitset_set_to(m.rows[row], col, value)
+
+cdef inline bint binary_matrix_get(binary_matrix_t m, mp_bitcnt_t row, mp_bitcnt_t col) noexcept:
+    r"""
+    Return the value of a given entry
+    """
+    return bitset_in(m.rows[row], col)
+
+cdef inline binary_matrix_print(binary_matrix_t m):
+    r"""
+    Print the binary matrix
+    """
+    cdef mp_bitcnt_t i, j
+    import sys
+    for i in range(m.n_rows):
+        for j in range(m.n_cols):
+            sys.stdout.write("1" if binary_matrix_get(m, i, j) else ".",)
+        print("")

sage/data_structures/binary_search.pxd

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-categories
+cdef Py_ssize_t binary_search(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x, Py_ssize_t* ins) noexcept
+cdef Py_ssize_t binary_search0(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x) noexcept

sage/data_structures/binary_search.pyx

@@ -0,0 +1,66 @@
+# sage_setup: distribution = sagemath-categories
+# We can probably get away with only having the mpz_binary_searches in here.
+# I'm too scared to get rid of it at 2am though.
+cdef Py_ssize_t binary_search(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x, Py_ssize_t* ins) noexcept:
+    """
+    Find the position of the integer x in the array v, which has length n.
+
+    Return -1 if x is not in the array v, and in this case ins is
+    set equal to the position where x should be inserted in order to
+    obtain an ordered array.
+    """
+    if n == 0:
+        ins[0] = 0
+        return -1
+
+    cdef Py_ssize_t i, j, k
+    i = 0
+    j = n-1
+    while i<=j:
+        if i == j:
+            if v[i] == x:
+                ins[0] = i
+                return i
+            if v[i] < x:
+                ins[0] = i + 1
+            else:
+                ins[0] = i
+            return -1
+        k = (i+j)/2
+        if v[k] > x:
+            j = k-1
+        elif v[k] < x:
+            i = k+1
+        else:   # only possibility is that v[k] == x
+            ins[0] = k
+            return k
+    # end while
+    ins[0] = j+1
+    return -1
+
+
+cdef Py_ssize_t binary_search0(Py_ssize_t* v, Py_ssize_t n, Py_ssize_t x) noexcept:
+    """
+    Find the position of the int x in the array v, which has length n.
+
+    Return -1 if x is not in the array v.
+    """
+    if n == 0:
+        return -1
+
+    cdef Py_ssize_t i, j, k
+    i = 0
+    j = n-1
+    while i<=j:
+        if i == j:
+            if v[i] == x:
+                return i
+            return -1
+        k = (i+j)/2
+        if v[k] > x:
+            j = k-1
+        elif v[k] < x:
+            i = k+1
+        else:   # only possibility is that v[k] == x
+            return k
+    return -1

sage/data_structures/bitset.pxd

@@ -0,0 +1,40 @@
+# sage_setup: distribution = sagemath-categories
+# ***************************************************************************
+#     Copyright (C) 2008 Robert Bradshaw <robertwb@math.washington.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from sage.data_structures.bitset_base cimport bitset_t
+
+# Python layer over bitset_t
+cdef class FrozenBitset:
+    cdef bitset_t _bitset
+    cdef FrozenBitset _new(self, long int capacity)
+    cpdef FrozenBitset _larger_capacity_(self, long size)
+    cpdef long capacity(self) noexcept
+    cpdef bint isempty(self) noexcept
+    cpdef bint issubset(self, FrozenBitset other) except -1
+    cpdef bint issuperset(self, FrozenBitset other) except -1
+    cpdef bint isdisjoint(self, FrozenBitset other) except -1
+    cpdef _union(self, FrozenBitset other)
+    cpdef intersection(self, FrozenBitset other)
+    cpdef difference(self, FrozenBitset other)
+    cpdef symmetric_difference(self, FrozenBitset other)
+    cpdef complement(self)
+    cpdef __copy__(self)
+
+cdef class Bitset(FrozenBitset):
+    cpdef __copy__(self)
+    cpdef update(self, FrozenBitset other)
+    cpdef intersection_update(self, FrozenBitset other)
+    cpdef difference_update(self, FrozenBitset other)
+    cpdef symmetric_difference_update(self, FrozenBitset other)
+    cpdef add(self, unsigned long n)
+    cpdef remove(self, unsigned long n)
+    cpdef discard(self, unsigned long n)
+    cpdef pop(self)
+    cpdef clear(self)