Full coverage of nmod_poly and various fixes.

Author: oscarbenjamin

src/flint/test/test_all.py

@@ -1113,17 +1113,27 @@ def set_bad(i):
     raises(lambda: Q(1,2,[3,4]) * Q(1,3,[5,6,7]), ValueError)
     raises(lambda: Q(1,2,[3,4]) * Z(1,3,[5,6,7]), ValueError)
     raises(lambda: Z(1,2,[3,4]) * Q(1,3,[5,6,7]), ValueError)
+
     A = Q([[3,4],[5,7]]) / 11
     X = Q([[1,2],[3,4]])
     B = A*X
     assert A.solve(B) == X
     for algorithm in None, "fflu", "dixon":
         assert A.solve(B, algorithm=algorithm) == X
+    for _ in range(2):
+        A = Q(flint.fmpz_mat.randtest(30, 30, 10))
+        if A.det() == 0:
+            continue
+        B = Q(flint.fmpz_mat.randtest(30, 1, 10))
+        X = A.solve(B)
+        assert A*X == B
+
     assert raises(lambda: A.solve(B, algorithm="invalid"), ValueError)
     assert raises(lambda: A.solve(None), TypeError)
     assert raises(lambda: A.solve([1,2]), TypeError)
     assert raises(lambda: A.solve(Q([[1,2]])), ValueError)
     assert raises(lambda: Q([[1,2],[2,4]]).solve(Q([[1],[2]])), ZeroDivisionError)
+
     M = Q([[1,2,3],[flint.fmpq(1,2),5,6]])
     Mcopy = Q(M)
     Mrref = Q([[1,0,flint.fmpq(3,4)],[0,1,flint.fmpq(9,8)]])
@@ -1466,16 +1476,24 @@ def set_bad2():
     assert raises(set_bad2, TypeError)
     assert bool(P([], 5)) is False
     assert bool(P([1], 5)) is True
+
     assert P([1,2,1],3).gcd(P([1,1],3)) == P([1,1],3)
-    raises(lambda: P([1,2],3).gcd([]), TypeError)
-    raises(lambda: P([1,2],3).gcd(P([1,2],5)), ValueError)
+    assert raises(lambda: P([1,2],3).gcd([]), TypeError)
+    assert raises(lambda: P([1,2],3).gcd(P([1,2],5)), ValueError)
+    assert P([1,2,1],3).xgcd(P([1,1],3)) == (P([1, 1], 3), P([0], 3), P([1], 3))
+    assert raises(lambda: P([1,2],3).xgcd([]), TypeError)
+    assert raises(lambda: P([1,2],3).xgcd(P([1,2],5)), ValueError)
+    assert raises(lambda: P([1,2],6).xgcd(P([1,2],6)), DomainError)
+
     p3 = P([1,2,3,4,5,6],7)
     f3 = (N(6,7), [(P([6, 1],7), 5)])
     assert p3.factor() == f3
     # XXX: factor ignores an invalid algorithm string
     for alg in [None, 'berlekamp', 'cantor-zassenhaus']:
         assert p3.factor(alg) == f3
         assert p3.factor(algorithm=alg) == f3
+    assert raises(lambda: p3.factor(algorithm="invalid"), ValueError)
+
     assert P([1], 11).roots() == []
     assert P([1, 2, 3], 11).roots() == [(8, 1), (6, 1)]
     assert P([1, 6, 1, 8], 11).roots() == [(5, 3)]
@@ -1608,6 +1626,33 @@ def test_nmod_series():
     # XXX: currently no code in nmod_series.pyx
     pass
 
+
+def test_nmod_contexts():
+    # XXX: Generalise this test to cover fmpz_mod, fq_default, etc.
+    C = flint.nmod_ctx
+    CP = flint.nmod_poly_ctx
+    G = flint.nmod
+    P = flint.nmod_poly
+
+    for c, name in [(C, 'nmod'), (CP, 'nmod_poly')]:
+        ctx = c.new(17)
+        assert ctx.modulus() == 17
+        assert str(ctx) == f"Context for {name} with modulus: 17"
+        assert repr(ctx) == f"{name}_ctx(17)"
+        assert raises(lambda: c(3), TypeError)
+        assert raises(lambda: ctx.new(3.0), TypeError)
+
+    ctx = C.new(17)
+    assert ctx(3) == G(3,17) == G(3, ctx)
+    assert raises(lambda: ctx(3.0), TypeError)
+    assert raises(lambda: G(3, []), TypeError)
+
+    ctx_poly = CP.new(17)
+    assert ctx_poly([1,2,3]) == P([1,2,3],17) == P([1,2,3], ctx_poly)
+    assert raises(lambda: ctx_poly([1,2.0,3]), TypeError)
+    assert raises(lambda: P([1,2,3], []), TypeError)
+
+
 def test_arb():
     A = flint.arb
     assert A(3) > A(2.5)
@@ -2211,7 +2256,7 @@ def test_fmpz_mod_poly():
 
         f_inv = f.inverse_series_trunc(2)
         assert (f * f_inv) % R_test([0,0,1]) == 1
