passagemath-ntl 10.6.36__cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

sage/libs/ntl/ntl_lzz_p.pxd

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-ntl
+from sage.libs.ntl.lzz_p cimport *
+from sage.libs.ntl.ntl_lzz_pContext cimport ntl_zz_pContext_class
+
+cdef class ntl_zz_p():
+    cdef zz_p_c x
+    cdef ntl_zz_pContext_class c
+    cdef ntl_zz_p _new(ntl_zz_p self)

sage/libs/ntl/ntl_lzz_p.pyx

@@ -0,0 +1,440 @@
+# sage_setup: distribution = sagemath-ntl
+# distutils: libraries = NTL_LIBRARIES gmp M_LIBRARIES
+# 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++
+"""
+ntl_lzz_p.pyx
+
+Wraps NTL's zz_p type for Sage
+
+NOTE: This file is essentially useless. While we provide
+this wrapper for consistency, this should never be used in
+*production* code, i.e. anything intended to be fast. The
+reason for this is simple: this is a wrapper for a Python
+interface to the zz_p type, which is just a long! Any speed
+gains you get from working with longs will be TOTALLY
+destroyed by the overhead of having a wrapper.
+
+AUTHORS:
+
+- Craig Citro
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+# 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_on, sig_off
+
+include 'misc.pxi'
+include 'decl.pxi'
+from sage.libs.gmp.mpz cimport *
+
+from cpython.object cimport Py_EQ, Py_NE
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import IntegerRing
+from sage.rings.integer cimport Integer
+
+from sage.rings.finite_rings.integer_mod cimport IntegerMod_gmp, IntegerMod_int, IntegerMod_int64
+
+from sage.libs.ntl.ntl_lzz_pContext import ntl_zz_pContext
+from sage.libs.ntl.ntl_lzz_pContext cimport ntl_zz_pContext_class
+from sage.arith.power cimport generic_power_pos
+
+ZZ_sage = IntegerRing()
+
+##############################################################################
+#
+# zz_pX  -- polynomials over the integers modulo p, p small
+#
+##############################################################################
+
+cdef class ntl_zz_p():
+    r"""
+    The class \class{zz_p} implements arithmetic modulo `p`,
+    for p smaller than a machine word.
+
+    NOTE: This type is provided mostly for completeness, and
+    shouldn't be used in any production code.
+    """
+    # See ntl_zz_p.pxd for definition of data members
+    def __init__(self, a=0, modulus=None):
+        """
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(5,7)
+            sage: f
+            5
+            sage: g = ntl.zz_p(int(-5),7)
+            sage: g
+            2
+        """
+        if modulus is None:
+            raise ValueError("You must specify a modulus.")
+
+        if isinstance(modulus, Integer):
+            p_sage = modulus
+        else:
+            p_sage = Integer(self.c.p)
+
+        #self.c.restore_c()   ## This was done in __new__
+
+        if isinstance(a, IntegerMod_int):
+            if (self.c.p == (<IntegerMod_int>a)._modulus.int32): ## this is slow
+                self.x = (<IntegerMod_int>a).ivalue
+            else:
+                raise ValueError("Mismatched modulus for converting to zz_p.")
+
+        elif isinstance(a, IntegerMod_int64):
+            if (self.c.p == (<IntegerMod_int64>a)._modulus.int64): ## this is slow
+                self.x = (<IntegerMod_int64>a).ivalue
+            else:
+                raise ValueError("Mismatched modulus for converting to zz_p.")
+
+        elif isinstance(a, IntegerMod_gmp):
+            if (p_sage == (<IntegerMod_gmp>a)._modulus.sageInteger): ## this is slow
+                self.x = mpz_get_si((<IntegerMod_gmp>a).value)
+            else:
+                raise ValueError("Mismatched modulus for converting to zz_p.")
+
+        elif isinstance(a, Integer):
+            self.x = mpz_get_si((<Integer>a).value) % self.c.p
+
+        elif isinstance(a, int):
+            ## we're lucky that python int is no larger than long
+            self.x = (<long>a) % self.c.p
+        else:
+            a = Integer(a)
+            self.x = mpz_get_si((<Integer>a).value) % self.c.p
+
+        return
+
+    def __cinit__(self, v=None, modulus=None):
+        #################### WARNING ###################
+        ## Before creating a zz_p, you must create a  ##
+        ## zz_pContext, and restore it.  In Python,   ##
+        ## the error checking in __init__ will prevent##
+        ## you from constructing a zz_p               ##
+        ## inappropriately.  However, from Cython, you##
+        ## could do r = ntl_zz_p.__new__(ntl_zz_p) without
+        ## first restoring a zz_pContext, which could ##
+        ## have unfortunate consequences.  See _new  ##
+        ## defined below for an example of the right  ##
+        ## way to short-circuit __init__ (or just call##
+        ## _new in your own code).                    ##
+        ################################################
+        if modulus is None:
+            return
+        if isinstance(modulus, ntl_zz_pContext_class):
+            self.c = <ntl_zz_pContext_class>modulus
+        elif isinstance(modulus, Integer):
+            self.c = <ntl_zz_pContext_class>ntl_zz_pContext(modulus)
+        elif isinstance(modulus, int):
+            self.c = <ntl_zz_pContext_class>ntl_zz_pContext(modulus)
+        else:
+            try:
+                modulus = int(modulus)
+            except Exception:
+                raise ValueError("%s is not a valid modulus." % modulus)
+            self.c = <ntl_zz_pContext_class>ntl_zz_pContext(modulus)
+
+        ## now that we've determined the modulus, set that modulus.
+        self.c.restore_c()
+
+    cdef ntl_zz_p _new(self):
+        """
+        Quick and dirty zz_p object creation.
+
+        EXAMPLES::
+
+            sage: x = ntl.zz_p(23,75)
+            sage: y = x*x ## indirect doctest
+        """
+        cdef ntl_zz_p y
+        self.c.restore_c()
+        y = ntl_zz_p.__new__(ntl_zz_p)
+        y.c = self.c
+        return y
+
+    def __reduce__(self):
+        """
+        For pickling.
+
+        TESTS::
+
+            sage: f = ntl.zz_p(16,244)
+            sage: loads(dumps(f)) == f
+            True
+        """
+        return make_zz_p, (zz_p_rep(self.x), self.c)
+
+    def __repr__(self):
+        """
+        Return the string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: ntl.zz_p(3,79).__repr__()
+            '3'
+        """
+        return repr(Integer(zz_p_rep(self.x)))
+
+    def __add__(ntl_zz_p self, other):
+        """
+        EXAMPLES::
+
+            sage: ntl.zz_p(5,23) + ntl.zz_p(6,23)
+            11
+        """
+        cdef ntl_zz_p y
+        if not isinstance(other, ntl_zz_p):
+            other = ntl_zz_p(other, modulus=self.c)
+        elif self.c is not (<ntl_zz_p>other).c:
+            raise ValueError("arithmetic operands must have the same modulus.")
+        self.c.restore_c()
+        y = self._new()
+        zz_p_add(y.x, self.x, (<ntl_zz_p>other).x)
+        return y
+
+    def __sub__(ntl_zz_p self, other):
+        """
+        EXAMPLES::
+
+            sage: ntl.zz_p(5,23) - ntl.zz_p(6,23)
+            22
+        """
+        cdef ntl_zz_p y
+        if not isinstance(other, ntl_zz_p):
+            other = ntl_zz_p(other, modulus=self.c)
+        elif self.c is not (<ntl_zz_p>other).c:
+            raise ValueError("arithmetic operands must have the same modulus.")
+        self.c.restore_c()
+        y = self._new()
+        zz_p_sub(y.x, self.x, (<ntl_zz_p>other).x)
+        return y
+
+    def __mul__(ntl_zz_p self, other):
+        """
+        EXAMPLES::
+
+            sage: ntl.zz_p(5,23) * ntl.zz_p(6,23)
+            7
+        """
+        cdef ntl_zz_p y
+        if not isinstance(other, ntl_zz_p):
+            other = ntl_zz_p(other, modulus=self.c)
+        elif self.c is not (<ntl_zz_p>other).c:
+            raise ValueError("arithmetic operands must have the same modulus.")
+        y = self._new()
+        self.c.restore_c()
+        zz_p_mul(y.x, self.x, (<ntl_zz_p>other).x)
+        return y
+
+    def __truediv__(ntl_zz_p self, other):
+        """
+        EXAMPLES::
+
+            sage: ntl.zz_p(5,23) / ntl.zz_p(2,23)
+            14
+        """
+        cdef ntl_zz_p q
+        if not isinstance(other, ntl_zz_p):
+            other = ntl_zz_p(other, modulus=self.c)
+        elif self.c is not (<ntl_zz_p>other).c:
+            raise ValueError("arithmetic operands must have the same modulus.")
+        q = self._new()
+        self.c.restore_c()
+        sig_on()
+        zz_p_div(q.x, self.x, (<ntl_zz_p>other).x)
+        sig_off()
+        return q
+
+    def __pow__(ntl_zz_p self, long n, ignored):
+        """
+        Return the `n`-th nonnegative power of ``self``.
+
+        EXAMPLES::
+
+            sage: g = ntl.zz_p(5, 13)
+            sage: g ^ 10
+            12
+            sage: g ^ (-1)
+            8
+            sage: g ^ (-5)
+            8
+            sage: g ^ 0
+            1
+            sage: z = ntl.zz_p(0, 13)
+            sage: z ^ 0
+            1
+            sage: z ^ 1
+            0
+            sage: z ^ (-1)
+            Traceback (most recent call last):
+            ...
+            ZeroDivisionError: inverse does not exist
+        """
+        self.c.restore_c()
+        if n == 0:
+            return ntl_zz_p(1, self.c)
+
+        if self.is_zero():
+            if n > 0:
+                return self
+            raise ZeroDivisionError("inverse does not exist")
+
+        cdef ntl_zz_p y
+        if n > 0:
+            return generic_power_pos(self, <unsigned long>n)
+        else:
+            y = ntl_zz_p.__new__(ntl_zz_p)
+            y.c = self.c
+            zz_p_inv(y.x, self.x)
+            return generic_power_pos(y, -<unsigned long>n)
+
+    def __neg__(self):
+        """
+        Return the negative of ``self``.
+
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(5,234)
+            sage: -f ## indirect doctest
+            229
+        """
+        cdef ntl_zz_p y
+        y = self._new()
+        self.c.restore_c()
+        zz_p_negate(y.x, self.x)
+        return y
+
+    def __richcmp__(ntl_zz_p self, other, int op):
+        """
+        Compare ``self`` to ``other``.
+
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(3,20)
+            sage: g = ntl.zz_p(2,20)
+            sage: h = ntl.zz_p(3,60)
+            sage: f == g
+            False
+            sage: f == f
+            True
+            sage: f == h
+            True
+            sage: f == 3
+            True
+        """
+        self.c.restore_c()
+
+        if op != Py_EQ and op != Py_NE:
+            raise TypeError("integers mod p are not ordered")
+
+        cdef ntl_zz_p b
+        try:
+            b = <ntl_zz_p?>other
+        except TypeError:
+            b = ntl_zz_p(other, self.c)
+
+        return (op == Py_EQ) == (self.x == b.x)
+
+    def __int__(self):
+        """
+        Return ``self`` as an int.
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.pari
+            sage: ntl.zz_p(3, next_prime(100)).__int__()
+            3
+            sage: int(ntl.zz_p(3, next_prime(100)))
+            3
+            sage: type(int(ntl.zz_p(3, next_prime(100))))
+            <... 'int'>
+        """
+        return zz_p_rep(self.x)
+
+    def square(self):
+        """
+        Return f*f.
+
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(15,23)
+            sage: f*f
+            18
+        """
+        cdef ntl_zz_p y
+        y = self._new()
+        self.c.restore_c()
+        zz_p_sqr(y.x, self.x)
+        return y
+
+    def is_zero(self):
+        """
+        Return ``True`` exactly if this element is 0.
+
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(0,20)
+            sage: f.is_zero()
+            True
+            sage: f = ntl.zz_p(1,20)
+            sage: f.is_zero()
+            False
+        """
+        self.c.restore_c()
+        return zz_p_rep(self.x) == 0
+
+    def is_one(self):
+        """
+        Return ``True`` exactly if this element is 1.
+
+        EXAMPLES::
+
+            sage: f = ntl.zz_p(1,11)
+            sage: f.is_one()
+            True
+            sage: f = ntl.zz_p(5,11)
+            sage: f.is_one()
+            False
+        """
+        self.c.restore_c()
+        return zz_p_rep(self.x) == 1
+
+    def clear(self):
+        """
+        Reset this element to 0.
+
+        EXAMPLES::
+
+            sage: x = ntl.zz_p(5,102) ; x
+            5
+            sage: x.clear() ; x
+            0
+        """
+        self.c.restore_c()
+        zz_p_clear(self.x)
+
+
+def make_zz_p(val, context):
+    """
+    For unpickling.
+
+    TESTS::
+
+        sage: f = ntl.zz_p(1, 12)
+        sage: loads(dumps(f)) == f
+        True
+    """
+    return ntl_zz_p(val, context)

sage/libs/ntl/ntl_lzz_pContext.pxd

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-ntl
+from sage.libs.ntl.types cimport zz_pContext_c
+
+cdef class ntl_zz_pContext_class():
+    cdef zz_pContext_c x
+    cdef void restore_c(self) noexcept
+    cdef long p

sage/libs/ntl/ntl_lzz_pContext.pyx

@@ -0,0 +1,137 @@
+# sage_setup: distribution = sagemath-ntl
+# distutils: libraries = NTL_LIBRARIES gmp M_LIBRARIES
+# 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++
+
+#*****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+# 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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.libs.gmp.mpz cimport mpz_get_si
+include 'misc.pxi'
+include 'decl.pxi'
+
+from sage.rings.integer cimport Integer
+
+zz_pContextDict = {}
+
+cdef class ntl_zz_pContext_class():
+    def __init__(self, long v):
+        """
+        EXAMPLES::
+
+            # You can construct contexts manually.
+            sage: c = ntl.zz_pContext(11)
+            sage: n1 = ntl.zz_p(12,c)
+            sage: n1
+            1
+
+            # or You can construct contexts implicitly.
+            sage: n2=ntl.zz_p(12, 7)
+            sage: n2
+            5
+            sage: ntl.zz_p(2,3)+ntl.zz_p(1,3)
+            0
+            sage: n2+n1  # Mismatched moduli:  It will go BOOM!
+            Traceback (most recent call last):
+            ...
+            ValueError: arithmetic operands must have the same modulus.
+        """
+        pass
+
+    def __cinit__(self, long v):
+        if v > NTL_SP_BOUND:
+            raise ValueError("Modulus (=%s) is too big" % v)
+        elif v < 2:
+            # Issue 13940: only moduli greater than one are supported.
+            raise ValueError("Modulus (=%s) is too small" % v)
+
+        self.x = zz_pContext_c(v)
+        zz_pContextDict[repr(v)] = self
+        self.p = v
+
+    def __reduce__(self):
+        """
+        EXAMPLES::
+
+            sage: c=ntl.zz_pContext(13)
+            sage: loads(dumps(c)) is c
+            True
+        """
+        return ntl_zz_pContext, (self.p,)
+
+    def modulus(self):
+        """
+        Print the modulus for ``self``.
+
+        EXAMPLES::
+
+            sage: c1 = ntl.zz_pContext(36)
+            sage: c1.modulus()
+            36
+        """
+        return self.p
+
+    def restore(self):
+        """
+        Restore a zz_pContext.
+
+        EXAMPLES::
+
+            sage: c = ntl.zz_pContext(5)
+            sage: m = ntl.zz_p(4,7)
+            sage: c.restore()
+        """
+        self.restore_c()
+
+    cdef void restore_c(self) noexcept:
+        """
+        Actual code for the above.
+
+        EXAMPLES::
+
+            sage: n = ntl.zz_p(3,5)
+            sage: m = ntl.zz_p(4,7)
+            sage: n*n ## indirect doctest
+            4
+        """
+        self.x.restore()
+
+
+def ntl_zz_pContext( v ):
+    """
+    Creation function for a zz_p context.
+
+    EXAMPLES::
+
+        sage: f = ntl.zz_pContext(26)
+        sage: f = ntl.zz_pContext(10^100)
+        Traceback (most recent call last):
+        ...
+        ValueError: Modulus (=10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) is too big
+        sage: f = ntl.zz_pContext(1)
+        Traceback (most recent call last):
+        ...
+        ValueError: Modulus (=1) is too small
+        sage: f = ntl.zz_pContext(0)
+        Traceback (most recent call last):
+        ...
+        ValueError: Modulus (=0) is too small
+    """
+    if v > NTL_SP_BOUND:
+        raise ValueError("Modulus (=%s) is too big" % v)
+    if isinstance(v, Integer):
+        v = mpz_get_si((<Integer>v).value)
+    try:
+        return zz_pContextDict[repr(v)]
+    except KeyError:
+        return ntl_zz_pContext_class(v)

sage/libs/ntl/ntl_lzz_pX.pxd

@@ -0,0 +1,10 @@
+# sage_setup: distribution = sagemath-ntl
+from sage.libs.ntl.lzz_p cimport *
+from sage.libs.ntl.lzz_pX cimport *
+
+from sage.libs.ntl.ntl_lzz_pContext cimport ntl_zz_pContext_class
+
+cdef class ntl_zz_pX():
+    cdef zz_pX_c x
+    cdef ntl_zz_pContext_class c
+    cdef ntl_zz_pX _new(self)