passagemath-ntl 10.6.38__cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

sage/matrix/matrix_modn_dense_template_header.pxi

@@ -0,0 +1,15 @@
+# sage_setup: distribution = sagemath-ntl
+"""
+Dense Matrix Template for C/C++ Library Interfaces
+"""
+
+from sage.ext.mod_int cimport *
+from sage.matrix.matrix_dense cimport Matrix_dense
+
+cdef class Matrix_modn_dense_template(Matrix_dense):
+    cdef celement **_matrix
+    cdef celement *_entries
+    cdef mod_int p
+    cdef xgcd_eliminate (self, celement * row1, celement* row2, Py_ssize_t start_col)
+    cpdef _export_as_string(self)
+    cdef int _copy_row_to_mod_int_array(self, mod_int *to, Py_ssize_t i) noexcept

sage/matrix/matrix_modn_sparse.pxd

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-ntl
+from sage.matrix.matrix_sparse cimport Matrix_sparse
+from sage.modules.vector_modn_sparse cimport *
+
+cdef class Matrix_modn_sparse(Matrix_sparse):
+    cdef c_vector_modint* rows
+    cdef public int p
+    cdef swap_rows_c(self, Py_ssize_t n1, Py_ssize_t n2)

sage/misc/all__sagemath_ntl.py

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

sage/rings/all__sagemath_ntl.py

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-ntl
+
+from sage.rings.all__sagemath_categories import *
+
+from sage.rings.padics.all__sagemath_ntl import *
+
+from sage.rings.bernoulli_mod_p import bernoulli_mod_p, bernoulli_mod_p_single

sage/rings/bernmm.pyx

