Make in-place operators functions, and explict

Author: Jake-Moss

src/flint/test/test_all.py

@@ -2837,31 +2837,36 @@ def quick_poly():
         for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]:
             p = quick_poly()
             p += T(1)
+            q = quick_poly()
+            assert q.iadd(T(1)) is None
             assert quick_poly() + T(1) \
-                == p == mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4})
+                == p == q == mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4})
             assert T(1) + quick_poly() \
                 == mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4})
 
         assert raises(lambda: mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}) + None, TypeError)
         assert raises(lambda: None + mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}), TypeError)
         assert raises(lambda: quick_poly() + P(ctx=ctx1), IncompatibleContextError)
-        assert raises(lambda: quick_poly().__iadd__(P(ctx=ctx1)), IncompatibleContextError)
-        assert quick_poly().__iadd__(None) is NotImplemented
+        assert raises(lambda: quick_poly().iadd(P(ctx=ctx1)), IncompatibleContextError)
+        assert raises(lambda: quick_poly().iadd(None), NotImplementedError)
 
         assert quick_poly() - mpoly({(0, 0): 5, (0, 1): 6, (1, 0): 7, (2, 2): 8}) \
             == mpoly({(0, 0): -4, (0, 1): -4, (1, 0): -4, (2, 2): -4})
 
         for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]:
             p = quick_poly()
             p -= T(1)
-            assert quick_poly() - T(1) == p == mpoly({(0, 1): 2, (1, 0): 3, (2, 2): 4})
+            q = quick_poly()
+            assert q.isub(T(1)) is None
+            breakpoint()
+            assert quick_poly() - T(1) == p == q == mpoly({(0, 1): 2, (1, 0): 3, (2, 2): 4})
             assert T(1) - quick_poly() == mpoly({(0, 1): -2, (1, 0): -3, (2, 2): -4})
 
         assert raises(lambda: quick_poly() - None, TypeError)
         assert raises(lambda: None - quick_poly(), TypeError)
         assert raises(lambda: quick_poly() - P(ctx=ctx1), IncompatibleContextError)
