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

sage/libs/ntl/ntl_ZZ_pEContext.pyx

@@ -0,0 +1,226 @@
+# 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>
+#
+#  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/
+#*****************************************************************************
+
+include 'misc.pxi'
+include 'decl.pxi'
+
+from sage.ext.cplusplus cimport ccrepr
+from sage.libs.ntl.ntl_ZZ_pX cimport ntl_ZZ_pX
+
+
+ZZ_pEContextDict = {}
+
+
+cdef class ntl_ZZ_pEContext_class():
+    def __init__(self, ntl_ZZ_pX f):
+        """
+        EXAMPLES:
+
+        You can construct contexts manually::
+
+            sage: c=ntl.ZZ_pEContext(ntl.ZZ_pX([4,1,6],25))
+            sage: n1=c.ZZ_pE([10,17,12])
+            sage: n1
+            [2 15]
+
+        Or you can construct contexts implicitly::
+
+            sage: n2=ntl.ZZ_pE(12, ntl.ZZ_pX([1,1,1],7))
+            sage: n2
+            [5]
+            sage: n2+n1  # Mismatched moduli:  It will go BOOM!
+            Traceback (most recent call last):
+            ...
+            ValueError: You cannot perform arithmetic with elements of different moduli.
+        """
+        pass
+
+    def __cinit__(self, ntl_ZZ_pX f):
+        self.pc = f.c
+        self.pc.restore_c()
+        self.x = ZZ_pEContext_c(f.x)
+        ZZ_pEContextDict[(repr(f), repr(f.c.p))] = self
+        self.f = f
+        self.ptrs.zzpc = &(self.pc.x)
+        self.ptrs.zzpec = &(self.x)
+
+    def __reduce__(self):
+        """
+        EXAMPLES::
+
+           sage: c=ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1],7))
+           sage: loads(dumps(c)) is c
+           True
+        """
+        return ntl_ZZ_pEContext, (self.f,)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7)); c
+            NTL modulus [1 1 1] (mod 7)
+        """
+        return "NTL modulus %s (mod %s)" % (self.f, self.pc.p)
+
+    def get_pc(self):
+        """
+        Return the ZZ_pContext contained within ``self``.
+
+        EXAMPLES::
+
+            sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7)); c
+            NTL modulus [1 1 1] (mod 7)
+            sage: c.get_pc()
+            NTL modulus 7
+        """
+        return self.pc
+
+    def polynomial(self):
+        """
+        Return the ZZ_pX polynomial defining ``self``.
+
+        EXAMPLES::
+
+            sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7))
+            sage: c.polynomial()
+            [1 1 1]
+        """
+        return self.f
+
+    def restore(self):
+        """
+        Manually set the global NTL modulus to be ``self``.
+
+        This should be done automatically by all of the NTL wrapper classes.
+
+        CRUCIAL: If you are writing your own classes that use ZZ_p_c, ZZ_pX_c, ZZ_pE_c, ZZ_pEX_c
+        then you MUST restore the context before calling off to NTL for anything.  If the context has been
+        switched by other code then behavior of operations is undefined.  See the NTL documentation for
+        more details (or the wrappers in sage.libs.ntl)
+        """
+        self.restore_c()
+
+    cdef void restore_c(self) noexcept:
+        """
+        Set the global NTL modulus to be ``self``.
+
+        CRUCIAL: If you are writing your own classes that use ZZ_p_c, ZZ_pX_c, ZZ_pE_c, ZZ_pEX_c
+        then you MUST restore the context before calling off to NTL for anything.  If the context has been
+        switched by other code then behavior of operations is undefined.  See the NTL documentation for
+        more details (or the wrappers in sage.libs.ntl)
+        """
+        self.pc.restore_c()
+        self.x.restore()
+
+    #def ZZ_pX(self, v=None):
+    #    from ntl_ZZ_pX import ntl_ZZ_pX
+    #    return ntl_ZZ_pX(v,modulus=self)
+
+    def ZZ_pE(self, v=None):
+        """
+        Return a ZZ_pE object with modulus ``self`` out of the data v.
+
+        EXAMPLES::
+
+            sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7))
+            sage: c.ZZ_pE([4,3])
+            [4 3]
+        """
+        from sage.libs.ntl.ntl_ZZ_pE import ntl_ZZ_pE
+        return ntl_ZZ_pE(v,modulus=self)
+
+    def ZZ_pEX(self, v=None):
+        """
+        Return a ZZ_pE object with modulus ``self`` out of the data v.
+
+        EXAMPLES::
+
+            sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7))
+            sage: c.ZZ_pEX([4,3])
+            [[4] [3]]
+        """
+        from sage.libs.ntl.ntl_ZZ_pEX import ntl_ZZ_pEX
+        return ntl_ZZ_pEX(v, modulus=self)
+
+    cpdef void _assert_is_current_modulus(self) except *:
+        """
+        Assert that this is currently-set NTL modulus.
+
+        Mostly for debugging purposes. If false, an assertion is raised. This method
+        segfaults if the NTL modulus has never been set before.
+
+        EXAMPLES::
+
+            sage: c1 = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 5))
+            sage: c2 = ntl.ZZ_pEContext(ntl.ZZ_pX([1,2,1], 5))
+            sage: c1.restore()
+            sage: c1._assert_is_current_modulus()
+            sage: c2._assert_is_current_modulus()
+            Traceback (most recent call last):
+            ...
+            AssertionError: modulus mismatch: [1 2 1] != [1 1 1]
+            sage: c2.restore()
+            sage: c1._assert_is_current_modulus()
+            Traceback (most recent call last):
+            ...
+            AssertionError: modulus mismatch: [1 1 1] != [1 2 1]
+            sage: c2._assert_is_current_modulus()
+            sage: ntl.ZZ_pContext(3).restore()
+            sage: c1._assert_is_current_modulus()
+            Traceback (most recent call last):
+            ...
+            AssertionError: modulus mismatch: 5 != 3
+            sage: c2._assert_is_current_modulus()
+            Traceback (most recent call last):
+            ...
+            AssertionError: modulus mismatch: 5 != 3
+        """
+        self.pc._assert_is_current_modulus()
+        if self.f.x == ZZ_pE_current_modulus().val():
+            return
+        raise AssertionError('modulus mismatch: {} != {}'.format(
+            ccrepr(self.f.x),
+            ccrepr(ZZ_pE_current_modulus().val())))
+
+
+def ntl_ZZ_pEContext( ntl_ZZ_pX f):
+    """
+    Create an ntl_ZZ_pEContext.
+
+    Such an object must be created before any ZZ_pE or ZZ_pEX objects can be used.
+
+    The context handling should be taken care of by the wrapper classes.
+
+    EXAMPLES::
+
+        sage: c = ntl.ZZ_pEContext(ntl.ZZ_pX([1,1,1], 7)); c
+        NTL modulus [1 1 1] (mod 7)
+    """
+    try:
+        return ZZ_pEContextDict[repr(f), repr(f.c.p)]
+    except KeyError:
+        # Creating the following object caches it.
+        return ntl_ZZ_pEContext_class(f)

sage/libs/ntl/ntl_ZZ_pEX.pxd

@@ -0,0 +1,10 @@
+# sage_setup: distribution = sagemath-ntl
+from sage.libs.ntl.types cimport ZZ_pEX_c
+from sage.libs.ntl.ntl_ZZ_pEContext cimport ntl_ZZ_pEContext_class
+
+cdef class ntl_ZZ_pEX():
+    cdef ZZ_pEX_c x
+    cdef ntl_ZZ_pEContext_class c
+    #cdef void setitem_from_int(ntl_ZZ_pX self, long i, int value)
+    #cdef int getitem_as_int(ntl_ZZ_pX self, long i)
+    cdef ntl_ZZ_pEX _new(self)