-        assert raises(lambda: R_cmp([0,0,1]).inverse_series_trunc(2), ValueError)
+        assert raises(lambda: R_cmp([0,0,1]).inverse_series_trunc(2), ZeroDivisionError)
 
         # Resultant
         f1 = R_test([-3, 1])
@@ -2846,6 +2891,50 @@ def setbad(obj, i, val):
         if type(p) == flint.fq_default_poly:
             assert raises(lambda: p.integral(), NotImplementedError)
 
+        if characteristic == 0:
+            assert not hasattr(P(0), "inverse_series_trunc")
+        elif composite_characteristic:
+            x = P([0, 1])
+            if type(x) is flint.fmpz_mod_poly:
+                assert (1 + x).inverse_series_trunc(4) == 1 - x + x**2 - x**3
+                if characteristic.gcd(3) != 1:
+                    assert (3 + x).inverse_series_trunc(4) == 1 - x + x**2 - x**3
+                else:
+                    assert (3 + x).inverse_series_trunc(4)\
+                            == S(1)/3 - S(1)/9*x + S(1)/27*x**2 - S(1)/81*x**3
+            elif type(x) is flint.nmod_poly:
+                assert raises(lambda: (1 + x).inverse_series_trunc(4), DomainError)
+            else:
+                assert False
+        else:
+            x = P([0, 1])
+            assert (1 + x).inverse_series_trunc(4) == 1 - x + x**2 - x**3
+            assert (3 + x).inverse_series_trunc(4)\
+                            == S(1)/3 - S(1)/9*x + S(1)/27*x**2 - S(1)/81*x**3
+            assert raises(lambda: (1 + x).inverse_series_trunc(-1), ValueError)
+            assert raises(lambda: x.inverse_series_trunc(4), ZeroDivisionError)
+
+        if characteristic == 0:
+            assert not hasattr(P(0), "pow_mod")
+        elif composite_characteristic:
+            pass
+        else:
+            x = P([0, 1])
+            assert (1 + x).pow_mod(4, x**2 + 1) == -4
+            assert (3 + x).pow_mod(4, x**2 + 1) == 96*x + 28
+            assert x.pow_mod(4, x**2 + 1) == 1
+
+            assert x.pow_mod(2**127, x - 1) == 1
+            assert (1 + x).pow_mod(2**127, x - 1) == pow(2, 2**127, characteristic)
+
+            if type(x) is not flint.fq_default_poly:
+                assert (1 + x).pow_mod(2**127, x - 1, S(1)/2) == pow(2, 2**127, characteristic)
+                assert raises(lambda: (1 + x).pow_mod(2**127, x - 1, []), TypeError)
+
+            assert raises(lambda: (1 + x).pow_mod(4, []), TypeError)
+            assert raises(lambda: (1 + x).pow_mod([], x), TypeError)
+            assert raises(lambda: (1 + x).pow_mod(-1, x), ValueError)
+
 
 def _all_mpolys():
     return [
@@ -3989,6 +4078,8 @@ def test_matrices_pow():
             # XXX: Allow unimodular matrices?
             assert raises(lambda: M1234**-1, DomainError)
 
+        assert raises(lambda: pow(M1234, 2, 3), NotImplementedError)
+
         Mr = M([[1, 2, 3], [4, 5, 6]])
         assert raises(lambda: Mr**0, ValueError)
         assert raises(lambda: Mr**1, ValueError)
@@ -4552,6 +4643,8 @@ def test_all_tests():
     test_nmod_mat,
     test_nmod_series,
 
+    test_nmod_contexts,
+
     test_fmpz_mod,
     test_fmpz_mod_dlog,
     test_fmpz_mod_poly,

src/flint/types/fmpq_mat.pyx

@@ -99,9 +99,6 @@ cdef class fmpq_mat(flint_mat):
         cdef bint r
         if op != 2 and op != 3:
             raise TypeError("matrices cannot be ordered")
-        s = any_as_fmpq_mat(s)
-        if t is NotImplemented:
-            return s
         t = any_as_fmpq_mat(t)
         if t is NotImplemented:
             return t
@@ -270,9 +267,6 @@ cdef class fmpq_mat(flint_mat):
     def __truediv__(s, t):
         return fmpq_mat._div_(s, t)
 
-    def __div__(s, t):
-        return fmpq_mat._div_(s, t)
-
     def inv(self):
         """
         Returns the inverse matrix of *self*.
@@ -491,7 +485,7 @@ cdef class fmpq_mat(flint_mat):
         if self.nrows() != self.ncols():
             raise ValueError("matrix must be square")
         if z is not None:
-            raise TypeError("fmpq_mat does not support modular exponentiation")
+            raise NotImplementedError("fmpq_mat does not support modular exponentiation")
 
         n = int(n)
         if n == 0:

src/flint/types/fmpz_mod_mat.pyx

@@ -481,8 +481,10 @@ cdef class fmpz_mod_mat(flint_mat):
             return self._scalarmul(e)
         return NotImplemented
 
-    def __pow__(self, other):
+    def __pow__(self, other, m=None):
         """``M ** n``: Raise a matrix to an integer power."""
+        if m is not None:
+            raise NotImplementedError("fmpz_mod_mat pow: modulo not supported")
         if not isinstance(other, int):
             return NotImplemented
         return self._pow(other)

src/flint/types/fmpz_mod_poly.pyx

@@ -1434,17 +1434,27 @@ cdef class fmpz_mod_poly(flint_poly):
         """
         cdef fmpz_t f
         cdef fmpz_mod_poly res
+        cdef bint is_one
+
+        if n < 1:
+            raise ValueError(f"{n = } must be positive")
+
+        if self.constant_coefficient() == 0:
+            raise ZeroDivisionError("fmpz_mod_poly inverse_series_trunc: zero constant term")
 
         res = self.ctx.new_ctype_poly()
         fmpz_init(f)
         fmpz_mod_poly_inv_series_f(
             f, res.val, self.val, n, res.ctx.mod.val
         )
-        if not fmpz_is_one(f):
-            fmpz_clear(f)
+        is_one = fmpz_is_one(f)
+        fmpz_clear(f)
+
+        if not is_one:
             raise ValueError(
                 f"Cannot compute inverse series of {self} modulo x^{n}"
             )
+
         return res
 
     def resultant(self, other):

src/flint/types/fq_default_poly.pyx

@@ -1242,6 +1242,9 @@ cdef class fq_default_poly(flint_poly):
         cdef fmpz_t f
         cdef fq_default_poly res
 
+        if n < 1:
+            raise ValueError(f"{n = } must be positive")
+
         if self.constant_coefficient().is_zero():
             raise ZeroDivisionError("constant coefficient must be invertible")
 

src/flint/types/nmod.pxd

@@ -11,11 +11,11 @@ cdef class nmod_ctx:
     cdef bint _is_prime
 
     @staticmethod
-    cdef any_as_nmod_ctx(obj)
+    cdef nmod_ctx any_as_nmod_ctx(obj)
     @staticmethod
-    cdef _get_ctx(int mod)
+    cdef nmod_ctx _get_ctx(int mod)
     @staticmethod
-    cdef _new_ctx(ulong mod)
+    cdef nmod_ctx _new_ctx(ulong mod)
 
     @cython.final
     cdef int any_as_nmod(self, mp_limb_t * val, obj) except -1

src/flint/types/nmod.pyx

@@ -46,27 +46,27 @@ cdef class nmod_ctx:
     @staticmethod
     def new(mod):
         """Get an nmod context with modulus ``mod``."""
-        return nmod_ctx._get_ctx(mod)
+        return nmod_ctx.any_as_nmod_ctx(mod)
 
     @staticmethod
-    cdef any_as_nmod_ctx(obj):
+    cdef nmod_ctx any_as_nmod_ctx(obj):
         """Convert an ``nmod_ctx`` or ``int`` to an ``nmod_ctx``."""
         if typecheck(obj, nmod_ctx):
             return obj
         if typecheck(obj, int):
             return nmod_ctx._get_ctx(obj)
-        return NotImplemented
+        raise TypeError("Invalid context/modulus for nmod: %s" % obj)
 
     @staticmethod
-    cdef _get_ctx(int mod):
+    cdef nmod_ctx _get_ctx(int mod):
         """Retrieve an nmod context from the cache or create a new one."""
         ctx = _nmod_ctx_cache.get(mod)
         if ctx is None:
             ctx = _nmod_ctx_cache.setdefault(mod, nmod_ctx._new_ctx(mod))
         return ctx
 
     @staticmethod
-    cdef _new_ctx(ulong mod):
+    cdef nmod_ctx _new_ctx(ulong mod):
         """Create a new nmod context."""
         cdef nmod_ctx ctx = nmod_ctx.__new__(nmod_ctx)
         nmod_init(&ctx.mod, mod)
@@ -160,7 +160,8 @@ cdef class nmod_ctx:
 
         """
         r = self.new_nmod()
-        self.any_as_nmod(&r.val, val)
+        if not self.any_as_nmod(&r.val, val):
+            raise TypeError("cannot create nmod from object of type %s" % type(val))
         return r
 
 
@@ -174,11 +175,7 @@ cdef class nmod(flint_scalar):
 
     """
     def __init__(self, val, mod):
-        cdef nmod_ctx ctx
-        c = nmod_ctx.any_as_nmod_ctx(mod)
-        if c is NotImplemented:
-            raise TypeError("Invalid context/modulus for nmod: %s" % mod)
-        ctx = c
+        cdef nmod_ctx ctx = nmod_ctx.any_as_nmod_ctx(mod)
         if not ctx.any_as_nmod(&self.val, val):
             raise TypeError("cannot create nmod from object of type %s" % type(val))
         self.ctx = ctx

src/flint/types/nmod_poly.pxd

@@ -16,7 +16,7 @@ cdef class nmod_poly_ctx:
     cdef nmod_ctx scalar_ctx
 
     @staticmethod
-    cdef any_as_nmod_poly_ctx(obj)
+    cdef nmod_poly_ctx any_as_nmod_poly_ctx(obj)
     @staticmethod
     cdef nmod_poly_ctx _get_ctx(int mod)
     @staticmethod