passagemath-flint 10.6.1rc10__cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

sage/combinat/posets/hasse_cython_flint.pyx

@@ -0,0 +1,194 @@
+# sage_setup: distribution = sagemath-flint
+# cython: binding=True
+# sage.doctest: needs sage.libs.flint sage.graphs sage.modules
+r"""
+Some fast computations for finite posets using FLINT matrices
+"""
+# ****************************************************************************
+#       Copyright (C) 2020 Frédéric Chapoton <chapoton@unistra.fr>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License 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 cysignals.signals cimport sig_check
+from cysignals.memory cimport sig_malloc, sig_free
+
+from sage.libs.flint.fmpz cimport *
+from sage.libs.flint.fmpz_mat cimport *
+from sage.matrix.matrix_integer_dense cimport Matrix_integer_dense
+from sage.matrix.matrix_space import MatrixSpace
+from sage.rings.integer_ring import ZZ
+from sage.libs.flint.fmpz_poly_sage cimport Fmpz_poly
+
+
+cpdef Fmpz_poly chain_poly(list positions):
+    r"""
+    Return the chain polynomial of a poset.
+
+    INPUT:
+
+    - ``positions`` -- a list of sets of integers describing the poset, as
+      given by the lazy attribute ``_leq_storage`` of Hasse diagrams
+
+    OUTPUT: a Flint polynomial in one variable over `\ZZ`.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.hasse_cython_flint import chain_poly
+        sage: D = [{0, 1}, {1}]
+        sage: chain_poly(D)
+        3  1 2 1
+        sage: P = posets.TamariLattice(5)
+        sage: H = P._hasse_diagram
+        sage: D = H._leq_storage
+        sage: chain_poly(D)
+        12  1 42 357 1385 3133 4635 4758 3468 1778 612 127 12
+    """
+    cdef Py_ssize_t n = len(positions)
+    cdef Py_ssize_t i, j
+
+    q = Fmpz_poly([0, 1])
+    zero = Fmpz_poly(0)
+    one = Fmpz_poly(1)
+
+    cdef list chain_polys = [zero] * n
+
+    # chain_polys[i] will be the generating function for the
+    # chains with lowest vertex i (in the labelling of the
+    # Hasse diagram).
+    for i in range(n - 1, -1, -1):
+        cpi = q
+        for j in positions[i]:
+            cpi += q * chain_polys[j]
+        chain_polys[i] = cpi
+    total = one
+    for i in range(n):
+        total += chain_polys[i]
+    return total
+
+
+cpdef Matrix_integer_dense moebius_matrix_fast(list positions):
+    """
+    Compute the Möbius matrix of a poset by a specific triangular inversion.
+
+    INPUT:
+
+    - ``positions`` -- a list of sets of integers describing the poset, as
+      given by the lazy attribute ``_leq_storage`` of Hasse diagrams
+
+    OUTPUT: a dense matrix
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.hasse_cython_flint import moebius_matrix_fast
+        sage: D = [{0,1},{1}]
+        sage: moebius_matrix_fast(D)
+        [ 1 -1]
+        [ 0  1]
+        sage: P = posets.TamariLattice(5)
+        sage: H = P._hasse_diagram
+        sage: D = H._leq_storage
+        sage: moebius_matrix_fast(D)
+        42 x 42 dense matrix over Integer Ring (...)
+    """
+    cdef Matrix_integer_dense A
+    cdef Py_ssize_t n = len(positions)
+    cdef Py_ssize_t i
+    cdef int j, k
+    A = Matrix_integer_dense.__new__(Matrix_integer_dense,
+                                     MatrixSpace(ZZ, n, n), None, None, None)
+    fmpz_mat_one(A._matrix)
+    cdef Py_ssize_t *pos_lens = <Py_ssize_t*> sig_malloc(n*sizeof(Py_ssize_t))
+    cdef int **pos_array = <int**> sig_malloc(n*sizeof(int*))
+    cdef Py_ssize_t jind, kind
+    for i in range(n):
+        pos_lens[i] = len(positions[i])
+        pos_array[i] = <int*> sig_malloc(pos_lens[i]*sizeof(int))
+        for jind, j in enumerate(positions[i]):
+            pos_array[i][jind] = j
+
+    for i in range(n - 1, -1, -1):
+        sig_check()
+        for jind in range(pos_lens[i]):
+            j = pos_array[i][jind]
+            if j != i:
+                for kind in range(pos_lens[j]):
+                    k = pos_array[j][kind]
+                    fmpz_sub(fmpz_mat_entry(A._matrix, i, k),
+                             fmpz_mat_entry(A._matrix, i, k),
+                             fmpz_mat_entry(A._matrix, j, k))
+    for i in range(n):
+        sig_free(pos_array[i])
+    sig_free(pos_array)
+    sig_free(pos_lens)
+    return A
+
+
+cpdef Matrix_integer_dense coxeter_matrix_fast(list positions):
+    """
+    Compute the Coxeter matrix of a poset by a specific algorithm.
+
+    INPUT:
+
+    - ``positions`` -- a list of sets of integers describing the poset, as
+      given by the lazy attribute ``_leq_storage`` of Hasse diagrams
+
+    OUTPUT: a dense matrix
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.hasse_cython_flint import coxeter_matrix_fast
+        sage: D = [{0,1},{1}]
+        sage: coxeter_matrix_fast(D)
+        [ 0 -1]
+        [ 1 -1]
+        sage: P = posets.TamariLattice(5)
+        sage: H = P._hasse_diagram
+        sage: D = H._leq_storage
+        sage: coxeter_matrix_fast(D)
+        42 x 42 dense matrix over Integer Ring (...)
+    """
+    cdef Matrix_integer_dense A
+    cdef Py_ssize_t n = len(positions)
+    cdef Py_ssize_t i
+    cdef int j, k
+    A = Matrix_integer_dense.__new__(Matrix_integer_dense,
+                                     MatrixSpace(ZZ, n, n), None, None, None)
+    fmpz_mat_one(A._matrix)
+    cdef Py_ssize_t *pos_lens = <Py_ssize_t*> sig_malloc(n*sizeof(Py_ssize_t))
+    cdef int **pos_array = <int**> sig_malloc(n*sizeof(int*))
+    cdef Py_ssize_t jind, kind
+    for i in range(n):
+        pos_lens[i] = len(positions[i])
+        pos_array[i] = <int*> sig_malloc(pos_lens[i]*sizeof(int))
+        for jind, j in enumerate(positions[i]):
+            pos_array[i][jind] = j
+
+    for i in range(n - 1, -1, -1):
+        sig_check()
+        for jind in range(pos_lens[i]):
+            j = pos_array[i][jind]
+            if j != i:
+                for kind in range(pos_lens[j]):
+                    k = pos_array[j][kind]
+                    fmpz_sub(fmpz_mat_entry(A._matrix, k, i),
+                             fmpz_mat_entry(A._matrix, k, i),
+                             fmpz_mat_entry(A._matrix, k, j))
+    for i in range(n):
+        sig_check()
+        for jind in range(pos_lens[i]):
+            j = pos_array[i][jind]
+            if j != i:
+                for k in range(n):
+                    fmpz_add(fmpz_mat_entry(A._matrix, i, k),
+                             fmpz_mat_entry(A._matrix, i, k),
+                             fmpz_mat_entry(A._matrix, j, k))
+    for i in range(n):
+        sig_free(pos_array[i])
+    sig_free(pos_array)
+    sig_free(pos_lens)
+    fmpz_mat_scalar_mul_si(A._matrix, A._matrix, -1)
+    return A