-        assert raises(lambda: quick_poly().__isub__(P(ctx=ctx1)), IncompatibleContextError)
-        assert quick_poly().__isub__(None) is NotImplemented
+        assert raises(lambda: quick_poly().isub(P(ctx=ctx1)), IncompatibleContextError)
+        assert raises(lambda: quick_poly().isub(None), NotImplementedError)
 
         assert quick_poly() * mpoly({(1, 0): 5, (0, 1): 6}) \
             == mpoly({
@@ -2877,14 +2882,16 @@ def quick_poly():
         for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]:
             p = quick_poly()
             p *= T(2)
-            assert quick_poly() * T(2) == p == mpoly({(0, 0): 2, (0, 1): 4, (1, 0): 6, (2, 2): 8})
+            q = quick_poly()
+            assert q.imul(T(2)) is None
+            assert quick_poly() * T(2) == p == q == mpoly({(0, 0): 2, (0, 1): 4, (1, 0): 6, (2, 2): 8})
             assert T(2) * quick_poly() == mpoly({(0, 0): 2, (0, 1): 4, (1, 0): 6, (2, 2): 8})
 
         assert raises(lambda: quick_poly() * None, TypeError)
         assert raises(lambda: None * quick_poly(), TypeError)
         assert raises(lambda: quick_poly() * P(ctx=ctx1), IncompatibleContextError)
-        assert raises(lambda: quick_poly().__imul__(P(ctx=ctx1)), IncompatibleContextError)
-        assert quick_poly().__imul__(None) is NotImplemented
+        assert raises(lambda: quick_poly().imul(P(ctx=ctx1)), IncompatibleContextError)
+        assert raises(lambda: quick_poly().imul(None), NotImplementedError)
 
         assert quick_poly() // mpoly({(1, 1): 1}) == mpoly({(1, 1): 4})
         assert quick_poly() % mpoly({(1, 1): 1}) \

src/flint/types/fmpq_mpoly.pyx

@@ -346,19 +346,6 @@ cdef class fmpq_mpoly(flint_mpoly):
             return res
         return NotImplemented
 
-    def __iadd__(self, other):
-        if typecheck(other, fmpq_mpoly):
-            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
-            fmpq_mpoly_add((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            other = any_as_fmpq(other)
-            if other is not NotImplemented:
-                fmpq_mpoly_add_fmpq((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __sub__(self, other):
         cdef fmpq_mpoly res
         if typecheck(other, fmpq_mpoly):
@@ -384,19 +371,6 @@ cdef class fmpq_mpoly(flint_mpoly):
             return -res
         return NotImplemented
 
-    def __isub__(self, other):
-        if typecheck(other, fmpq_mpoly):
-            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
-            fmpq_mpoly_sub((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            other = any_as_fmpq(other)
-            if other is not NotImplemented:
-                fmpq_mpoly_sub_fmpq((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __mul__(self, other):
         cdef fmpq_mpoly res
         if typecheck(other, fmpq_mpoly):
@@ -422,19 +396,6 @@ cdef class fmpq_mpoly(flint_mpoly):
             return res
         return NotImplemented
 
-    def __imul__(self, other):
-        if typecheck(other, fmpq_mpoly):
-            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
-            fmpq_mpoly_mul((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            other = any_as_fmpq(other)
-            if other is not NotImplemented:
-                fmpq_mpoly_scalar_mul_fmpq(self.val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __pow__(self, other, modulus):
         cdef fmpq_mpoly res
         if modulus is not None:
@@ -582,6 +543,84 @@ cdef class fmpq_mpoly(flint_mpoly):
             raise ValueError("unreasonably large polynomial")  # pragma: no cover
         return vres
 
+    def iadd(self, other):
+        """
+        In-place addition, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.iadd(5)
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1 + 5
+
+        """
+        if typecheck(other, fmpq_mpoly):
+            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
+            fmpq_mpoly_add((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            other = any_as_fmpq(other)
+            if other is not NotImplemented:
+                fmpq_mpoly_add_fmpq((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
+                return
+        raise NotImplementedError(f"in-place addition not implemented between {type(self)} and {type(other)}")
+
+    def isub(self, other):
+        """
+        In-place subtraction, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.isub(5)
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1 - 5
+
+        """
+        if typecheck(other, fmpq_mpoly):
+            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
+            fmpq_mpoly_sub((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            other = any_as_fmpq(other)
+            if other is not NotImplemented:
+                fmpq_mpoly_sub_fmpq((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
+                return
+        raise NotImplementedError(f"in-place subtraction not implemented between {type(self)} and {type(other)}")
+
+    def imul(self, other):
+        """
+        In-place multiplication, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpq_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.imul(2)
+            >>> f
+            8*x0*x1 + 4*x0 + 6*x1
+
+        """
+        if typecheck(other, fmpq_mpoly):
+            if (<fmpq_mpoly>self).ctx is not (<fmpq_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpq_mpoly>self).ctx} is not {(<fmpq_mpoly>other).ctx}")
+            fmpq_mpoly_mul((<fmpq_mpoly>self).val, (<fmpq_mpoly>self).val, (<fmpq_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            other = any_as_fmpq(other)
+            if other is not NotImplemented:
+                fmpq_mpoly_scalar_mul_fmpq(self.val, (<fmpq_mpoly>self).val, (<fmpq>other).val, self.ctx.val)
+                return
+        raise NotImplementedError(f"in-place multiplication not implemented between {type(self)} and {type(other)}")
+
     def monoms(self):
         """
         Return the exponent vectors of each term as a tuple of fmpz.

src/flint/types/fmpz_mpoly.pyx

@@ -326,19 +326,6 @@ cdef class fmpz_mpoly(flint_mpoly):
             return res
         return NotImplemented
 
-    def __iadd__(self, other):
-        if typecheck(other, fmpz_mpoly):
-            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
-            fmpz_mpoly_add((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            zval = any_as_fmpz(other)
-            if zval is not NotImplemented:
-                fmpz_mpoly_add_fmpz((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz>zval).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __sub__(self, other):
         cdef fmpz_mpoly res
         if typecheck(other, fmpz_mpoly):
@@ -364,19 +351,6 @@ cdef class fmpz_mpoly(flint_mpoly):
             return -res
         return NotImplemented
 
-    def __isub__(self, other):
-        if typecheck(other, fmpz_mpoly):
-            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
-            fmpz_mpoly_sub((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            other = any_as_fmpz(other)
-            if other is not NotImplemented:
-                fmpz_mpoly_sub_fmpz((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz>other).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __mul__(self, other):
         cdef fmpz_mpoly res
         if typecheck(other, fmpz_mpoly):
@@ -402,19 +376,6 @@ cdef class fmpz_mpoly(flint_mpoly):
             return res
         return NotImplemented
 
-    def __imul__(self, other):
-        if typecheck(other, fmpz_mpoly):
-            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
-                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
-            fmpz_mpoly_mul((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
-            return self
-        else:
-            other = any_as_fmpz(other)
-            if other is not NotImplemented:
-                fmpz_mpoly_scalar_mul_fmpz(self.val, (<fmpz_mpoly>self).val, (<fmpz>other).val, self.ctx.val)
-                return self
-        return NotImplemented
-
     def __pow__(self, other, modulus):
         cdef fmpz_mpoly res
         if modulus is not None:
@@ -564,6 +525,84 @@ cdef class fmpz_mpoly(flint_mpoly):
             raise ValueError("unreasonably large polynomial")  # pragma: no cover
         return vres
 
+    def iadd(self, other):
+        """
+        In-place addition, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.iadd(5)
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1 + 5
+
+        """
+        if typecheck(other, fmpz_mpoly):
+            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
+            fmpz_mpoly_add((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            zval = any_as_fmpz(other)
+            if zval is not NotImplemented:
+                fmpz_mpoly_add_fmpz((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz>zval).val, self.ctx.val)
+                return
+        raise NotImplementedError()
+
+    def isub(self, other):
+        """
+        In-place subtraction, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.isub(5)
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1 - 5
+
+        """
+        if typecheck(other, fmpz_mpoly):
+            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
+            fmpz_mpoly_sub((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            other = any_as_fmpz(other)
+            if other is not NotImplemented:
+                fmpz_mpoly_sub_fmpz((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz>other).val, self.ctx.val)
+                return
+        raise NotImplementedError()
+
+    def imul(self, other):
+        """
+        In-place multiplication, mutates self.
+
+            >>> from flint import Ordering
+            >>> ctx = fmpz_mpoly_ctx.get_context(2, Ordering.lex, 'x')
+            >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4})
+            >>> f
+            4*x0*x1 + 2*x0 + 3*x1
+            >>> f.imul(2)
+            >>> f
+            8*x0*x1 + 4*x0 + 6*x1
+
+        """
+        if typecheck(other, fmpz_mpoly):
+            if (<fmpz_mpoly>self).ctx is not (<fmpz_mpoly>other).ctx:
+                raise IncompatibleContextError(f"{(<fmpz_mpoly>self).ctx} is not {(<fmpz_mpoly>other).ctx}")
+            fmpz_mpoly_mul((<fmpz_mpoly>self).val, (<fmpz_mpoly>self).val, (<fmpz_mpoly>other).val, self.ctx.val)
+            return
+        else:
+            other = any_as_fmpz(other)
+            if other is not NotImplemented:
+                fmpz_mpoly_scalar_mul_fmpz(self.val, (<fmpz_mpoly>self).val, (<fmpz>other).val, self.ctx.val)
+                return
+        raise NotImplementedError()
+
     def monoms(self):
         """
         Return the exponent vectors of each term as a tuple of fmpz.