Begin adding fmpz_mod_poly

setup.py

@@ -95,6 +95,7 @@
     ("flint.types.acb_series", ["src/flint/types/acb_series.pyx"]),
     ("flint.types.fmpz_mpoly", ["src/flint/types/fmpz_mpoly.pyx"]),
     ("flint.types.fmpz_mod", ["src/flint/types/fmpz_mod.pyx"]),
+    ("flint.types.fmpz_mod_poly", ["src/flint/types/fmpz_mod_poly.pyx"]),
     ("flint.types.dirichlet", ["src/flint/types/dirichlet.pyx"]),
     ("flint.flint_base.flint_base", ["src/flint/flint_base/flint_base.pyx"]),
     ("flint.flint_base.flint_context", ["src/flint/flint_base/flint_context.pyx"]),

src/flint/__init__.py

@@ -22,6 +22,7 @@
 from .types.acb_series import *
 from .types.fmpz_mpoly import *
 from .types.fmpz_mod import *
+from .types.fmpz_mod_poly import *
 from .types.dirichlet import *
 from .functions.showgood import showgood
 

src/flint/flintlib/fmpz_mod_poly_factor.pxd

@@ -0,0 +1,46 @@
+from flint.flintlib.flint cimport fmpz_struct, slong, flint_rand_t
+from flint.flintlib.fmpz cimport fmpz_t
+from flint.flintlib.fmpz_mod cimport fmpz_mod_ctx_t
+from flint.flintlib.fmpz_factor cimport fmpz_factor_t
+from flint.flintlib.fmpz_mod_poly cimport fmpz_mod_poly_struct, fmpz_mod_poly_t
+
+# unimported types  {'fmpz_mod_poly_factor_t', 'void', 'fmpz_mod_poly_t'}
+
+cdef extern from "flint/fmpz_mod_poly_factor.h":
+    ctypedef struct fmpz_mod_poly_factor_struct:
+        fmpz_mod_poly_struct * poly
+        slong *exp
+        slong num
+        slong alloc
+    ctypedef fmpz_mod_poly_factor_struct fmpz_mod_poly_factor_t[1]
+
+    # Parsed from here
+    void fmpz_mod_poly_factor_init(fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_clear(fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_realloc(fmpz_mod_poly_factor_t fac, slong alloc, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_fit_length(fmpz_mod_poly_factor_t fac, slong len, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_set(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_print(const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_insert(fmpz_mod_poly_factor_t fac, const fmpz_mod_poly_t poly, slong exp, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_concat(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_pow(fmpz_mod_poly_factor_t fac, slong exp, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_irreducible(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_irreducible_ddf(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_irreducible_rabin(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_irreducible_rabin_f(fmpz_t r, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int _fmpz_mod_poly_is_squarefree(const fmpz_struct * f, slong len, const fmpz_mod_ctx_t ctx)
+    int _fmpz_mod_poly_is_squarefree_f(fmpz_t fac, const fmpz_struct * f, slong len, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_squarefree(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_is_squarefree_f(fmpz_t fac, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_factor_equal_deg_prob(fmpz_mod_poly_t factor, flint_rand_t state, const fmpz_mod_poly_t pol, slong d, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_equal_deg(fmpz_mod_poly_factor_t factors, const fmpz_mod_poly_t pol, slong d, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_distinct_deg(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, slong * const *degs, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_distinct_deg_threaded(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, slong * const *degs, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_squarefree(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_cantor_zassenhaus(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_kaltofen_shoup(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx)
+    void fmpz_mod_poly_factor_berlekamp(fmpz_mod_poly_factor_t factors, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx)
+    void _fmpz_mod_poly_interval_poly_worker(void* arg_ptr)
+    void fmpz_mod_poly_roots(fmpz_mod_poly_factor_t r, const fmpz_mod_poly_t f, int with_multiplicity, const fmpz_mod_ctx_t ctx)
+    int fmpz_mod_poly_roots_factored(fmpz_mod_poly_factor_t r, const fmpz_mod_poly_t f, int with_multiplicity, const fmpz_factor_t n, const fmpz_mod_ctx_t ctx)

src/flint/test/test.py

@@ -1591,10 +1591,17 @@ def test_fmpz_mod():
     p_med = 2**127 - 1
     p_big = 2**255 - 19
 
+    F_cmp = fmpz_mod_ctx(10)
     F_sml = fmpz_mod_ctx(p_sml)
     F_med = fmpz_mod_ctx(p_med)
     F_big = fmpz_mod_ctx(p_big)
 
+    assert F_sml.is_prime() is True
+    assert F_med.is_prime() is True
+    assert F_big.is_prime() is True
+    assert F_cmp.is_prime() is False
+
+
     # Context tests
     assert raises(lambda: fmpz_mod_ctx("AAA"), TypeError)
     assert raises(lambda: fmpz_mod_ctx(-1), ValueError)
@@ -1776,17 +1783,17 @@ def test_fmpz_mod_dlog():
     # Input modulus must be prime
     F = fmpz_mod_ctx(4)
     g, a = F(1), F(2)
-    assert raises(lambda: g.discrete_log(a, check=True), ValueError)
+    assert raises(lambda: g.discrete_log(a), NotImplementedError)
 
     # Moduli must match
     F1, F2 = fmpz_mod_ctx(2), fmpz_mod_ctx(3)
     g = F1(2)
     a = F2(4)
-    assert raises(lambda: g.discrete_log(a, check=True), ValueError)
+    assert raises(lambda: g.discrete_log(a), ValueError)
 
     # Need to use either fmpz_mod or something which can be case to
     # fmpz
-    assert raises(lambda: g.discrete_log("A", check=True), TypeError)
+    assert raises(lambda: g.discrete_log("A"), TypeError)
 
     F = fmpz_mod_ctx(163)
     g = F(2)
@@ -1813,6 +1820,85 @@ def test_fmpz_mod_dlog():
             x = g.discrete_log(a)
             assert g**x == a
 
+def test_fmpz_mod_poly():
+    from flint import fmpz_poly, fmpz_mod_poly_ctx, fmpz_mod_ctx, fmpz
+
+    # fmpz_mod_poly_ctx tests
+    F = fmpz_mod_ctx(11)
+    R1 = fmpz_mod_poly_ctx(F)
+    R2 = fmpz_mod_poly_ctx(11)
+    R3 = fmpz_mod_poly_ctx(13)
+
+    assert raises(lambda: fmpz_mod_ctx("AAA"), TypeError)
+    assert raises(lambda: fmpz_mod_ctx(-1), ValueError)
+    assert (R1 == R1) is True
+    assert (R1 == R2) is True
+    assert (R1 != R3) is True
+    assert (R1 != "AAA") is True
+
+    assert (hash(R1) == hash(R1)) is True
+    assert (hash(R1) == hash(R2)) is True
+    assert (hash(R1) != hash(R3)) is True
+
+    assert str(R1) == "Context for fmpz_mod_poly with modulus: 11"
+    assert str(R1) == str(R2)
+    assert repr(R3) == "fmpz_mod_poly_ctx(13)"
+
+    assert R1.modulus() == 11
+    assert R1([0,1]) == R1.gen()
+
+    # Conversion tests
+    F = fmpz_mod_ctx(11)
+    R = fmpz_mod_poly_ctx(F)
+
+    f1 = R([int(-1),int(-2),int(-3)])
+    f2 = R([fmpz(-1),fmpz(-2),fmpz(-3)])
+    f3 = R([F(-1),F(-2),F(-3)])
+    f4 = R(fmpz_poly([-1, -2, -3]))
+
+    assert str(f1) == "8*x^2 + 9*x + 10"
+    assert str(f2) == "8*x^2 + 9*x + 10"
+    assert str(f3) == "8*x^2 + 9*x + 10"
+    assert str(f4) == "8*x^2 + 9*x + 10"
+
+    f1 = R(5)
+    f2 = R(fmpz(6))
+    f3 = R(F(7))
+    assert str(f1) == "5"
+    assert str(f2) == "6"
+    assert str(f3) == "7"
+
+    # Printing
+    f = R([5, 6, 7, 8])
+    assert str(f) == "8*x^3 + 7*x^2 + 6*x + 5"
+    # assert repr(f) == "fmpz_mod_poly([5, 6, 7, 8], fmpz_mod_poly_ctx(11))"
+
+    # Get and Set tests
+    f = R([5, 6, 7, 8])
+    assert f[0] == 5
+    assert repr(f[0]) == "fmpz_mod(5, 11)"
+    f[0] = 7
+    assert repr(f[0]) == "fmpz_mod(7, 11)"
+    assert str(f) == "8*x^3 + 7*x^2 + 6*x + 7"
+
+    # Comparisons
+    f1 = R([1,2,3])
+    f2 = R([12,13,14])
+    f3 = R([4,5,6])
+    f4 = R([3])
+
+    assert (f1 == f2) is True
+    assert (f1 != f3) is True
+    assert (f1 != "1") is True
+    assert (f4 == 3) is True
+
+    f1 = R([0])
+    f2 = R([1])
+    f3 = R([0, 1])
+
+    assert f1.is_zero() is True
+    assert f2.is_one() is True
+    assert f3.is_gen() is True
 
 
 all_tests = [
@@ -1834,5 +1920,6 @@ def test_fmpz_mod_dlog():
     test_nmod_mat,
     test_arb,
     test_fmpz_mod,
-    test_fmpz_mod_dlog
+    test_fmpz_mod_dlog,
+    test_fmpz_mod_poly
 ]

src/flint/types/fmpz_mod.pxd

@@ -8,6 +8,7 @@ from flint.flintlib.fmpz_mod cimport (
 
 cdef class fmpz_mod_ctx:
     cdef fmpz_mod_ctx_t val
+    cdef bint _is_prime
     cdef fmpz_mod_discrete_log_pohlig_hellman_t *L
     cdef any_as_fmpz_mod(self, obj)
     cdef _precompute_dlog_prime(self)

src/flint/types/fmpz_mod.pyx

@@ -1,6 +1,8 @@
+from flint.pyflint cimport global_random_state
 from flint.flintlib.fmpz cimport(
     fmpz_t,
     fmpz_one,
+    fmpz_zero,
     fmpz_set,
     fmpz_init,
     fmpz_clear,
@@ -10,7 +12,8 @@ from flint.flintlib.fmpz cimport(
     fmpz_invmod,
     fmpz_divexact,
     fmpz_gcd,
-    fmpz_is_one
+    fmpz_is_one,
+    fmpz_randm
 )
 from flint.flintlib.fmpz cimport fmpz_mod as fmpz_type_mod
 from flint.flintlib.fmpz_mod cimport *
@@ -39,6 +42,7 @@ cdef class fmpz_mod_ctx:
         fmpz_one(one.val)
         fmpz_mod_ctx_init(self.val, one.val)
         self.L = NULL
+        self._is_prime = 0
 
 
     def __dealloc__(self):
@@ -52,7 +56,7 @@ cdef class fmpz_mod_ctx:
             mod = any_as_fmpz(mod)
             if mod is NotImplemented:
                 raise TypeError(
-                    "Context modulus must be able to be case to an `fmpz` type"
+                    "Context modulus must be able to be cast to an `fmpz` type"
                 )
 
         # Ensure modulus is positive
@@ -62,6 +66,10 @@ cdef class fmpz_mod_ctx:
         # Set the modulus
         fmpz_mod_ctx_set_modulus(self.val, (<fmpz>mod).val)
 
+        # Check whether the modulus is prime
+        # TODO: should we use a stronger test?
+        self._is_prime = fmpz_is_probabprime(self.val.n)
+
     def modulus(self):
         """
         Return the modulus from the context as an fmpz
@@ -76,6 +84,59 @@ cdef class fmpz_mod_ctx:
         fmpz_set(n.val, (<fmpz_t>self.val.n))
         return n
 
+    def is_prime(self):
+        """
+        Return whether the modulus is prime
+
+            >>> fmpz_mod_ctx(2**127).is_prime()
+            False
+            >>> fmpz_mod_ctx(2**127 - 1).is_prime()
+            True
+        """
+        return self._is_prime == 1
+
+    def zero(self):
+        """
+        Return the zero element
+
+            >>> F = fmpz_mod_ctx(163)
+            >>> F.zero()
+            fmpz_mod(0, 163)
+        """
+        cdef fmpz_mod res 
+        res = fmpz_mod.__new__(fmpz_mod)
+        fmpz_zero(res.val)
+        res.ctx = self
+
+        return res
+
+    def one(self):
+        """
+        Return the one element
+
+            >>> F = fmpz_mod_ctx(163)
+            >>> F.one()
+            fmpz_mod(1, 163)
+        """
+        cdef fmpz_mod res 
+        res = fmpz_mod.__new__(fmpz_mod)
+        fmpz_one(res.val)
+        res.ctx = self
+
+        return res
+
+    def random_element(self):
+        r"""
+        Return a random element in :math:`\mathbb{Z}/N\mathbb{Z}`
+        """
+        cdef fmpz_mod res
+        res = fmpz_mod.__new__(fmpz_mod)
+        res.ctx = self
+
+        fmpz_randm(res.val, global_random_state, self.val.n)
+
+        return res
+
     cdef _precompute_dlog_prime(self):
         """
         Initalise the dlog data, all discrete logs are solved with an 
@@ -126,7 +187,7 @@ cdef class fmpz_mod_ctx:
         # If they're not the same object in memory, they may have the
         # same modulus, which is good enough
         if typecheck(other, fmpz_mod_ctx):
-            return fmpz_equal(self.val.n, (<fmpz_mod_ctx>other).val.n)
+            return fmpz_equal(self.val.n, (<fmpz_mod_ctx>other).val.n) == 1
         return False
 
     def __hash__(self):
@@ -252,7 +313,7 @@ cdef class fmpz_mod(flint_scalar):
 
         return res
 
-    def discrete_log(self, a, check=False):
+    def discrete_log(self, a):
         """
         Solve the discrete logarithm problem, using `self = g` as a base.
         Assumes a solution, :math:`a = g^x \pmod p` exists.
@@ -269,10 +330,8 @@ cdef class fmpz_mod(flint_scalar):
         cdef bint is_prime
 
         # Ensure that the modulus is prime
-        if check:
-            is_prime = fmpz_is_probabprime(self.ctx.val.n)
-            if not is_prime:
-                raise ValueError("modulus must be prime")
+        if not self.ctx.is_prime():
+            raise NotImplementedError("algorithm assumes modulus is prime")
 
         # Then check the type of the input
         if typecheck(a, fmpz_mod):
@@ -345,7 +404,7 @@ cdef class fmpz_mod(flint_scalar):
         if not typecheck(other, fmpz_mod):
             other = self.ctx.any_as_fmpz_mod(other)
 
-        if typecheck(self, fmpz_mod) and typecheck(other, fmpz_mod):
+        if typecheck(other, fmpz_mod):
             res = fmpz_equal(self.val, (<fmpz_mod>other).val) and \
                   (self.ctx == (<fmpz_mod>other).ctx)
             if op == 2:

src/flint/types/fmpz_mod_poly.pxd

@@ -0,0 +1,17 @@
+from flint.flintlib.fmpz_mod_poly cimport *
+
+from flint.flint_base.flint_base cimport flint_poly
+from flint.types.fmpz_mod cimport fmpz_mod_ctx
+
+
+cdef class fmpz_mod_poly_ctx:
+    cdef fmpz_mod_ctx mod
+    cdef any_as_fmpz_mod_poly(self, obj)
+    cdef set_any_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, obj)
+    cdef set_list_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, val)
+
+cdef class fmpz_mod_poly(flint_poly):
+    cdef fmpz_mod_poly_t val
+    cdef fmpz_mod_poly_ctx ctx
+    cpdef long length(self)
+    cpdef long degree(self)