diff --git a/src/flint/types/_gr.pyx b/src/flint/types/_gr.pyx index fa9f0f3a..83811460 100644 --- a/src/flint/types/_gr.pyx +++ b/src/flint/types/_gr.pyx @@ -779,6 +779,47 @@ cdef class gr_ctx(flint_ctx): def max(self, x, y) -> gr: return self._max(self(x), self(y)) + ### + # Array-API wrappers + + def divide(self, x, y) -> gr: + return self.div(x, y) + + def greater(self, x, y): + return self.gt(x, y) + + def greater_equal(self, x, y): + return self.ge(x, y) + + def less(self, x, y): + return self.lt(x, y) + + def less_equal(self, x, y): + return self.le(x, y) + + def imag(self, x): + return self.im(x) + + def real(self, x): + return self.re(x) + + def maximum(self, x, y): + return self.max(x, y) + + def minimum(self, x, y): + return self.min(x, y) + + def multiply(self, x, y): + return self.mul(x, y) + + def negative(self, x): + return self.neg(x) + + def not_equal(self, x, y): + eq = self.equal(x, y) + if eq is None: + return None + return not eq cdef class gr_scalar_ctx(gr_ctx): """Base class for all scalar contexts.""" @@ -1661,6 +1702,18 @@ cdef class gr(flint_scalar): def __repr__(self): return self.ctx.to_str(self) + def parent(self) -> gr_ctx: + """ + Return the parent context. + + >>> from flint.types._gr import gr_complex_acb_ctx + >>> acb = gr_complex_acb_ctx.new(53) + >>> x = acb("pi") + >>> x.parent() + gr_complex_acb_ctx(53) + """ + return self.ctx + def is_zero(self): """Return whether the element is zero (may return ``None``). @@ -1838,10 +1891,7 @@ cdef class gr(flint_scalar): return NotImplemented def __pow__(self, other) -> gr: - if isinstance(other, int): - return self._pow_si(other) - else: - return NotImplemented + return self.ctx.pow(self, other) def is_square(self): """Return whether the element is a square (may return ``None``). @@ -1854,7 +1904,7 @@ cdef class gr(flint_scalar): >>> Q(4).sqrt() 2 """ - return truth_to_py(self._is_square()) + return truth_to_py(self.ctx.is_square(self)) def sqrt(self): """Return the square root of the element if it exists. @@ -1863,7 +1913,7 @@ cdef class gr(flint_scalar): >>> Z(4).sqrt() 2 """ - return self._sqrt() + return self.ctx.sqrt(self) def rsqrt(self): """Return the reciprocal square root of the element if it exists. @@ -1872,7 +1922,7 @@ cdef class gr(flint_scalar): >>> Q(4).rsqrt() 1/2 """ - return self._rsqrt() + return self.ctx.rsqrt(self) def gcd(self, other): """Return the greatest common divisor of two elements. @@ -1902,7 +1952,7 @@ cdef class gr(flint_scalar): other_gr = other if not self.ctx == other_gr.ctx: raise TypeError("gcd of gr with different contexts.") - return self._lcm(other_gr) + return self.ctx.lcm(self, other_gr) def factor(self): """Return the factorization of the element. @@ -1911,7 +1961,7 @@ cdef class gr(flint_scalar): >>> Z(12).factor() (1, [(2, 2), (3, 1)]) """ - return self._factor() + return self.ctx.factor(self) def numer(self) -> gr: """Return the numerator of the element. @@ -1925,7 +1975,7 @@ cdef class gr(flint_scalar): See also :meth:`denom`. """ - return self._numerator() + return self.ctx.numerator(self) def denom(self) -> gr: """Return the denominator of the element. @@ -1939,21 +1989,21 @@ cdef class gr(flint_scalar): See also :meth:`numer`. """ - return self._denominator() + return self.ctx.denominator(self) def __floor__(self) -> gr: - return self._floor() + return self.ctx.floor(self) def __ceil__(self) -> gr: - return self._ceil() + return self.ctx.ceil(self) def __trunc__(self) -> gr: - return self._trunc() + return self.ctx.trunc(self) def __round__(self, ndigits: int = 0) -> gr: if ndigits != 0: raise NotImplementedError("Rounding to a specific number of digits is not supported") - return self._nint() + return self.ctx.nint(self) # def __int__(self) -> int: # return self._floor().to_int() @@ -1962,7 +2012,7 @@ cdef class gr(flint_scalar): # return ... def __abs__(self) -> gr: - return self._abs() + return self.ctx.abs(self) def conjugate(self) -> gr: """Return complex conjugate of the element. @@ -1972,7 +2022,7 @@ cdef class gr(flint_scalar): >>> (1 + I).conjugate() (1-I) """ - return self._conj() + return self.ctx.conj(self) @property def real(self) -> gr: @@ -1983,7 +2033,7 @@ cdef class gr(flint_scalar): >>> (1 + I).real 1 """ - return self._re() + return self.ctx.re(self) @property def imag(self) -> gr: @@ -1994,7 +2044,7 @@ cdef class gr(flint_scalar): >>> (1 + I).imag 1 """ - return self._im() + return self.ctx.im(self) # XXX: Return -1, 0, 1 as int? def sgn(self) -> gr: @@ -2008,7 +2058,7 @@ cdef class gr(flint_scalar): >>> Q(0).sgn() 0 """ - return self._sgn() + return self.ctx.sgn(self) def csgn(self) -> gr: """Return the complex sign of the element. @@ -2018,7 +2068,7 @@ cdef class gr(flint_scalar): >>> (1 + C.i()).csgn() # doctest: +SKIP 1 """ - return self._csgn() + return self.ctx.csgn(self) def arg(self) -> gr: """Return the argument of the element. @@ -2028,4 +2078,4 @@ cdef class gr(flint_scalar): >>> (1 + C.i()).arg() [0.785 +/- 6.45e-4] """ - return self._arg() + return self.ctx.arg(self)