fix: add __rdunder__ fmpz_poly, fmpq_poly and nmp_poly

Author: oscarbenjamin

src/flint/fmpq_poly.pyx

@@ -176,70 +176,98 @@ cdef class fmpq_poly(flint_poly):
         fmpq_poly_neg(res.val, self.val)
         return res
 
-    def __add__(s, t):
+    def _add_(s, t):
         cdef fmpq_poly r
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
         t = any_as_fmpq_poly(t)
         if t is NotImplemented:
             return t
         r = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_add(r.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return r
 
-    def __sub__(s, t):
+    def __add__(s, t):
+        return s._add_(t)
+
+    def __radd__(s, t):
+        return s._add_(t)
+
+    def _sub_(s, t):
         cdef fmpq_poly r
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
-        t = any_as_fmpq_poly(t)
-        if t is NotImplemented:
-            return t
         r = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_sub(r.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return r
 
-    def __mul__(s, t):
+    def __sub__(s, t):
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return s._sub_(t)
+
+    def __rsub__(s, t):
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return t._sub_(s)
+
+    def _mul_(s, t):
         cdef fmpq_poly r
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
         t = any_as_fmpq_poly(t)
         if t is NotImplemented:
             return t
         r = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_mul(r.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return r
 
-    def __floordiv__(s, t):
+    def __mul__(s, t):
+        return s._mul_(t)
+
+    def __rmul__(s, t):
+        return s._mul_(t)
+
+    def _floordiv_(s, t):
         cdef fmpq_poly r
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
-        t = any_as_fmpq_poly(t)
-        if t is NotImplemented:
-            return t
         if fmpq_poly_is_zero((<fmpq_poly>t).val):
             raise ZeroDivisionError("fmpq_poly division by 0")
         r = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_div(r.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return r
 
-    def __mod__(s, t):
+    def __floordiv__(s, t):
+        cdef fmpq_poly r
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return s._floordiv_(t)
+
+    def __rfloordiv__(s, t):
         cdef fmpq_poly r
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
         t = any_as_fmpq_poly(t)
         if t is NotImplemented:
             return t
+        return t._floordiv_(s)
+
+    def _mod_(s, t):
+        cdef fmpq_poly r
         if fmpq_poly_is_zero((<fmpq_poly>t).val):
             raise ZeroDivisionError("fmpq_poly division by 0")
         r = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_rem(r.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return r
 
+    def __mod__(s, t):
+        cdef fmpq_poly r
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return s._mod_(t)
+
+    def __rmod__(s, t):
+        cdef fmpq_poly r
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return t._mod_(s)
+
     @staticmethod
     def _div_(fmpq_poly s, t):
         cdef fmpq_poly r
@@ -258,21 +286,27 @@ cdef class fmpq_poly(flint_poly):
     def __truediv__(s, t):
         return fmpq_poly._div_(s, t)
 
-    def __divmod__(s, t):
+    def _divmod_(s, t):
         cdef fmpq_poly P, Q
-        s = any_as_fmpq_poly(s)
-        if s is NotImplemented:
-            return s
-        t = any_as_fmpq_poly(t)
-        if t is NotImplemented:
-            return t
         if fmpq_poly_is_zero((<fmpq_poly>t).val):
             raise ZeroDivisionError("fmpq_poly divmod by 0")
         P = fmpq_poly.__new__(fmpq_poly)
         Q = fmpq_poly.__new__(fmpq_poly)
         fmpq_poly_divrem(P.val, Q.val, (<fmpq_poly>s).val, (<fmpq_poly>t).val)
         return P, Q
 
+    def __divmod__(s, t):
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return s._divmod_(t)
+
+    def __rdivmod__(s, t):
+        t = any_as_fmpq_poly(t)
+        if t is NotImplemented:
+            return t
+        return t._divmod_(s)
+
     def __pow__(fmpq_poly self, ulong exp, mod):
         cdef fmpq_poly res
         if mod is not None:

src/flint/fmpz_poly.pyx

@@ -147,85 +147,115 @@ cdef class fmpz_poly(flint_poly):
         fmpz_poly_neg(res.val, self.val)
         return res
 
-    def __add__(self, other):
+    def _add_(self, other):
         cdef fmpz_poly res
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
         res = fmpz_poly.__new__(fmpz_poly)
         fmpz_poly_add(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
         return res
 
+    def __add__(self, other):
+        return self._add_(other)
+
+    def __radd__(self, other):
+        return self._add_(other)
+
     def __sub__(self, other):
         cdef fmpz_poly res
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
         res = fmpz_poly.__new__(fmpz_poly)
         fmpz_poly_sub(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
         return res
 
-    def __mul__(self, other):
+    def __rsub__(self, other):
         cdef fmpz_poly res
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
         res = fmpz_poly.__new__(fmpz_poly)
-        fmpz_poly_mul(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
+        fmpz_poly_sub(res.val, (<fmpz_poly>other).val, (<fmpz_poly>self).val)
         return res
 
-    def __floordiv__(self, other):
+    def _mul_(self, other):
         cdef fmpz_poly res
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
+        res = fmpz_poly.__new__(fmpz_poly)
+        fmpz_poly_mul(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
+        return res
+
+    def __mul__(self, other):
+        return self._mul_(other)
+
+    def __rmul__(self, other):
+        return self._mul_(other)
+
+    def _floordiv_(self, other):
+        cdef fmpz_poly res
         if fmpz_poly_is_zero((<fmpz_poly>other).val):
             raise ZeroDivisionError("fmpz_poly division by 0")
         res = fmpz_poly.__new__(fmpz_poly)
         fmpz_poly_div(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
         return res
 
-    def __mod__(self, other):
-        cdef fmpz_poly res
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
+    def __floordiv__(self, other):
+        other = any_as_fmpz_poly(other)
+        if other is NotImplemented:
+            return other
+        return self._floordiv_(other)
+
+    def __rfloordiv__(self, other):
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
+        return other._floordiv_(self)
+
+    def _mod_(self, other):
+        cdef fmpz_poly res
         if fmpz_poly_is_zero((<fmpz_poly>other).val):
             raise ZeroDivisionError("fmpz_poly division by 0")
         res = fmpz_poly.__new__(fmpz_poly)
         fmpz_poly_rem(res.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
         return res
 
-    def __divmod__(self, other):
-        cdef fmpz_poly P, Q
-        self = any_as_fmpz_poly(self)
-        if self is NotImplemented:
-            return self
+    def __mod__(self, other):
         other = any_as_fmpz_poly(other)
         if other is NotImplemented:
             return other
+        return self._mod_(other)
+
+    def __rmod__(self, other):
+        other = any_as_fmpz_poly(other)
+        if other is NotImplemented:
+            return other
+        return other._mod_(self)
+
+    def _divmod_(self, other):
+        cdef fmpz_poly P, Q
         if fmpz_poly_is_zero((<fmpz_poly>other).val):
             raise ZeroDivisionError("fmpz_poly divmod by 0")
         P = fmpz_poly.__new__(fmpz_poly)
         Q = fmpz_poly.__new__(fmpz_poly)
         fmpz_poly_divrem(P.val, Q.val, (<fmpz_poly>self).val, (<fmpz_poly>other).val)
         return P, Q
 
+    def __divmod__(self, other):
+        other = any_as_fmpz_poly(other)
+        if other is NotImplemented:
+            return other
+        return self._divmod_(other)
+
+    def __rdivmod__(self, other):
+        other = any_as_fmpz_poly(other)
+        if other is NotImplemented:
+            return other
+        return other._divmod_(self)
+
     def __pow__(fmpz_poly self, ulong exp, mod):
         cdef fmpz_poly res
         if mod is not None: