Move primality testing to constructor, create mod_mpoly_context class

Creates a subclass of flint_mpoly_context to hold mod_mpoly specific methods and abstractions

Author: Jake-Moss

src/flint/flint_base/flint_base.pxd

@@ -13,6 +13,9 @@ cdef class flint_mpoly_context(flint_elem):
     cdef public object py_names
     cdef const char ** c_names
 
+cdef class flint_mod_mpoly_context(flint_mpoly_context):
+    cdef readonly bint __prime_modulus
+
 cdef class flint_mpoly(flint_elem):
     cdef _add_scalar_(self, other)
     cdef _sub_scalar_(self, other)

src/flint/flint_base/flint_base.pyx

@@ -409,6 +409,51 @@ cdef class flint_mpoly_context(flint_elem):
             exp_vec = (0,) * self.nvars()
         return self.from_dict({tuple(exp_vec): coeff})
 
+cdef class flint_mod_mpoly_context(flint_mpoly_context):
+    def __init__(self, nvars, names, prime_modulus):
+        super().__init__(nvars, names)
+        self.__prime_modulus = <bint>prime_modulus
+
+    @classmethod
+    def create_context_key(
+            cls,
+            slong nvars=1,
+            ordering=Ordering.lex,
+            modulus = None,
+            names: Optional[str] = "x",
+            nametup: Optional[tuple] = None,
+    ):
+        """
+        Create a key for the context cache via the number of variables, the ordering, the modulus, and either a
+        variable name string, or a tuple of variable names.
+        """
+        # A type hint of ``ordering: Ordering`` results in the error "TypeError: an integer is required" if a Ordering
+        # object is not provided. This is pretty obtuse so we check its type ourselves
+        if not isinstance(ordering, Ordering):
+            raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
+
+        if nametup is not None:
+            key = nvars, ordering, nametup, modulus
+        elif nametup is None and names is not None:
+            key = nvars, ordering, cls.create_variable_names(nvars, names), modulus
+        else:
+            raise ValueError("must provide either 'names' or 'nametup'")
+        return key
+
+    def is_prime(self):
+        """
+        Return whether the modulus is prime
+
+            >>> from flint import Ordering, fmpz_mod_mpoly_ctx
+            >>> ctx = fmpz_mod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**127, 'z')
+            >>> ctx.is_prime()
+            False
+            >>> ctx = fmpz_mod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**127 - 1, 'z')
+            >>> ctx.is_prime()
+            True
+        """
+        return self.__prime_modulus
+
 
 cdef class flint_mpoly(flint_elem):
     """

src/flint/types/fmpz_mod_mpoly.pxd

@@ -1,4 +1,4 @@
-from flint.flint_base.flint_base cimport flint_mpoly, flint_mpoly_context
+from flint.flint_base.flint_base cimport flint_mpoly, flint_mod_mpoly_context
 
 from flint.flintlib.functions.fmpz_mod_mpoly cimport (
     fmpz_mod_mpoly_ctx_t,
@@ -21,9 +21,8 @@ cdef inline fmpz_mod_mpoly create_fmpz_mod_mpoly(fmpz_mod_mpoly_ctx ctx):
     var._init = True
     return var
 
-cdef class fmpz_mod_mpoly_ctx(flint_mpoly_context):
+cdef class fmpz_mod_mpoly_ctx(flint_mod_mpoly_context):
     cdef fmpz_mod_mpoly_ctx_t val
-    cdef readonly object __prime_modulus
 
 cdef class fmpz_mod_mpoly(flint_mpoly):
     cdef fmpz_mod_mpoly_t val

src/flint/types/fmpz_mod_mpoly.pyx

@@ -1,6 +1,6 @@
 from flint.flint_base.flint_base cimport (
     flint_mpoly,
-    flint_mpoly_context,
+    flint_mod_mpoly_context,
     ordering_py_to_c,
     ordering_c_to_py,
 )
@@ -76,7 +76,7 @@ cimport libc.stdlib
 cdef dict _fmpz_mod_mpoly_ctx_cache = {}
 
 
-cdef class fmpz_mod_mpoly_ctx(flint_mpoly_context):
+cdef class fmpz_mod_mpoly_ctx(flint_mod_mpoly_context):
     """
     A class for storing the polynomial context
 
