Add context methods for neg, add, sub and mul

Author: Tom-Hubrecht

src/flint/types/_gr.pxd

@@ -119,10 +119,16 @@ from flint.flintlib.functions.gr cimport (
     gr_neg,
     gr_add,
     gr_add_si,
+    gr_add_other,
+    gr_other_add,
     gr_sub,
     gr_sub_si,
+    gr_sub_other,
+    gr_other_sub,
     gr_mul,
     gr_mul_si,
+    gr_mul_other,
+    gr_other_mul,
     gr_inv,
     gr_div,
     gr_div_si,
@@ -390,6 +396,123 @@ cdef class gr_ctx(flint_ctx):
     cdef inline truth_t _is_neg_one(self, gr x):
         return gr_is_neg_one(x.pval, self.ctx_t)
 
+    @cython.final
+    cdef inline gr _neg(self, gr x):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_neg(res.pval, x.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot negate x in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _add(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_add(res.pval, x.pval, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot add x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _add_other(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_add_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot add x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _other_add(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_other_add(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot add x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _add_si(self, gr x, slong y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_add_si(res.pval, x.pval, y, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot add x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _sub(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_sub(res.pval, x.pval, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot sub x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _sub_other(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_sub_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot sub x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _other_sub(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_other_sub(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot sub x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _sub_si(self, gr x, slong y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_sub_si(res.pval, x.pval, y, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot sub x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _mul(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_mul(res.pval, x.pval, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot mul x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _mul_other(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_mul_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot mul x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _other_mul(self, gr x, gr y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_other_mul(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot mul x and y in this context")
+        return res
+
+    @cython.final
+    cdef inline gr _mul_si(self, gr x, slong y):
+        cdef int err
+        cdef gr res = self.new_gr()
+        err = gr_mul_si(res.pval, x.pval, y, self.ctx_t)
+        if err != GR_SUCCESS:
+            raise self._error(err, "Cannot mul x and y in this context")
+        return res
+
     # @cython.final
     # cdef inline list _gens_recursive(self):
     #     cdef int err
@@ -919,7 +1042,7 @@ cdef class gr_series_ctx(gr_ctx):
 @cython.no_gc
 cdef class gr(flint_scalar):
     cdef gr_ptr pval
-    cdef gr_ctx ctx
+    cdef public gr_ctx ctx
     cdef bint _init
 
     @cython.final

src/flint/types/_gr.pyx

@@ -397,6 +397,80 @@ cdef class gr_ctx(flint_ctx):
         """
         return truth_to_py(self._is_neg_one(x))
 
+    def neg(self, x):
+        """
+        Returns `-x`.
+
+            >>> from flint.types._gr import gr_complex_acb_ctx, gr_real_arb_ctx
+            >>> arb = gr_real_arb_ctx.new(53); acb = gr_complex_acb_ctx.new(106)
+            >>> c = acb("2 + I").sqrt(); c
+            ([1.4553466902253548081226618397097 +/- 3.48e-32] + [0.3435607497225124641385657439146 +/- 5.23e-32]*I)
+            >>> arb.neg(c)
+            [-1.455346690225355 +/- 1.92e-16]
+        """
+        return self._neg(x)
+
+    def add(self, x, y) -> gr:
+        """
+        Returns `x + y`
+
+        """
+        if isinstance(x, gr) and isinstance(y, gr):
+            if x.ctx == self and y.ctx == self:
+                return self._add(x, y)
+            if x.ctx == self:
+                return self._add_other(x, y)
+            if y.ctx == self:
+                return self._other_add(x, y)
+
+        if isinstance(x, gr) and x.ctx == self and type(y) is int:
+            try:
+                return self._add_si(x, y)
+            except OverflowError:
+                pass
+
+        # NOTE: By default, convert everything to the required
+        # context before performing the operation
+        return self._add(self(x), self(y))
+
+    def sub(self, x, y):
+        if isinstance(x, gr) and isinstance(y, gr):
+            if x.ctx == self and y.ctx == self:
+                return self._sub(x, y)
+            if x.ctx == self:
+                return self._sub_other(x, y)
+            if y.ctx == self:
+                return self._other_sub(x, y)
+
+        if isinstance(x, gr) and x.ctx == self and type(y) is int:
+            try:
+                return self._sub_si(x, y)
+            except OverflowError:
+                pass
+
+        # NOTE: By default, convert everything to the required
+        # context before performing the operation
+        return self._sub(self(x), self(y))
+
+    def mul(self, x, y):
+        if isinstance(x, gr) and isinstance(y, gr):
+            if x.ctx == self and y.ctx == self:
+                return self._mul(x, y)
+            if x.ctx == self:
+                return self._mul_other(x, y)
+            if y.ctx == self:
+                return self._other_mul(x, y)
+
+        if isinstance(x, gr) and x.ctx == self and type(y) is int:
+            try:
+                return self._mul_si(x, y)
+            except OverflowError:
+                pass
+
+        # NOTE: By default, convert everything to the required
+        # context before performing the operation
+        return self._mul(self(x), self(y))
+
     # def gens_recursive(self) -> list[gr]:
     #     """Return all generators of the domain