@@ -0,0 +1,161 @@
+# sage_setup: distribution = sagemath-ntl
+# distutils: sources = sage/rings/bernmm/bern_modp.cpp sage/rings/bernmm/bern_modp_util.cpp sage/rings/bernmm/bern_rat.cpp
+# distutils: libraries = NTL_LIBRARIES pthread gmp
+# distutils: extra_compile_args = NTL_CFLAGS
+# distutils: include_dirs = NTL_INCDIR
+# distutils: library_dirs = NTL_LIBDIR
+# distutils: extra_link_args = NTL_LIBEXTRA
+# distutils: depends = sage/rings/bernmm/bern_modp.h sage/rings/bernmm/bern_modp_util.h sage/rings/bernmm/bern_rat.h
+# distutils: language = c++
+# distutils: define_macros = USE_THREADS=1 THREAD_STACK_SIZE=4096
+
+r"""
+Cython wrapper for bernmm library
+
+AUTHOR:
+
+- David Harvey (2008-06): initial version
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2008 William Stein <wstein@gmail.com>
+#                     2008 David Harvey <dmharvey@math.harvard.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from cysignals.signals cimport sig_on, sig_off
+
+from sage.libs.gmp.types cimport mpq_t
+
+
+cdef extern from "bernmm/bern_rat.h":
+    void bern_rat "bernmm::bern_rat" (mpq_t res, long k, int num_threads)
+
+cdef extern from "bernmm/bern_modp.h":
+    long bern_modp "bernmm::bern_modp" (long p, long k)
+
+
+from sage.rings.rational cimport Rational
+
+
+def bernmm_bern_rat(long k, int num_threads=1):
+    r"""
+    Compute `k`-th Bernoulli number using a multimodular algorithm.
+    (Wrapper for bernmm library.)
+
+    INPUT:
+
+    - ``k`` -- nonnegative integer
+    - ``num_threads`` -- integer `\geq 1`, number of threads to use
+
+    COMPLEXITY:
+
+    Pretty much quadratic in `k`. See the paper "A multimodular algorithm
+    for computing Bernoulli numbers", David Harvey, 2008, for more details.
+
+    EXAMPLES::
+
+        sage: from sage.rings.bernmm import bernmm_bern_rat
+
+        sage: bernmm_bern_rat(0)
+        1
+        sage: bernmm_bern_rat(1)
+        -1/2
+        sage: bernmm_bern_rat(2)
+        1/6
+        sage: bernmm_bern_rat(3)
+        0
+        sage: bernmm_bern_rat(100)
+        -94598037819122125295227433069493721872702841533066936133385696204311395415197247711/33330
+        sage: bernmm_bern_rat(100, 3)
+        -94598037819122125295227433069493721872702841533066936133385696204311395415197247711/33330
+
+    TESTS::
+
+        sage: lst1 = [ bernoulli(2*k, algorithm='bernmm', num_threads=2) for k in [2932, 2957, 3443, 3962, 3973] ]
+        sage: lst2 = [ bernoulli(2*k, algorithm='pari') for k in [2932, 2957, 3443, 3962, 3973] ]   # needs sage.libs.pari
+        sage: lst1 == lst2                                                                          # needs sage.libs.pari
+        True
+        sage: [ Zmod(101)(t) for t in lst1 ]
+        [77, 72, 89, 98, 86]
+        sage: [ Zmod(101)(t) for t in lst2 ]                                                        # needs sage.libs.pari
+        [77, 72, 89, 98, 86]
+    """
+    cdef Rational x
+
+    if k < 0:
+        raise ValueError("k must be nonnegative")
+
+    x = Rational()
+    sig_on()
+    bern_rat(x.value, k, num_threads)
+    sig_off()
+
+    return x
+
+
+def bernmm_bern_modp(long p, long k):
+    r"""
+    Compute `B_k \mod p`, where `B_k` is the `k`-th Bernoulli number.
+
+    If `B_k` is not `p`-integral, return `-1`.
+
+    INPUT:
+
+    - ``p`` -- a prime
+    - ``k`` -- nonnegative integer
+
+    COMPLEXITY:
+
+    Pretty much linear in `p`.
+
+    EXAMPLES::
+
+        sage: from sage.rings.bernmm import bernmm_bern_modp
+
+        sage: # needs sage.libs.flint
+        sage: bernoulli(0) % 5, bernmm_bern_modp(5, 0)
+        (1, 1)
+        sage: bernoulli(1) % 5, bernmm_bern_modp(5, 1)
+        (2, 2)
+        sage: bernoulli(2) % 5, bernmm_bern_modp(5, 2)
+        (1, 1)
+        sage: bernoulli(3) % 5, bernmm_bern_modp(5, 3)
+        (0, 0)
+        sage: bernoulli(4), bernmm_bern_modp(5, 4)
+        (-1/30, -1)
+        sage: bernoulli(18) % 5, bernmm_bern_modp(5, 18)
+        (4, 4)
+        sage: bernoulli(19) % 5, bernmm_bern_modp(5, 19)
+        (0, 0)
+
+        sage: p = 10000019; k = 1000
+        sage: bernoulli(k) % p                                                          # needs sage.libs.flint
+        1972762
+        sage: bernmm_bern_modp(p, k)
+        1972762
+
+    TESTS:
+
+    Check that bernmm works with the new NTL single precision modular
+    arithmetic from :issue:`19874`::
+
+        sage: from sage.rings.bernmm import bernmm_bern_modp
+        sage: bernmm_bern_modp(7, 128) == bernoulli(128) % 7                            # needs sage.libs.flint
+        True
+    """
+    cdef long x
+
+    if k < 0:
+        raise ValueError("k must be nonnegative")
+
+    sig_on()
+    x = bern_modp(p, k)
+    sig_off()
+
+    return x
+
+
+# ============ end of file

sage/rings/bernoulli_mod_p.pyx

@@ -0,0 +1,313 @@
+# sage_setup: distribution = sagemath-ntl
+# distutils: libraries = NTL_LIBRARIES gmp
+# distutils: extra_compile_args = NTL_CFLAGS
+# distutils: include_dirs = NTL_INCDIR
+# distutils: library_dirs = NTL_LIBDIR
+# distutils: extra_link_args = NTL_LIBEXTRA
+# distutils: language = c++
+# sage.doctest: needs sage.libs.pari
+r"""
+Bernoulli numbers modulo p
+
+AUTHOR:
+
+- David Harvey (2006-07-26): initial version
+- William Stein (2006-07-28): some touch up.
+- David Harvey (2006-08-06): new, faster algorithm, also using faster NTL interface
+- David Harvey (2007-08-31): algorithm for a single Bernoulli number mod p
+- David Harvey (2008-06): added interface to bernmm, removed old code
+"""
+# ****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#                     2006 David Harvey <dmharvey@math.harvard.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.arith.misc import is_prime, primitive_root
+
+cimport sage.rings.fast_arith
+import sage.rings.fast_arith
+cdef sage.rings.fast_arith.arith_int arith_int
+arith_int = sage.rings.fast_arith.arith_int()
+
+ctypedef long long llong
+
+import sage.arith.all
+
+from sage.libs.ntl import all as ntl
+from sage.libs.ntl.ntl_ZZ_pX cimport ntl_ZZ_pX
+from sage.rings.bernmm import bernmm_bern_modp
+
+
+def verify_bernoulli_mod_p(data):
+    r"""
+    Compute checksum for Bernoulli numbers.
+
+    It checks the identity
+
+    .. MATH::
+
+        \sum_{n=0}^{(p-3)/2} 2^{2n} (2n+1) B_{2n}  \equiv  -2 \pmod p
+
+    (see "Irregular Primes to One Million", Buhler et al)
+
+    INPUT:
+
+    - ``data`` -- list; same format as output of :func:`bernoulli_mod_p` function
+
+    OUTPUT: boolean; ``True`` if checksum passed
+
+    EXAMPLES::
+
+        sage: from sage.rings.bernoulli_mod_p import verify_bernoulli_mod_p
+        sage: verify_bernoulli_mod_p(bernoulli_mod_p(next_prime(3)))
+        True
+        sage: verify_bernoulli_mod_p(bernoulli_mod_p(next_prime(1000)))
+        True
+        sage: verify_bernoulli_mod_p([1, 2, 4, 5, 4])
+        True
+        sage: verify_bernoulli_mod_p([1, 2, 3, 4, 5])
+        False
+
+    This one should test that long longs are working::
+
+        sage: verify_bernoulli_mod_p(bernoulli_mod_p(next_prime(20000)))
+        True
+
+    AUTHOR: David Harvey
+    """
+
+    cdef int N, p, i, product, sum, value, element
+    N = len(data)
+    p = N*2 + 1
+    product = 1
+    sum = 0
+    for i from 0 <= i < N:
+        element = data[i]
+        value = <int> (((((<llong> product) * (2*i+1)) % p) * element) % p)
+        sum = (sum + value) % p
+        product = (4 * product) % p
+
+    if (sum + 2) % p == 0:
+        return True
+    else:
+        return False
+
+
+def bernoulli_mod_p(int p):
+    r"""
+    Return the Bernoulli numbers `B_0, B_2, ... B_{p-3}` modulo `p`.
+
+    INPUT:
+
+    - ``p`` -- integer; a prime
+
+    OUTPUT:
+
+    list -- Bernoulli numbers modulo `p` as a list
+    of integers [B(0), B(2), ... B(p-3)].
+
+    ALGORITHM:
+
+    Described in accompanying latex file.
+
+    PERFORMANCE:
+
+    Should be complexity `O(p \log p)`.
+
+    EXAMPLES:
+
+    Check the results against PARI's C-library implementation (that
+    computes exact rationals) for `p = 37`::
+
+        sage: bernoulli_mod_p(37)
+        [1, 31, 16, 15, 16, 4, 17, 32, 22, 31, 15, 15, 17, 12, 29, 2, 0, 2]
+        sage: [bernoulli(n) % 37 for n in range(0, 36, 2)]
+        [1, 31, 16, 15, 16, 4, 17, 32, 22, 31, 15, 15, 17, 12, 29, 2, 0, 2]
+
+    Boundary case::
+
+        sage: bernoulli_mod_p(3)
+         [1]
+
+    AUTHOR:
+
+    - David Harvey (2006-08-06)
+    """
+    if p <= 2:
+        raise ValueError("p (=%s) must be a prime >= 3" % p)
+
+    if not is_prime(p):
+        raise ValueError("p (=%s) must be a prime" % p)
+
+    cdef int g, gSqr, gInv, gInvSqr, isOdd
+
+    g = primitive_root(p)
+    gInv = arith_int.c_inverse_mod_int(g, p)
+    gSqr = ((<llong> g) * g) % p
+    gInvSqr = ((<llong> gInv) * gInv) % p
+    isOdd = ((p-1)/2) % 2
+
+    # STEP 1: compute the polynomials G(X) and J(X)
+
+    # These hold g^{i-1} and g^{-i} at the beginning of each iteration
+    cdef llong gPower, gPowerInv
+    gPower = gInv
+    gPowerInv = 1
+
+    # "constant" is (g-1)/2 mod p
+    cdef int constant
+    if g % 2:
+        constant = (g-1)/2
+    else:
+        constant = (g+p-1)/2
+
+    # fudge holds g^{i^2}, fudgeInv holds g^{-i^2}
+    cdef int fudge, fudgeInv
+    fudge = fudgeInv = 1
+
+    cdef ntl_ZZ_pX G, J
+    G = ntl.ZZ_pX([], ntl.ZZ(p))
+    J = ntl.ZZ_pX([], ntl.ZZ(p))
+    G.preallocate_space((p-1)/2)
+    J.preallocate_space((p-1)/2)
+
+    cdef int i
+    cdef llong temp, h
+    for i from 0 <= i < (p-1)/2:
+        # compute h = h(g^i)/g^i  (h(x) is as in latex notes)
+        temp = g * gPower
+        h = ((p + constant - (temp / p)) * gPowerInv) % p
+        gPower = temp % p
+        gPowerInv = (gPowerInv * gInv) % p
+
+        # store the coefficient  g^{i^2} h(g^i)/g^i
+        G.setitem_from_int(i, <int> ((h * fudge) % p))
+
+        # store the coefficient  g^{-i^2}
+        J.setitem_from_int(i, fudgeInv)
+
+        # update fudge and fudgeInv
+        fudge = (((fudge * gPower) % p) * ((gPower * g) % p)) % p
+        fudgeInv = (((fudgeInv * gPowerInv) % p) * ((gPowerInv * g) % p)) % p
+
+    J.setitem_from_int(0, 0)
+
+    # STEP 2: multiply the polynomials
+
+    cdef ntl_ZZ_pX product
+    product = G * J
+
+    # STEP 3: assemble the result
+
+    cdef int gSqrPower, value
+    output = [1]
+    gSqrPower = gSqr
+    fudge = g
+    for i from 1 <= i < (p-1)/2:
+        value = product.getitem_as_int(i + (p-1)/2)
+
+        if isOdd:
+            value = (G.getitem_as_int(i) + product.getitem_as_int(i) - value + p) % p
+        else:
+            value = (G.getitem_as_int(i) + product.getitem_as_int(i) + value) % p
+
+        value = (((4 * i * (<llong> fudge)) % p) * (<llong> value)) % p
+        value = ((<llong> value) * (arith_int.c_inverse_mod_int(1 - gSqrPower, p))) % p
+
+        output.append(value)
+
+        gSqrPower = ((<llong> gSqrPower) * g) % p
+        fudge = ((<llong> fudge) * gSqrPower) % p
+        gSqrPower = ((<llong> gSqrPower) * g) % p
+
+    return output
+
+
+def bernoulli_mod_p_single(long p, long k):
+    r"""
+    Return the Bernoulli number `B_k` mod `p`.
+
+    If `B_k` is not `p`-integral, an :exc:`ArithmeticError` is raised.
+
+    INPUT:
+
+    - ``p`` -- integer; a prime
+    - ``k`` -- nonnegative integer
+
+    OUTPUT: the `k`-th Bernoulli number mod `p`
+
+    EXAMPLES::
+
+        sage: bernoulli_mod_p_single(1009, 48)
+        628
+        sage: bernoulli(48) % 1009
+        628
+
+        sage: bernoulli_mod_p_single(1, 5)
+        Traceback (most recent call last):
+        ...
+        ValueError: p (=1) must be a prime >= 3
+
+        sage: bernoulli_mod_p_single(100, 4)
+        Traceback (most recent call last):
+        ...
+        ValueError: p (=100) must be a prime
+
+        sage: bernoulli_mod_p_single(19, 5)
+        0
+
+        sage: bernoulli_mod_p_single(19, 18)
+        Traceback (most recent call last):
+        ...
+        ArithmeticError: B_k is not integral at p
+
+        sage: bernoulli_mod_p_single(19, -4)
+        Traceback (most recent call last):
+        ...
+        ValueError: k must be nonnegative
+
+    Check results against :class:`bernoulli_mod_p`::
+
+        sage: bernoulli_mod_p(37)
+         [1, 31, 16, 15, 16, 4, 17, 32, 22, 31, 15, 15, 17, 12, 29, 2, 0, 2]
+        sage: [bernoulli_mod_p_single(37, n) % 37 for n in range(0, 36, 2)]
+         [1, 31, 16, 15, 16, 4, 17, 32, 22, 31, 15, 15, 17, 12, 29, 2, 0, 2]
+
+        sage: bernoulli_mod_p(31)
+         [1, 26, 1, 17, 1, 9, 11, 27, 14, 23, 13, 22, 14, 8, 14]
+        sage: [bernoulli_mod_p_single(31, n) % 31 for n in range(0, 30, 2)]
+         [1, 26, 1, 17, 1, 9, 11, 27, 14, 23, 13, 22, 14, 8, 14]
+
+        sage: bernoulli_mod_p(3)
+         [1]
+        sage: [bernoulli_mod_p_single(3, n) % 3 for n in range(0, 2, 2)]
+         [1]
+
+        sage: bernoulli_mod_p(5)
+         [1, 1]
+        sage: [bernoulli_mod_p_single(5, n) % 5 for n in range(0, 4, 2)]
+         [1, 1]
+
+        sage: bernoulli_mod_p(7)
+         [1, 6, 3]
+        sage: [bernoulli_mod_p_single(7, n) % 7 for n in range(0, 6, 2)]
+         [1, 6, 3]
+
+    AUTHOR:
+
+    - David Harvey (2007-08-31)
+    - David Harvey (2008-06): rewrote to use bernmm library
+    """
+    if p <= 2:
+        raise ValueError("p (=%s) must be a prime >= 3" % p)
+
+    if not is_prime(p):
+        raise ValueError("p (=%s) must be a prime" % p)
+
+    cdef long x = bernmm_bern_modp(p, k)
+    if x == -1:
+        raise ArithmeticError("B_k is not integral at p")
+    return x

sage/rings/finite_rings/all__sagemath_ntl.py

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