passagemath-flint 10.6.1rc10__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sage/matrix/misc_flint.pyx

@@ -0,0 +1,109 @@
+# sage_setup: distribution = sagemath-flint
+# sage.doctest: needs sage.libs.linbox
+r"""
+Misc matrix algorithms using FLINT
+"""
+
+from cysignals.signals cimport sig_check
+
+from sage.arith.rational_reconstruction cimport mpq_rational_reconstruction
+from sage.libs.gmp.mpq cimport *
+from sage.libs.gmp.mpz cimport *
+from sage.libs.flint.fmpq cimport fmpq_set_mpq, fmpq_canonicalise
+from sage.libs.flint.fmpq_mat cimport fmpq_mat_entry_num, fmpq_mat_entry_den, fmpq_mat_entry
+from sage.libs.flint.fmpz cimport fmpz_set_mpz, fmpz_one
+from sage.rings.integer cimport Integer
+from sage.rings.rational_field import QQ
+
+from sage.matrix.matrix_integer_dense cimport Matrix_integer_dense
+from sage.matrix.matrix_rational_dense cimport Matrix_rational_dense
+
+
+def matrix_integer_dense_rational_reconstruction(Matrix_integer_dense A, Integer N):
+    r"""
+    Given a matrix over the integers and an integer modulus, do
+    rational reconstruction on all entries of the matrix, viewed as
+    numbers mod `N`.  This is done efficiently by assuming there is a
+    large common factor dividing the denominators.
+
+    INPUT:
+
+    - ``A`` -- matrix
+    - ``N`` -- integer
+
+    EXAMPLES::
+
+        sage: B = ((matrix(ZZ, 3,4, [1,2,3,-4,7,2,18,3,4,3,4,5])/3)%500).change_ring(ZZ)
+        sage: from sage.matrix.misc_flint import matrix_integer_dense_rational_reconstruction
+        sage: matrix_integer_dense_rational_reconstruction(B, 500)
+        [ 1/3  2/3    1 -4/3]
+        [ 7/3  2/3    6    1]
+        [ 4/3    1  4/3  5/3]
+
+    TESTS:
+
+    Check that :issue:`9345` is fixed::
+
+        sage: A = random_matrix(ZZ, 3)
+        sage: matrix_integer_dense_rational_reconstruction(A, 0)
+        Traceback (most recent call last):
+        ...
+        ZeroDivisionError: The modulus cannot be zero
+    """
+    if not N:
+        raise ZeroDivisionError("The modulus cannot be zero")
+    cdef Matrix_rational_dense R
+    R = Matrix_rational_dense.__new__(Matrix_rational_dense,
+                                      A.parent().change_ring(QQ), 0,0,0)
+
+    cdef mpz_t a, bnd, other_bnd, denom, tmp
+    cdef mpq_t qtmp
+    cdef Integer _bnd
+    cdef Py_ssize_t i, j
+    cdef int do_it
+
+    mpz_init_set_si(denom, 1)
+    mpz_init(a)
+    mpz_init(tmp)
+    mpz_init(other_bnd)
+    mpq_init(qtmp)
+
+    _bnd = (N//2).isqrt()
+    mpz_init_set(bnd, _bnd.value)
+    mpz_sub(other_bnd, N.value, bnd)
+
+    for i in range(A._nrows):
+        for j in range(A._ncols):
+            sig_check()
+            A.get_unsafe_mpz(i, j, a)
+            if mpz_cmp_ui(denom, 1) != 0:
+                mpz_mul(a, a, denom)
+            mpz_fdiv_r(a, a, N.value)
+            do_it = 0
+            if mpz_cmp(a, bnd) <= 0:
+                do_it = 1
+            elif mpz_cmp(a, other_bnd) >= 0:
+                mpz_sub(a, a, N.value)
+                do_it = 1
+            if do_it:
+                fmpz_set_mpz(fmpq_mat_entry_num(R._matrix, i, j), a)
+                if mpz_cmp_ui(denom, 1) != 0:
+                    fmpz_set_mpz(fmpq_mat_entry_den(R._matrix, i, j), denom)
+                    fmpq_canonicalise(fmpq_mat_entry(R._matrix, i, j))
+                else:
+                    fmpz_one(fmpq_mat_entry_den(R._matrix, i, j))
+            else:
+                # Otherwise have to do it the hard way
+                A.get_unsafe_mpz(i, j, tmp)
+                mpq_rational_reconstruction(qtmp, tmp, N.value)
+                mpz_lcm(denom, denom, mpq_denref(qtmp))
+                fmpq_set_mpq(fmpq_mat_entry(R._matrix, i, j), qtmp)
+
+    mpz_clear(denom)
+    mpz_clear(a)
+    mpz_clear(tmp)
+    mpz_clear(other_bnd)
+    mpz_clear(bnd)
+    mpq_clear(qtmp)
+
+    return R

sage/modular/all__sagemath_flint.py

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

sage/modular/modform/all__sagemath_flint.py

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

sage/modular/modform/eis_series_cython.pyx

@@ -0,0 +1,226 @@
+# sage_setup: distribution = sagemath-flint
+# sage.doctest: needs sage.libs.pari
+"""
+Eisenstein series, optimized
+"""
+
+from cysignals.memory cimport check_allocarray, sig_free
+from cysignals.signals cimport sig_check
+
+from sage.arith.misc import primes, bernoulli
+from sage.rings.integer cimport Integer
+from sage.rings.fast_arith cimport prime_range
+
+from cpython.list cimport PyList_GET_ITEM
+from sage.libs.flint.fmpz_poly cimport *
+from sage.libs.gmp.mpz cimport *
+from sage.libs.flint.fmpz_poly_sage cimport Fmpz_poly, fmpz_poly_set_coeff_mpz, fmpz_poly_scalar_mul_mpz
+
+cpdef Ek_ZZ(int k, int prec=10):
+    """
+    Return list of prec integer coefficients of the weight k
+    Eisenstein series of level 1, normalized so the coefficient of q
+    is 1, except that the 0th coefficient is set to 1 instead of its
+    actual value.
+
+    INPUT:
+
+    - ``k`` -- integer
+    - ``prec`` -- integer
+
+    OUTPUT: list of integers
+
+    EXAMPLES::
+
+        sage: from sage.modular.modform.eis_series_cython import Ek_ZZ
+        sage: Ek_ZZ(4,10)
+        [1, 1, 9, 28, 73, 126, 252, 344, 585, 757]
+        sage: [sigma(n,3) for n in [1..9]]
+        [1, 9, 28, 73, 126, 252, 344, 585, 757]
+        sage: Ek_ZZ(10,10^3) == [1] + [sigma(n,9) for n in range(1,10^3)]
+        True
+    """
+    cdef Integer pp
+    cdef mpz_t q, current_sum, q_plus_one
+
+    cdef unsigned long p
+    cdef Py_ssize_t i, ind
+    cdef bint continue_flag
+
+    cdef list power_sum_ls
+
+    cdef unsigned long max_power_sum, temp_index
+    cdef unsigned long remainder, prev_index
+    cdef unsigned long additional_p_powers
+
+    mpz_init(q)
+    mpz_init(current_sum)
+    mpz_init(q_plus_one)
+
+    # allocate the list for the result
+    cdef list val = []
+    for i in range(prec):
+        pp = Integer.__new__(Integer)
+        mpz_set_si(pp.value, 1)
+        val.append(pp)
+
+    # no need to reallocate this list every time -- just reuse the
+    # Integers in it
+    power_sum_ls = []
+    max_power_sum = prec
+    while max_power_sum:
+        max_power_sum >>= 1
+        pp = Integer.__new__(Integer)
+        mpz_set_si(pp.value, 1)
+        power_sum_ls.append(pp)
+
+    for pp in prime_range(prec):
+        p = mpz_get_ui((<Integer>pp).value)
+        mpz_ui_pow_ui(q, p, k - 1)
+        mpz_add_ui(q_plus_one, q, 1)
+        mpz_set(current_sum, q_plus_one)
+
+        # NOTE: I (wstein) did benchmarks, and the use of
+        # PyList_GET_ITEM in the code below is worth it since it leads
+        # to a significant speedup by not doing bounds checking.
+
+        # set power_sum_ls[1] = q+1
+        mpz_set((<Integer>(PyList_GET_ITEM(power_sum_ls, 1))).value,
+                current_sum)
+        max_power_sum = 1
+
+        ind = 0
+        while True:
+            continue_flag = 0
+            # do the first p-1
+            for i in range(1, p):
+                ind += p
+                if (ind >= prec):
+                    continue_flag = 1
+                    break
+                mpz_mul((<Integer>(PyList_GET_ITEM(val, ind))).value,
+                        (<Integer>(PyList_GET_ITEM(val, ind))).value,
+                        q_plus_one)
+            ind += p
+            if (ind >= prec or continue_flag):
+                break
+
+            # now do the pth one, which is harder.
+
+            # compute the valuation of n at p
+            additional_p_powers = 0
+            temp_index = ind // p
+            remainder = 0
+            while not remainder:
+                additional_p_powers += 1
+                prev_index = temp_index
+                temp_index = temp_index // p
+                remainder = prev_index - p*temp_index
+
+            # if we need a new sum, it has to be the next uncomputed one.
+            if (additional_p_powers > max_power_sum):
+                mpz_mul(current_sum, current_sum, q)
+                mpz_add_ui(current_sum, current_sum, 1)
+                max_power_sum += 1
+
+                mpz_set((<Integer>(PyList_GET_ITEM(power_sum_ls,
+                                                   max_power_sum))).value,
+                        current_sum)
+
+            # finally, set the coefficient
+            mpz_mul((<Integer>(PyList_GET_ITEM(val, ind))).value,
+                    (<Integer>(PyList_GET_ITEM(val, ind))).value,
+                    (<Integer>(PyList_GET_ITEM(power_sum_ls,
+                                               additional_p_powers))).value)
+
+    mpz_clear(q)
+    mpz_clear(current_sum)
+    mpz_clear(q_plus_one)
+
+    return val
+
+
+cpdef eisenstein_series_poly(int k, int prec=10):
+    r"""
+    Return the `q`-expansion up to precision ``prec`` of the weight `k`
+    Eisenstein series, as a FLINT :class:`~sage.libs.flint.fmpz_poly.Fmpz_poly`
+    object, normalised so the coefficients are integers with no common factor.
+
+    Used internally by the functions
+    :func:`~sage.modular.modform.eis_series.eisenstein_series_qexp` and
+    :func:`~sage.modular.modform.vm_basis.victor_miller_basis`; see the
+    docstring of the former for further details.
+
+    EXAMPLES::
+
+        sage: from sage.modular.modform.eis_series_cython import eisenstein_series_poly
+        sage: eisenstein_series_poly(12, prec=5)
+        5  691 65520 134250480 11606736960 274945048560
+    """
+    cdef mpz_t *val = <mpz_t *>check_allocarray(prec, sizeof(mpz_t))
+    cdef mpz_t one, mult, term, last, term_m1, last_m1
+    cdef long ind
+    cdef int i
+    cdef Fmpz_poly res = Fmpz_poly.__new__(Fmpz_poly)
+
+    if k % 2 or k < 2:
+        raise ValueError("k (=%s) must be an even positive integer" % k)
+    if prec < 0:
+        raise ValueError("prec (=%s) must be an even nonnegative integer" % prec)
+    if (prec == 0):
+        return Fmpz_poly.__new__(Fmpz_poly)
+
+    mpz_init(one)
+    mpz_init(term)
+    mpz_init(last)
+    mpz_init(mult)
+    mpz_init(term_m1)
+    mpz_init(last_m1)
+
+    for i in range(prec):
+        mpz_init_set_si(val[i], 1)
+
+    mpz_set_si(one, 1)
+
+    cdef unsigned long expt = k - 1
+    a0 = -bernoulli(k) / (2*k)
+
+    cdef long p, ppow
+    for p in primes(1, prec):
+        ppow = p
+
+        mpz_set_si(mult, p)
+        mpz_pow_ui(mult, mult, expt)
+        mpz_mul(term, mult, mult)
+        mpz_set(last, mult)
+
+        while ppow < prec:
+            sig_check()
+            ind = ppow
+            mpz_sub(term_m1, term, one)
+            mpz_sub(last_m1, last, one)
+            while ind < prec:
+                mpz_mul(val[ind], val[ind], term_m1)
+                mpz_fdiv_q(val[ind], val[ind], last_m1)
+                ind += ppow
+            ppow *= p
+            mpz_set(last, term)
+            mpz_mul(term, term, mult)
+
+    mpz_clear(one)
+    mpz_clear(term)
+    mpz_clear(last)
+    mpz_clear(mult)
+    mpz_clear(term_m1)
+    mpz_clear(last_m1)
+
+    fmpz_poly_set_coeff_mpz(res.poly, prec-1, val[prec-1])
+    for i in range(1, prec - 1):
+        fmpz_poly_set_coeff_mpz(res.poly, i, val[i])
+
+    fmpz_poly_scalar_mul_mpz(res.poly, res.poly, (<Integer>(a0.denominator())).value)
+    fmpz_poly_set_coeff_mpz(res.poly, 0, (<Integer>(a0.numerator())).value)
+
+    sig_free(val)
+
+    return res

sage/modular/modsym/all__sagemath_flint.py

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

sage/modular/modsym/apply.pxd

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-flint
+from sage.libs.flint.types cimport fmpz_poly_t
+
+cdef class Apply:
+    cdef fmpz_poly_t f, g, ff, gg
+    cdef int apply_to_monomial_flint(self, fmpz_poly_t ans, int i, int j, int a, int b, int c, int d) except -1

sage/modular/modsym/apply.pyx

@@ -0,0 +1,113 @@
+# sage_setup: distribution = sagemath-flint
+# distutils: extra_compile_args = -D_XPG6
+"""
+Monomial expansion of `(aX + bY)^i (cX + dY)^{j-i}`
+"""
+
+##########################################################################
+#
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+#
+##########################################################################
+
+from sage.ext.stdsage cimport PY_NEW
+
+from sage.libs.flint.fmpz_poly cimport *
+from sage.libs.flint.fmpz_poly_sage cimport *
+from sage.rings.integer cimport Integer
+
+cdef class Apply:
+    def __cinit__(self):
+        """
+        EXAMPLES::
+
+            sage: import sage.modular.modsym.apply
+            sage: sage.modular.modsym.apply.Apply()
+            <sage.modular.modsym.apply.Apply object at ...>
+        """
+        fmpz_poly_init(self.f)
+        fmpz_poly_init(self.g)
+        fmpz_poly_init(self.ff)
+        fmpz_poly_init(self.gg)
+
+    def __dealloc__(self):
+        # clear flint polys
+        fmpz_poly_clear(self.f)
+        fmpz_poly_clear(self.g)
+        fmpz_poly_clear(self.ff)
+        fmpz_poly_clear(self.gg)
+
+    cdef int apply_to_monomial_flint(self, fmpz_poly_t ans, int i, int j,
+                                     int a, int b, int c, int d) except -1:
+        if i < 0 or j - i < 0:
+            raise ValueError("i (=%s) and j-i (=%s) must both be nonnegative." % (i, j - i))
+
+        # f = b+a*x, g = d+c*x
+        fmpz_poly_set_coeff_si(self.f, 0, b)
+        fmpz_poly_set_coeff_si(self.f, 1, a)
+        fmpz_poly_set_coeff_si(self.g, 0, d)
+        fmpz_poly_set_coeff_si(self.g, 1, c)
+
+        # h = (f**i)*(g**(j-i))
+        fmpz_poly_pow(self.ff, self.f, i)
+        fmpz_poly_pow(self.gg, self.g, j - i)
+        fmpz_poly_mul(ans, self.ff, self.gg)
+
+        return 0
+
+
+cdef Apply A = Apply()
+
+
+def apply_to_monomial(int i, int j, int a, int b, int c, int d):
+    r"""
+    Return a list of the coefficients of
+
+    .. MATH::
+
+        (aX + bY)^i (cX + dY)^{j-i},
+
+    where `0 \leq i \leq j`, and `a`, `b`, `c`, `d` are integers.
+
+    One should think of `j` as being `k-2` for the application to
+    modular symbols.
+
+    INPUT:
+
+    - i, j, a, b, c, d -- all ints
+
+    OUTPUT:
+
+    list of ints, which are the coefficients
+    of `Y^j, Y^{j-1}X, \ldots, X^j`, respectively.
+
+    EXAMPLES:
+
+    We compute that `(X+Y)^2(X-Y) = X^3 + X^2Y - XY^2 - Y^3`::
+
+        sage: from sage.modular.modsym.apply import apply_to_monomial
+        sage: apply_to_monomial(2, 3, 1,1,1,-1)
+        [-1, -1, 1, 1]
+        sage: apply_to_monomial(5, 8, 1,2,3,4)
+        [2048, 9728, 20096, 23584, 17200, 7984, 2304, 378, 27]
+        sage: apply_to_monomial(6,12, 1,1,1,-1)
+        [1, 0, -6, 0, 15, 0, -20, 0, 15, 0, -6, 0, 1]
+    """
+    cdef fmpz_poly_t pr
+    fmpz_poly_init(pr)
+
+    A.apply_to_monomial_flint(pr, i, j, a, b, c, d)
+
+    cdef Integer res
+    v = []
+    for k in range(j + 1):
+        res = <Integer>PY_NEW(Integer)
+        fmpz_poly_get_coeff_mpz(res.value, pr, k)
+        v.append(int(res))
+
+    fmpz_poly_clear(pr)
+    return v