@@ -97,60 +97,20 @@ cdef class fmpz_mod_mpoly_ctx(flint_mpoly_context):
                 raise TypeError(f"modulus ({modulus}) is not coercible to fmpz")
         else:
             m = modulus
-        fmpz_mod_mpoly_ctx_init(self.val, nvars, ordering_py_to_c(ordering), m.val)
-        self.__prime_modulus = None
-        super().__init__(nvars, names)
-
-    @classmethod
-    def create_context_key(
-            cls,
-            slong nvars=1,
-            ordering=Ordering.lex,
-            modulus = None,
-            names: Optional[str] = "x",
-            nametup: Optional[tuple] = None,
-    ):
-        """
-        Create a key for the context cache via the number of variables, the ordering, the modulus, and either a
-        variable name string, or a tuple of variable names.
-        """
-        # A type hint of ``ordering: Ordering`` results in the error "TypeError: an integer is required" if a Ordering
-        # object is not provided. This is pretty obtuse so we check its type ourselves
-        if not isinstance(ordering, Ordering):
-            raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
-        elif not typecheck(modulus, fmpz):
-            m = any_as_fmpz(modulus)
-            if m is NotImplemented:
-                raise TypeError(f"'modulus' ('{modulus}') is not coercible to fmpz")
-            else:
-                modulus = m
 
-        if nametup is not None:
-            key = nvars, ordering, nametup, modulus
-        elif nametup is None and names is not None:
-            key = nvars, ordering, cls.create_variable_names(nvars, names), modulus
-        else:
-            raise ValueError("must provide either 'names' or 'nametup'")
-        return key
+        super().__init__(nvars, names, m.is_prime())
+        fmpz_mod_mpoly_ctx_init(self.val, nvars, ordering_py_to_c(ordering), m.val)
 
     def _any_as_scalar(self, other):
         if isinstance(other, int):
             return any_as_fmpz(other)
         elif typecheck(other, nmod):
-            if (<nmod>other).modulus() != self.modulus():
-                raise DomainError(
-                    f"modulus does not match, got {(<nmod>other).modulus()}, expected {self.modulus()}"
-                )
             return any_as_fmpz((<nmod>other).val)
         elif typecheck(other, fmpz):
             res = fmpz.__new__(fmpz)
             fmpz_set((<fmpz>res).val, (<fmpz>other).val)
             return res
         elif typecheck(other, fmpz_mod):
-            if (<fmpz_mod>other).ctx.modulus() != self.modulus():
-                raise DomainError(
-                    f"modulus does not match, got {(<fmpz_mod>other).ctx.modulus()}, expected {self.modulus()}"
-                )
             res = fmpz.__new__(fmpz)
             fmpz_set((<fmpz>res).val, (<fmpz_mod>other).val)
             return res
@@ -197,22 +157,6 @@ cdef class fmpz_mod_mpoly_ctx(flint_mpoly_context):
         fmpz_mod_mpoly_ctx_get_modulus(m.val, self.val)
         return m
 
-    def is_prime(self):
-        """
-        Return whether the modulus is prime
-
-            >>> from flint import Ordering
-            >>> ctx = fmpz_mod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**127, 'z')
-            >>> ctx.is_prime()
-            False
-            >>> ctx = fmpz_mod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**127 - 1, 'z')
-            >>> ctx.is_prime()
-            True
-        """
-        if self.__prime_modulus is None:
-            self.__prime_modulus = <bint>self.modulus().is_prime()
-        return self.__prime_modulus
-
     def gen(self, slong i):
         """
         Return the ``i`` th generator of the polynomial ring

src/flint/types/nmod_mpoly.pxd

@@ -1,4 +1,4 @@
-from flint.flint_base.flint_base cimport flint_mpoly, flint_mpoly_context
+from flint.flint_base.flint_base cimport flint_mpoly, flint_mod_mpoly_context
 
 from flint.flintlib.functions.nmod_mpoly cimport (
     nmod_mpoly_ctx_t,
@@ -21,9 +21,8 @@ cdef inline nmod_mpoly create_nmod_mpoly(nmod_mpoly_ctx ctx):
     var._init = True
     return var
 
-cdef class nmod_mpoly_ctx(flint_mpoly_context):
+cdef class nmod_mpoly_ctx(flint_mod_mpoly_context):
     cdef nmod_mpoly_ctx_t val
-    cdef readonly object __prime_modulus
 
 cdef class nmod_mpoly(flint_mpoly):
     cdef nmod_mpoly_t val

src/flint/types/nmod_mpoly.pyx

@@ -1,6 +1,6 @@
 from flint.flint_base.flint_base cimport (
     flint_mpoly,
-    flint_mpoly_context,
+    flint_mod_mpoly_context,
     ordering_py_to_c,
     ordering_c_to_py,
 )
@@ -81,7 +81,7 @@ cimport libc.stdlib
 cdef dict _nmod_mpoly_ctx_cache = {}
 
 
-cdef class nmod_mpoly_ctx(flint_mpoly_context):
+cdef class nmod_mpoly_ctx(flint_mod_mpoly_context):
     """
     A class for storing the polynomial context
 
