fmpz_mat uses exact division

Previously fmpz_mat / fmpz would give an fmpq_mat.

Now fmpz_mat / fmpz succeeds and returns fmpz_mat if the division is
exact and raises DomainError otherwise.

Author: oscarbenjamin

src/flint/test/test.py

@@ -547,7 +547,8 @@ def test_fmpz_mat():
     assert str(M(2,2,[1,2,3,4])) == '[1, 2]\n[3, 4]'
     assert M(1,2,[3,4]) * flint.fmpq(1,3) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
     assert flint.fmpq(1,3) * M(1,2,[3,4]) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
-    assert M(1,2,[3,4]) / 3 == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
+    assert raises(lambda: M(1,2,[3,4]) / 3, DomainError)
+    assert M(1,2,[2,4]) / 2 == M(1,2,[1,2])
     assert M(2,2,[1,2,3,4]).inv().det() == flint.fmpq(1) / M(2,2,[1,2,3,4]).det()
     assert M(2,2,[1,2,3,4]).inv().inv() == M(2,2,[1,2,3,4])
     assert raises(lambda: M.randrank(4,3,4,1), ValueError)
@@ -2318,6 +2319,44 @@ def test_division_scalar():
         assert raises(lambda: "AAA" / R(5), TypeError)
 
 
+def test_division_matrix():
+    Z = flint.fmpz
+    Q = flint.fmpq
+    F17 = lambda x: flint.nmod(x, 17)
+    ctx = flint.fmpz_mod_ctx(163)
+    F163 = lambda a: flint.fmpz_mod(a, ctx)
+    MZ = lambda x: flint.fmpz_mat(x)
+    MQ = lambda x: flint.fmpq_mat(x)
+    MF17 = lambda x: flint.nmod_mat(x, 17)
+    MF163 = lambda x: flint.fmpz_mod_mat(x, ctx)
+    # fmpz exact division
+    assert MZ([[2, 4]]) / Z(2) == MZ([[1, 2]])
+    assert MZ([[2, 4]]) / 2 == MZ([[1, 2]])
+    assert raises(lambda: MZ([[2, 5]]) / Z(2), DomainError)
+    assert raises(lambda: MZ([[2, 5]]) / 2, DomainError)
+    # field division by scalar
+    for (K, MK) in [(Q, MQ), (F17, MF17), (F163, MF163)]:
+        assert MK([[2, 5]]) / K(2) == MK([[K(2)/K(2), K(5)/K(2)]])
+        assert MK([[2, 5]]) / 2 == MK([[K(2)/K(2), K(5)/K(2)]])
+    # No other division is allowed
+    for (R, MR) in [(Z, MZ), (Q, MQ), (F17, MF17), (F163, MF163)]:
+        M = MR([[2, 5]])
+        for s in (2, R(2)):
+            assert raises(lambda: s / M, TypeError)
+            assert raises(lambda: M // s, TypeError)
+            assert raises(lambda: s // M, TypeError)
+            assert raises(lambda: M % s, TypeError)
+            assert raises(lambda: s % M, TypeError)
+            assert raises(lambda: divmod(s, M), TypeError)
+            assert raises(lambda: divmod(M, s), TypeError)
+        assert raises(lambda: M / M, TypeError)
+        assert raises(lambda: M // M, TypeError)
+        assert raises(lambda: M % M, TypeError)
+        assert raises(lambda: divmod(M, M), TypeError)
+        assert raises(lambda: M / 0, ZeroDivisionError)
+        assert raises(lambda: M / R(0), ZeroDivisionError)
+
+
 def _all_polys():
     return [
         # (poly_type, scalar_type, is_field)
@@ -3066,6 +3105,7 @@ def test_all_tests():
     test_fmpz_mod_mat,
 
     test_division_scalar,
+    test_division_matrix,
 
     test_polys,
 

src/flint/types/fmpz_mat.pyx

@@ -18,6 +18,9 @@ from flint.flintlib.fmpq_mat cimport fmpq_mat_init
 from flint.flintlib.fmpq_mat cimport fmpq_mat_set_fmpz_mat_div_fmpz
 from flint.flintlib.fmpq_mat cimport fmpq_mat_solve_fmpz_mat
 
+from flint.utils.flint_exceptions import DomainError
+
+
 cdef any_as_fmpz_mat(obj):
     if typecheck(obj, fmpz_mat):
         return obj
@@ -131,13 +134,10 @@ cdef class fmpz_mat(flint_mat):
     def __nonzero__(self):
         return not fmpz_mat_is_zero(self.val)
 
-    def __richcmp__(s, t, int op):
+    def __richcmp__(fmpz_mat s, t, int op):
         cdef bint r
         if op != 2 and op != 3:
             raise TypeError("matrices cannot be ordered")
-        s = any_as_fmpz_mat(s)
-        if t is NotImplemented:
-            return s
         t = any_as_fmpz_mat(t)
         if t is NotImplemented:
             return t
@@ -282,15 +282,22 @@ cdef class fmpz_mat(flint_mat):
             return fmpq_mat(s) * t
         return NotImplemented
 
-    @staticmethod
-    def _div_(fmpz_mat s, t):
-        return s * (1 / fmpq(t))
-
-    def __truediv__(s, t):
-        return fmpz_mat._div_(s, t)
-
-    def __div__(s, t):
-        return fmpz_mat._div_(s, t)
+    def __truediv__(fmpz_mat s, t):
+        cdef fmpz_mat u
+        cdef fmpz_mat_struct *sval
+        t = any_as_fmpz(t)
+        if t is NotImplemented:
+            return t
+        if fmpz_is_zero((<fmpz>t).val):
+            raise ZeroDivisionError("division by zero")
+        sval = &(<fmpz_mat>s).val[0]
+        u = fmpz_mat.__new__(fmpz_mat)
+        fmpz_mat_init(u.val, fmpz_mat_nrows(sval), fmpz_mat_ncols(sval))
+        fmpz_mat_scalar_divexact_fmpz(u.val, sval, (<fmpz>t).val)
+        # XXX: check for exact division - there should be a better way!
+        if u * t != s:
+            raise DomainError("fmpz_mat division is not exact")
+        return u
 
     def __pow__(self, e, m):
         cdef fmpz_mat t