sage/data_structures/all__sagemath_flint.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-flint

sage/data_structures/bounded_integer_sequences.pxd

@@ -0,0 +1,62 @@
+# sage_setup: distribution = sagemath-flint
+from sage.libs.gmp.types cimport *
+from sage.data_structures.bitset cimport *
+
+# A biseq (bounded integer sequence) is a sequence of nonnegative
+# integers, each fitting in "itembitsize" bits. We store the sequence
+# in a bitset of length at least length*itembitsize.
+ctypedef struct biseq_s:
+    # A bitset comprising at least length*itembitsize bits is used to
+    # store the items of this sequence. Note that bitset_t stores the
+    # data in a field mp_limb_t *bits, where mp_limb_t is defined in
+    # sage.libs.gmp.types.
+    #
+    # Normally, the "at least" in the first sentence above will be
+    # an equality, but we need the "at least" for the special case
+    # where the length is zero: then we will use a bitset of length 1.
+    # All extra bits (not in the first length*itembitsize) should be
+    # zero.
+    bitset_t data
+
+    # Number of items in this sequence.
+    mp_size_t length
+
+    # Bitsize (ranging from 1 to GMP_LIMB_BITS) of one item of this
+    # sequence. Note: Each item is a nonnegative integer, and all
+    # items of this sequence satisfy an upper bound. We do not store
+    # the exact bound for the items of this sequence, but store the
+    # bitsize that is sufficient to store one item.
+    mp_bitcnt_t itembitsize
+
+    # If L is a limb, then "L & mask_item" extracts the first
+    # itembitsize bits of it, i.e., it extracts one item.
+    size_t mask_item
+
+ctypedef biseq_s biseq_t[1]
+
+cdef bint biseq_init(biseq_t R, mp_size_t l, mp_bitcnt_t itemsize) except -1
+cdef void biseq_dealloc(biseq_t S) noexcept
+cdef bint biseq_init_copy(biseq_t R, biseq_t S) except -1
+cdef tuple biseq_pickle(biseq_t S)
+cdef bint biseq_unpickle(biseq_t R, tuple bitset_data, mp_bitcnt_t itembitsize, mp_size_t length) except -1
+cdef bint biseq_init_list(biseq_t R, list data, size_t bound) except -1
+cdef Py_hash_t biseq_hash(biseq_t S) noexcept
+cdef bint biseq_richcmp(biseq_t S1, biseq_t S2, int op) noexcept
+cdef bint biseq_init_concat(biseq_t R, biseq_t S1, biseq_t S2) except -1
+cdef bint biseq_startswith(biseq_t S1, biseq_t S2) except -1
+cdef mp_size_t biseq_contains(biseq_t S1, biseq_t S2, mp_size_t start) except -2
+cdef mp_size_t biseq_startswith_tail(biseq_t S1, biseq_t S2, mp_size_t start) except -2
+cdef mp_size_t biseq_index(biseq_t S, size_t item, mp_size_t start) except -2
+cdef size_t biseq_getitem(biseq_t S, mp_size_t index) noexcept
+cdef biseq_getitem_py(biseq_t S, mp_size_t index)
+cdef void biseq_inititem(biseq_t S, mp_size_t index, size_t item) noexcept
+cdef void biseq_clearitem(biseq_t S, mp_size_t index) noexcept
+cdef bint biseq_init_slice(biseq_t R, biseq_t S, mp_size_t start, mp_size_t stop, mp_size_t step) except -1
+
+cdef class BoundedIntegerSequence:
+    cdef biseq_t data
+    cpdef bint startswith(self, BoundedIntegerSequence other) noexcept
+    cpdef list list(self)
+    cpdef BoundedIntegerSequence maximal_overlap(self, BoundedIntegerSequence other)
+
+cpdef BoundedIntegerSequence NewBISEQ(tuple bitset_data, mp_bitcnt_t itembitsize, mp_size_t length)