@@ -98,35 +98,8 @@ cdef class nmod_mpoly_ctx(flint_mpoly_context):
         if modulus <= 0:
             raise ValueError("modulus must be positive")
 
+        super().__init__(nvars, names, <bint>n_is_prime(modulus))
         nmod_mpoly_ctx_init(self.val, nvars, ordering_py_to_c(ordering), modulus)
-        self.__prime_modulus = None
-        super().__init__(nvars, names)
-
-    @classmethod
-    def create_context_key(
-            cls,
-            slong nvars=1,
-            ordering=Ordering.lex,
-            modulus = None,
-            names: Optional[str] = "x",
-            nametup: Optional[tuple] = None,
-    ):
-        """
-        Create a key for the context cache via the number of variables, the ordering, the modulus, and either a
-        variable name string, or a tuple of variable names.
-        """
-        # A type hint of ``ordering: Ordering`` results in the error "TypeError: an integer is required" if a Ordering
-        # object is not provided. This is pretty obtuse so we check its type ourselves
-        if not isinstance(ordering, Ordering):
-            raise TypeError(f"'ordering' ('{ordering}') is not an instance of flint.Ordering")
-
-        if nametup is not None:
-            key = nvars, ordering, nametup, modulus
-        elif nametup is None and names is not None:
-            key = nvars, ordering, cls.create_variable_names(nvars, names), modulus
-        else:
-            raise ValueError("must provide either 'names' or 'nametup'")
-        return key
 
     def _any_as_scalar(self, other):
         if isinstance(other, int):
@@ -135,18 +108,10 @@ cdef class nmod_mpoly_ctx(flint_mpoly_context):
             except OverflowError:
                 return <ulong>(other % self.modulus())
         elif typecheck(other, nmod):
-            if (<nmod>other).modulus() != self.modulus():
-                raise DomainError(
-                    f"modulus does not match, got {(<nmod>other).modulus()}, expected {self.modulus()}"
-                )
             return (<nmod>other).val
         elif typecheck(other, fmpz):
             return fmpz_get_nmod((<fmpz>other).val, self.val.mod)
         elif typecheck(other, fmpz_mod):
-            if (<fmpz_mod>other).ctx.modulus() != self.modulus():
-                raise DomainError(
-                    f"modulus does not match, got {(<fmpz_mod>other).ctx.modulus()}, expected {self.modulus()}"
-                )
             return fmpz_get_nmod((<fmpz_mod>other).val, self.val.mod)
         else:
             return NotImplemented
@@ -189,22 +154,6 @@ cdef class nmod_mpoly_ctx(flint_mpoly_context):
         """
         return nmod_mpoly_ctx_modulus(self.val)
 
-    def is_prime(self):
-        """
-        Return whether the modulus is prime
-
-            >>> from flint import Ordering
-            >>> ctx = nmod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**32, 'z')
-            >>> ctx.is_prime()
-            False
-            >>> ctx = nmod_mpoly_ctx.get_context(4, Ordering.degrevlex, 2**32 - 17, 'z')
-            >>> ctx.is_prime()
-            True
-        """
-        if self.__prime_modulus is None:
-            self.__prime_modulus = <bint>n_is_prime(self.modulus())
-        return self.__prime_modulus
-
     def gen(self, slong i):
         """
         Return the ``i`` th generator of the polynomial ring