From 9ac1612c342c66a5d574a6c824b064e2a2ec076c Mon Sep 17 00:00:00 2001 From: Jeroen Demeyer Date: Mon, 12 Feb 2018 13:22:01 +0100 Subject: [PATCH] Cleanup for real/complex interval fields --- .../en/reference/rings_numerical/index.rst | 1 - src/sage/rings/complex_interval.pxd | 15 +- src/sage/rings/complex_interval.pyx | 121 +++++------- src/sage/rings/complex_interval_field.py | 49 +++-- .../number_field_element_quadratic.pyx | 4 +- src/sage/rings/real_interval_field.py | 5 + src/sage/rings/real_mpfi.pxd | 7 +- src/sage/rings/real_mpfi.pyx | 177 ++---------------- 8 files changed, 98 insertions(+), 281 deletions(-) diff --git a/src/doc/en/reference/rings_numerical/index.rst b/src/doc/en/reference/rings_numerical/index.rst index 9d396fe1559..b8bcfe8fd6f 100644 --- a/src/doc/en/reference/rings_numerical/index.rst +++ b/src/doc/en/reference/rings_numerical/index.rst @@ -36,7 +36,6 @@ ComplexBallField). :maxdepth: 2 sage/rings/real_mpfi - sage/rings/real_interval_field sage/rings/real_interval_absolute sage/rings/complex_interval_field sage/rings/complex_interval diff --git a/src/sage/rings/complex_interval.pxd b/src/sage/rings/complex_interval.pxd index 0b9d8a55464..eebcb2acbfa 100644 --- a/src/sage/rings/complex_interval.pxd +++ b/src/sage/rings/complex_interval.pxd @@ -2,7 +2,7 @@ from sage.libs.mpfr.types cimport mpfr_prec_t from sage.libs.mpfi.types cimport mpfi_t cimport sage.structure.element -from .real_mpfi cimport RealIntervalFieldElement +from .real_mpfi cimport RealIntervalFieldElement, RealIntervalField_class cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): @@ -10,11 +10,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): cdef mpfi_t __im cdef mpfr_prec_t _prec - cpdef _add_(self, other) - cpdef _mul_(self, other) - cdef RealIntervalFieldElement abs_c(ComplexIntervalFieldElement self) - cdef RealIntervalFieldElement norm_c(ComplexIntervalFieldElement self) - cdef inline ComplexIntervalFieldElement _new(self): """ Quickly create a new complex interval with the same parent as @@ -22,3 +17,11 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): """ cdef type t = type(self) return t.__new__(t, self._parent) + + cdef inline RealIntervalFieldElement _new_real(self): + """ + Quickly create a new real interval with the same precision as + ``self``. + """ + P = (self._parent.real_field()) + return P._new() diff --git a/src/sage/rings/complex_interval.pyx b/src/sage/rings/complex_interval.pyx index cd12eec28f1..1c9c5f5b4a0 100644 --- a/src/sage/rings/complex_interval.pyx +++ b/src/sage/rings/complex_interval.pyx @@ -322,23 +322,23 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: zz.imag().endpoints() == z.imag().endpoints() True """ - cdef ComplexIntervalFieldElement a00 = self._new() + a00 = self._new() mpfr_set(&a00.__re.left, &self.__re.left, MPFR_RNDN) mpfi_mid(&a00.__re.right, self.__re) mpfr_set(&a00.__im.left, &self.__im.left, MPFR_RNDN) mpfi_mid(&a00.__im.right, self.__im) - cdef ComplexIntervalFieldElement a01 = self._new() + a01 = self._new() mpfr_set(&a01.__re.left, &a00.__re.right, MPFR_RNDN) mpfr_set(&a01.__re.right, &self.__re.right, MPFR_RNDN) mpfi_set(a01.__im, a00.__im) - cdef ComplexIntervalFieldElement a10 = self._new() + a10 = self._new() mpfi_set(a10.__re, a00.__re) mpfi_mid(&a10.__im.left, self.__im) mpfr_set(&a10.__im.right, &self.__im.right, MPFR_RNDN) - cdef ComplexIntervalFieldElement a11 = self._new() + a11 = self._new() mpfi_set(a11.__re, a01.__re) mpfi_set(a11.__im, a10.__im) @@ -425,10 +425,10 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): 0.693147? + 3.1415902?*I, 0.693147? + 3.1415940?*I) """ - cdef ComplexIntervalFieldElement left = self._new() - cdef ComplexIntervalFieldElement right = self._new() - cdef ComplexIntervalFieldElement lower = self._new() - cdef ComplexIntervalFieldElement upper = self._new() + left = self._new() + right = self._new() + lower = self._new() + upper = self._new() cdef mpfr_t x mpfr_init2(x, self.prec()) @@ -471,7 +471,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): 2.00000000000000 """ cdef RealNumber diam - diam = RealNumber(self._parent._real_field().middle_field(), None) + diam = RealNumber(self._parent.real_field().middle_field(), None) cdef mpfr_t tmp mpfr_init2(tmp, self.prec()) mpfi_diam(diam.value, self.__re) @@ -511,8 +511,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): ... ValueError: intersection of non-overlapping intervals """ - - cdef ComplexIntervalFieldElement x = self._new() + x = self._new() cdef ComplexIntervalFieldElement other_intv if isinstance(other, ComplexIntervalFieldElement): other_intv = other @@ -538,7 +537,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(0).union(CIF(5, 5)).str(style='brackets') '[0.00000000000000000 .. 5.0000000000000000] + [0.00000000000000000 .. 5.0000000000000000]*I' """ - cdef ComplexIntervalFieldElement x = self._new() + x = self._new() cdef ComplexIntervalFieldElement other_intv if isinstance(other, ComplexIntervalFieldElement): other_intv = other @@ -566,7 +565,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: parent(CIF(1).magnitude()) Real Field with 53 bits of precision and rounding RNDU """ - cdef real_mpfi.RealIntervalField_class RIF = self._parent._real_field() + cdef real_mpfi.RealIntervalField_class RIF = self._parent.real_field() cdef RealNumber x = RIF.__upper_field._new() cdef RealNumber y = RIF.__upper_field._new() mpfi_mag(x.value, self.__re) @@ -590,7 +589,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: parent(CIF(1).mignitude()) Real Field with 53 bits of precision and rounding RNDD """ - cdef real_mpfi.RealIntervalField_class RIF = self._parent._real_field() + cdef real_mpfi.RealIntervalField_class RIF = self._parent.real_field() cdef RealNumber x = RIF.__lower_field._new() cdef RealNumber y = RIF.__lower_field._new() mpfi_mig(x.value, self.__re) @@ -649,7 +648,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(2,-3)._add_(CIF(1,-2)) 3 - 5*I """ - cdef ComplexIntervalFieldElement x x = self._new() mpfi_add(x.__re, self.__re, (right).__re) mpfi_add(x.__im, self.__im, (right).__im) @@ -664,7 +662,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(2,-3)._sub_(CIF(1,-2)) 1 - 1*I """ - cdef ComplexIntervalFieldElement x x = self._new() mpfi_sub(x.__re, self.__re, (right).__re) mpfi_sub(x.__im, self.__im, (right).__im) @@ -679,7 +676,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(2,-3)._mul_(CIF(1,-2)) -4 - 7*I """ - cdef ComplexIntervalFieldElement x x = self._new() cdef mpfi_t t0, t1 mpfi_init2(t0, self._prec) @@ -728,41 +724,17 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(1, -2).norm() 5 """ - return self.norm_c() - - cdef real_mpfi.RealIntervalFieldElement norm_c(ComplexIntervalFieldElement self): - cdef real_mpfi.RealIntervalFieldElement x - x = real_mpfi.RealIntervalFieldElement(self._parent._real_field(), None) - - cdef mpfi_t t0, t1 - mpfi_init2(t0, self._prec) - mpfi_init2(t1, self._prec) - - mpfi_sqr(t0, self.__re) - mpfi_sqr(t1, self.__im) + x = self._new_real() - mpfi_add(x.value, t0, t1) - - mpfi_clear(t0) - mpfi_clear(t1) - return x - - cdef real_mpfi.RealIntervalFieldElement abs_c(ComplexIntervalFieldElement self): - cdef real_mpfi.RealIntervalFieldElement x - x = real_mpfi.RealIntervalFieldElement(self._parent._real_field(), None) - - cdef mpfi_t t0, t1 - mpfi_init2(t0, self._prec) - mpfi_init2(t1, self._prec) + cdef mpfi_t t + mpfi_init2(t, self._prec) - mpfi_sqr(t0, self.__re) - mpfi_sqr(t1, self.__im) + mpfi_sqr(x.value, self.__re) + mpfi_sqr(t, self.__im) - mpfi_add(x.value, t0, t1) - mpfi_sqrt(x.value, x.value) + mpfi_add(x.value, x.value, t) - mpfi_clear(t0) - mpfi_clear(t1) + mpfi_clear(t) return x cpdef _div_(self, right): @@ -790,17 +762,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): """ return self * right.__invert__() - def __rdiv__(self, left): - """ - Divide ``left`` by ``self``. - - EXAMPLES:: - - sage: CIF(2,-3).__rdiv__(CIF(1,-2)) - 0.6153846153846154? - 0.0769230769230770?*I - """ - return ComplexIntervalFieldElement(self._parent, left)/self - def __pow__(self, right, modulus): r""" Compute `x^y`. @@ -1040,8 +1001,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: x.parent() Real Interval Field with 100 bits of precision """ - cdef real_mpfi.RealIntervalFieldElement x - x = real_mpfi.RealIntervalFieldElement(self._parent._real_field(), None) + x = self._new_real() mpfi_set(x.value, self.__re) return x @@ -1058,8 +1018,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: x.parent() Real Interval Field with 100 bits of precision """ - cdef real_mpfi.RealIntervalFieldElement x - x = real_mpfi.RealIntervalFieldElement(self._parent._real_field(), None) + x = self._new_real() mpfi_set(x.value, self.__im) return x @@ -1072,7 +1031,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: CIF(1.5, 2.5).__neg__() -1.5000000000000000? - 2.5000000000000000?*I """ - cdef ComplexIntervalFieldElement x x = self._new() mpfi_neg(x.__re, self.__re) mpfi_neg(x.__im, self.__im) @@ -1095,10 +1053,24 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): EXAMPLES:: + sage: abs(CIF(1.5, 2.5)) + 2.915475947422650? sage: CIF(1.5, 2.5).__abs__() 2.915475947422650? """ - return self.abs_c() + x = self._new_real() + + cdef mpfi_t t + mpfi_init2(t, self._prec) + + mpfi_sqr(x.value, self.__re) + mpfi_sqr(t, self.__im) + + mpfi_add(x.value, x.value, t) + mpfi_sqrt(x.value, x.value) + + mpfi_clear(t) + return x def __invert__(self): """ @@ -1135,8 +1107,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): .. [RL] \J. Rokne, P. Lancaster. Complex interval arithmetic. Communications of the ACM 14. 1971. """ - - cdef ComplexIntervalFieldElement x x = self._new() cdef mpfr_t a, b, c, d @@ -1631,7 +1601,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): upper = i break - fld = self.parent()._real_field() + fld = self._parent.real_field() return fld.pi() * fld(lower, upper) * fld(0.5) else: @@ -1641,7 +1611,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): # We'll handle the "bounded away in the imaginary direction" # case first. - fld = self.parent()._real_field() + fld = self._parent.real_field() if mpfi_is_strictly_pos(self.__im): return (-self.real() / self.imag()).arctan() + fld.pi()/2 @@ -1704,7 +1674,6 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): sage: (1+i).conjugate() 1 - 1*I """ - cdef ComplexIntervalFieldElement x x = self._new() mpfi_set(x.__re, self.__re) @@ -1888,7 +1857,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): \cos(x + iy) = \cos(x) \cosh(y) - i \sin(x) \sinh(y) """ - cdef ComplexIntervalFieldElement res = self._new() + res = self._new() cdef mpfi_t tmp mpfi_init2(tmp, self._parent.prec()) sig_on() @@ -1930,7 +1899,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): \sin(x + iy) = \sin(x) \cosh(y) + i \cos (x) \sinh(y) """ - cdef ComplexIntervalFieldElement res = self._new() + res = self._new() cdef mpfi_t tmp mpfi_init2(tmp, self._parent.prec()) sig_on() @@ -1981,7 +1950,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): \cosh(x+iy) = \cos(y) \cosh(x) + i \sin(y) \sinh(x) """ - cdef ComplexIntervalFieldElement res = self._new() + res = self._new() cdef mpfi_t tmp mpfi_init2(tmp, self._parent.prec()) sig_on() @@ -2017,7 +1986,7 @@ cdef class ComplexIntervalFieldElement(sage.structure.element.FieldElement): \sinh(x+iy) = \cos(y) \sinh(x) + i \sin(y) \cosh(x) """ - cdef ComplexIntervalFieldElement res = self._new() + res = self._new() cdef mpfi_t tmp mpfi_init2(tmp, self._parent.prec()) sig_on() @@ -2077,9 +2046,7 @@ def make_ComplexIntervalFieldElement0( fld, re, im ): sage: loads(dumps(a)) == a # indirect doctest True """ - x = ComplexIntervalFieldElement( fld, re, im ) - return x - + return fld(re, im) def create_ComplexIntervalFieldElement(s_real, s_imag=None, int pad=0, min_prec=53): diff --git a/src/sage/rings/complex_interval_field.py b/src/sage/rings/complex_interval_field.py index dcfd48fa93b..dffe4c7b78b 100644 --- a/src/sage/rings/complex_interval_field.py +++ b/src/sage/rings/complex_interval_field.py @@ -42,14 +42,13 @@ from sage.structure.parent import Parent from .integer_ring import ZZ from .rational_field import QQ -from . import complex_double from .ring import Field from . import integer from . import complex_interval import weakref from .real_mpfi import RealIntervalField, RealIntervalField_class -from .complex_field import ComplexField, ComplexField_class -from sage.misc.sage_eval import sage_eval +from .complex_field import ComplexField +from sage.misc.cachefunc import cached_method NumberFieldElement_quadratic = None @@ -214,7 +213,7 @@ def __init__(self, prec=53): """ self._prec = int(prec) from sage.categories.fields import Fields - Field.__init__(self, self._real_field(), ("I",), False, + Field.__init__(self, self.real_field(), ("I",), False, category=Fields().Infinite()) self._populate_coercion_lists_(convert_method_name="_complex_mpfi_") @@ -260,7 +259,7 @@ def construction(self): Univariate Polynomial Ring in x over Complex Interval Field with 53 bits of precision """ from sage.categories.pushout import AlgebraicClosureFunctor - return (AlgebraicClosureFunctor(), self._real_field()) + return (AlgebraicClosureFunctor(), self.real_field()) def is_exact(self): """ @@ -349,6 +348,7 @@ def _sage_input_(self, sib, coerce): precision = prec + @cached_method def real_field(self): """ Return the underlying :class:`RealIntervalField`. @@ -362,14 +362,13 @@ def real_field(self): sage: CIF.real_field() is R True """ - try: - return self.__real_field - except AttributeError: - self.__real_field = RealIntervalField(self._prec) - return self.__real_field + return RealIntervalField(self._prec) + # For compatibility with with other complex number implementations + # such as CC. _real_field = real_field + @cached_method def middle_field(self): """ Return the corresponding :class:`ComplexField` with the same precision @@ -382,11 +381,7 @@ def middle_field(self): sage: ComplexIntervalField(200).middle_field() Complex Field with 200 bits of precision """ - try: - return self.__middle_field - except AttributeError: - self.__middle_field = ComplexField(self._prec) - return self.__middle_field + return ComplexField(self._prec) def __eq__(self, other): """ @@ -480,7 +475,7 @@ def __call__(self, x=None, im=None, **kwds): # Note: we override Parent.__call__ because we want to support # CIF(a, b) and that is hard to do using coerce maps. if im is not None or kwds: - return complex_interval.ComplexIntervalFieldElement(self, x, im, **kwds) + return self.element_class(self, x, im, **kwds) return Parent.__call__(self, x) def _coerce_map_from_(self, S): @@ -595,7 +590,7 @@ def gen(self, n=0): """ if n != 0: raise IndexError("n must be 0") - return complex_interval.ComplexIntervalFieldElement(self, 0, 1) + return self.element_class(self, 0, 1) def random_element(self, *args, **kwds): """ @@ -616,8 +611,10 @@ def random_element(self, *args, **kwds): sage: CIF.random_element(max=0, min=-5) -0.079017286535590259? - 2.8712089896087117?*I """ - return self._real_field().random_element(*args, **kwds) \ - + self.gen() * self._real_field().random_element(*args, **kwds) + rand = self.real_field().random_element + re = rand(*args, **kwds) + im = rand(*args, **kwds) + return self.element_class(self, re, im) def is_field(self, proof = True): """ @@ -650,7 +647,7 @@ def pi(self): sage: ComplexIntervalField(100).pi() 3.14159265358979323846264338328? """ - return self(self._real_field().pi()) + return self.element_class(self, self.real_field().pi()) def ngens(self): r""" @@ -693,16 +690,16 @@ def zeta(self, n=2): from .integer import Integer n = Integer(n) if n == 1: - x = self(1) + x = self.element_class(self, 1) elif n == 2: - x = self(-1) + x = self.element_class(self, -1) elif n >= 3: # Use De Moivre # e^(2*pi*i/n) = cos(2pi/n) + i *sin(2pi/n) - RR = self._real_field() - pi = RR.pi() + RIF = self.real_field() + pi = RIF.pi() z = 2*pi/n - x = complex_interval.ComplexIntervalFieldElement(self, z.cos(), z.sin()) + x = self.element_class(self, z.cos(), z.sin()) # Uncomment after implemented #x._set_multiplicative_order( n ) return x @@ -725,6 +722,6 @@ def scientific_notation(self, status=None): sage: CIF((0.025, 2)) 0.025000000000000002? + 2*I """ - return self._real_field().scientific_notation(status) + return self.real_field().scientific_notation(status) diff --git a/src/sage/rings/number_field/number_field_element_quadratic.pyx b/src/sage/rings/number_field/number_field_element_quadratic.pyx index 9ad624f42c9..37f1b18828d 100644 --- a/src/sage/rings/number_field/number_field_element_quadratic.pyx +++ b/src/sage/rings/number_field/number_field_element_quadratic.pyx @@ -55,7 +55,7 @@ from sage.rings.real_double import RDF from sage.rings.complex_double import CDF from sage.categories.morphism cimport Morphism from sage.rings.number_field.number_field_element import _inverse_mod_generic -from sage.rings.real_mpfi cimport RealIntervalFieldElement +from sage.rings.real_mpfi cimport RealIntervalField_class from sage.rings.complex_interval cimport ComplexIntervalFieldElement from sage.rings.real_arb cimport RealBall from sage.rings.complex_arb cimport ComplexBall @@ -576,7 +576,7 @@ cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute): From: Number Field in a with defining polynomial x^2 - 5 To: Real Interval Field with 53 bits of precision """ - ans = RealIntervalFieldElement.__new__(RealIntervalFieldElement, R) + ans = (R)._new() if mpz_cmp_ui(self.b, 0): if mpz_cmp_ui(self.D.value, 0) < 0: diff --git a/src/sage/rings/real_interval_field.py b/src/sage/rings/real_interval_field.py index 2c7df5581a7..97a32ae67cc 100644 --- a/src/sage/rings/real_interval_field.py +++ b/src/sage/rings/real_interval_field.py @@ -2,6 +2,9 @@ Field of Arbitrary Precision Real Number Intervals """ +from sage.misc.superseded import deprecation +deprecation(24371, "sage.rings.real_interval_field is deprecated") + from sage.rings.real_mpfi import RealIntervalField_class, RealIntervalFieldElement def is_RealIntervalField(x): @@ -11,6 +14,8 @@ def is_RealIntervalField(x): EXAMPLES:: sage: from sage.rings.real_interval_field import is_RealIntervalField as is_RIF + doctest:...: DeprecationWarning: sage.rings.real_interval_field is deprecated + See http://trac.sagemath.org/24371 for details. sage: is_RIF(RIF) True """ diff --git a/src/sage/rings/real_mpfi.pxd b/src/sage/rings/real_mpfi.pxd index fc54c3c7a51..c32dcc959d0 100644 --- a/src/sage/rings/real_mpfi.pxd +++ b/src/sage/rings/real_mpfi.pxd @@ -33,7 +33,8 @@ cdef class RealIntervalField_class(Field): cdef inline RealIntervalFieldElement _new(self): """Return a new real interval with parent ``self``.""" - return RealIntervalFieldElement.__new__(RealIntervalFieldElement, self) + t = self.element_class + return (t.__new__(t, self)) cdef class RealIntervalFieldElement(RingElement): @@ -41,9 +42,7 @@ cdef class RealIntervalFieldElement(RingElement): cdef inline RealIntervalFieldElement _new(self): """Return a new real interval with same parent as ``self``.""" - return RealIntervalFieldElement.__new__(RealIntervalFieldElement, self._parent) - cpdef _add_(self, other) - cpdef _mul_(self, other) + return (self._parent)._new() cdef RealIntervalFieldElement abs(RealIntervalFieldElement self) cdef Rational _simplest_rational_helper(self) cpdef _str_question_style(self, int base, int error_digits, e, bint prefer_sci) diff --git a/src/sage/rings/real_mpfi.pyx b/src/sage/rings/real_mpfi.pyx index 0cada5d3e48..0c1bcac566d 100644 --- a/src/sage/rings/real_mpfi.pyx +++ b/src/sage/rings/real_mpfi.pyx @@ -692,9 +692,9 @@ cdef class RealIntervalField_class(Field): # Note: we override Parent.__call__ because we want to support # RIF(a, b) and that is hard to do using coerce maps. if y is not None: - return RealIntervalFieldElement(self, [x, y], **kwds) + return self.element_class(self, [x, y], **kwds) if kwds: - return RealIntervalFieldElement(self, x, **kwds) + return self.element_class(self, x, **kwds) return Parent.__call__(self, x) def algebraic_closure(self): @@ -1081,7 +1081,6 @@ cdef class RealIntervalField_class(Field): sage: R.pi().sqrt()/2 0.886226925452758013649083741670572591398774728? """ - cdef RealIntervalFieldElement x x = self._new() mpfi_const_pi(x.value) return x @@ -1095,24 +1094,10 @@ cdef class RealIntervalField_class(Field): sage: RealIntervalField(100).euler_constant() 0.577215664901532860606512090083? """ - cdef RealIntervalFieldElement x x = self._new() mpfi_const_euler(x.value) return x -# def catalan_constant(self): -# """ -# Returns Catalan's constant to the precision of this field. - -# EXAMPLES: -# sage: RealIntervalField(100).catalan_constant() -# 0.91596559417721901505460351493 -# """ -# cdef RealIntervalFieldElement x -# x = self._new() -# mpfr_const_catalan(x.value, self.rnd) -# return x - def log2(self): r""" Returns `\log(2)` to the precision of this field. @@ -1125,7 +1110,6 @@ cdef class RealIntervalField_class(Field): sage: R(2).log() 0.693147180559945309417232121458? """ - cdef RealIntervalFieldElement x x = self._new() mpfi_const_log2(x.value) return x @@ -2362,8 +2346,8 @@ cdef class RealIntervalFieldElement(RingElement): sage: RIF(pi).edges() (3.1415926535897932?, 3.1415926535897936?) """ - cdef RealIntervalFieldElement left = self._new() - cdef RealIntervalFieldElement right = self._new() + left = self._new() + right = self._new() cdef mpfr_t x mpfr_init2(x, self.prec()) mpfi_get_left(x, self.value) @@ -2567,8 +2551,8 @@ cdef class RealIntervalFieldElement(RingElement): sage: a.union(b).endpoints() == I.endpoints() True """ - cdef RealIntervalFieldElement left = self._new() - cdef RealIntervalFieldElement right = self._new() + left = self._new() + right = self._new() mpfr_set(&left.value.left, &self.value.left, MPFR_RNDN) mpfi_mid(&left.value.right, self.value) mpfi_interv_fr(right.value, &left.value.right, &self.value.right) @@ -2606,7 +2590,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: (R(1, 2) + R(3, 4)).str(style='brackets') '[4.0000000000000000 .. 6.0000000000000000]' """ - cdef RealIntervalFieldElement x x = self._new() mpfi_add(x.value, self.value, (other).value) return x @@ -2633,7 +2616,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: ~RIF(-1, 1) [-infinity .. +infinity] """ - cdef RealIntervalFieldElement x x = self._new() mpfi_inv(x.value, self.value) return x @@ -2652,7 +2634,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: (R(1, 2) - R(3, 4)).str(style='brackets') '[-3.0000000000000000 .. -1.0000000000000000]' """ - cdef RealIntervalFieldElement x x = self._new() mpfi_sub(x.value, self.value, (right).value) return x @@ -2689,7 +2670,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: parent(b*a) Real Interval Field with 20 bits of precision """ - cdef RealIntervalFieldElement x x = self._new() mpfi_mul(x.value, self.value, (right).value) return x @@ -2717,9 +2697,8 @@ cdef class RealIntervalFieldElement(RingElement): sage: (R(1, 2) / R(3, 4)).str(style='brackets') '[0.25000000000000000 .. 0.66666666666666675]' """ - cdef RealIntervalFieldElement x x = self._new() - mpfi_div((x).value, self.value, + mpfi_div(x.value, self.value, (right).value) return x @@ -2743,8 +2722,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: (v + -v).str(style='brackets') '[-1.0000000000000000 .. 1.0000000000000000]' """ - - cdef RealIntervalFieldElement x x = self._new() mpfi_neg(x.value, self.value) return x @@ -2764,7 +2741,7 @@ cdef class RealIntervalFieldElement(RingElement): """ return self.abs() - cdef RealIntervalFieldElement abs(RealIntervalFieldElement self): + cdef RealIntervalFieldElement abs(self): """ Return the absolute value of ``self``. @@ -2777,7 +2754,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: RIF(-2.1).abs() 2.1000000000000001? """ - cdef RealIntervalFieldElement x x = self._new() mpfi_abs(x.value, self.value) return x @@ -2800,14 +2776,12 @@ cdef class RealIntervalFieldElement(RingElement): sage: (RIF(-1, 1) * RIF(-1, 1)).str(style='brackets') '[-1.0000000000000000 .. 1.0000000000000000]' """ - - cdef RealIntervalFieldElement x x = self._new() mpfi_sqr(x.value, self.value) return x # Bit shifting - def _lshift_(RealIntervalFieldElement self, n): + def _lshift_(self, n): """ Return ``self*(2^n)`` for an integer ``n``. @@ -2818,7 +2792,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: RIF(1.5)._lshift_(2) 6 """ - cdef RealIntervalFieldElement x if n > sys.maxsize: raise OverflowError("n (=%s) must be <= %s" % (n, sys.maxsize)) x = self._new() @@ -2839,7 +2812,7 @@ cdef class RealIntervalFieldElement(RingElement): return x._lshift_(y) return sage.structure.element.bin_op(x, y, operator.lshift) - def _rshift_(RealIntervalFieldElement self, n): + def _rshift_(self, n): """ Return ``self/(2^n)`` for an integer ``n``. @@ -2852,7 +2825,6 @@ cdef class RealIntervalFieldElement(RingElement): """ if n > sys.maxsize: raise OverflowError("n (=%s) must be <= %s" % (n, sys.maxsize)) - cdef RealIntervalFieldElement x x = self._new() mpfi_div_2exp(x.value, self.value, n) return x @@ -3962,7 +3934,6 @@ cdef class RealIntervalFieldElement(RingElement): ... ValueError: intersection of non-overlapping intervals """ - cdef RealIntervalFieldElement x x = self._new() cdef RealIntervalFieldElement other_intv if isinstance(other, RealIntervalFieldElement): @@ -3992,8 +3963,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: RIF(1).union(RIF(-1)).str(style='brackets') '[-1.0000000000000000 .. 1.0000000000000000]' """ - - cdef RealIntervalFieldElement x x = self._new() cdef RealIntervalFieldElement other_intv cdef RealNumber other_rn @@ -4293,7 +4262,6 @@ cdef class RealIntervalFieldElement(RingElement): ... ValueError: self (=-2) is not >= 0 """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_sqrt(x.value, self.value) @@ -4324,7 +4292,6 @@ cdef class RealIntervalFieldElement(RingElement): return RingElement.__pow__(self, exponent) return (self.log() * exponent).exp() - def log(self, base='e'): """ Return the logarithm of ``self`` to the given ``base``. @@ -4337,7 +4304,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: r = R(-2); r.log() 0.6931471805599453? + 3.141592653589794?*I """ - cdef RealIntervalFieldElement x if self < 0: return self.parent().complex_field()(self).log(base) if base == 'e': @@ -4374,7 +4340,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: r.log2() [-infinity .. 1.0000000000000000] """ - cdef RealIntervalFieldElement x if self < 0: return self.parent().complex_field()(self).log(2) x = self._new() @@ -4411,7 +4376,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: r.log10() 1.364376353841841?*I """ - cdef RealIntervalFieldElement x if self < 0: return self.parent().complex_field()(self).log(10) x = self._new() @@ -4444,7 +4408,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: r.exp() 9.38184458849869?e-15 """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_exp(x.value, self.value) @@ -4473,7 +4436,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: r.exp2() 1.891172482530207?e-10 """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_exp2(x.value, self.value) @@ -4523,31 +4485,6 @@ cdef class RealIntervalFieldElement(RingElement): else: return False, None -# MPFI does not have exp10. (Could easily be synthesized if anybody cares.) -# def exp10(self): -# r""" -# Returns $10^\code{self}$ - -# EXAMPLES: -# sage: r = 0.0 -# sage: r.exp10() -# 1.00000000000000 - -# sage: r = 32.0 -# sage: r.exp10() -# 100000000000000000000000000000000 - -# sage: r = -32.3 -# sage: r.exp10() -# 0.00000000000000000000000000000000501187233627275 -# """ -# cdef RealIntervalFieldElement x -# x = self._new() -# sig_on() -# mpfr_exp10(x.value, self.value, (self._parent).rnd) -# sig_off() -# return x - def cos(self): """ Return the cosine of ``self``. @@ -4570,7 +4507,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: RIF(-1, 1).cos().str(style='brackets') '[0.54030230586813965 .. 1.0000000000000000]' """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_cos(x.value, self.value) @@ -4587,7 +4523,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: R(2).sin() 0.909297426825681695396019865912? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_sin(x.value, self.value) @@ -4607,32 +4542,12 @@ cdef class RealIntervalFieldElement(RingElement): sage: q.tan() 0.577350269189626? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_tan(x.value, self.value) sig_off() return x -# MPFI does not have sincos -# def sincos(self): -# """ -# Returns a pair consisting of the sine and cosine. - -# EXAMPLES: -# sage: R = RealIntervalField() -# sage: t = R.pi()/6 -# sage: t.sincos() -# (0.499999999999999, 0.866025403784438) -# """ -# cdef RealIntervalFieldElement x,y -# x = self._new() -# y = self._new() -# sig_on() -# mpfi_sin_cos(x.value, y.value, self.value) -# sig_off() -# return x,y - def arccos(self): """ Return the inverse cosine of ``self``. @@ -4656,7 +4571,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q in q2 True """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_acos(x.value, self.value) @@ -4686,7 +4600,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q in q2 True """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_asin(x.value, self.value) @@ -4716,7 +4629,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q in q2 True """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_atan(x.value, self.value) @@ -4733,7 +4645,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q.cosh() 1.034465640095511? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_cosh(x.value, self.value) @@ -4750,7 +4661,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q.sinh() 0.2648002276022707? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_sinh(x.value, self.value) @@ -4767,7 +4677,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: q.tanh() 0.2780794292958503? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_tanh(x.value, self.value) @@ -4784,7 +4693,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: i = q.arccosh() ; i 1.023227478547551? """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_acosh(x.value, self.value) @@ -4803,7 +4711,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: i.arcsinh() - q 0.?e-15 """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_asinh(x.value, self.value) @@ -4822,7 +4729,6 @@ cdef class RealIntervalFieldElement(RingElement): sage: i.arctanh() - q 0.?e-15 """ - cdef RealIntervalFieldElement x x = self._new() sig_on() mpfi_atanh(x.value, self.value) @@ -5069,7 +4975,7 @@ cdef class RealIntervalFieldElement(RingElement): sage: gamma(RIF(-3/2,-1/2)) [-infinity .. +infinity] """ - cdef RealIntervalFieldElement x = self._new() + x = self._new() if self > 1.462: # increasing mpfr_gamma(&x.value.left, &self.value.left, MPFR_RNDD) @@ -5114,65 +5020,6 @@ cdef class RealIntervalFieldElement(RingElement): from sage.rings.real_arb import RealBallField return RealBallField(self.precision())(self).psi()._real_mpfi_(self._parent) -# MPFI does not have: agm, erf, gamma, zeta -# def agm(self, other): -# """ -# Return the arithmetic-geometric mean of self and other. The -# arithmetic-geometric mean is the common limit of the sequences -# $u_n$ and $v_n$, where $u_0$ is self, $v_0$ is other, -# $u_{n+1}$ is the arithmetic mean of $u_n$ and $v_n$, and -# $v_{n+1}$ is the geometric mean of u_n and v_n. If any operand -# is negative, the return value is \code{NaN}. -# """ -# cdef RealIntervalFieldElement x, _other -# if not isinstance(other, RealIntervalFieldElement) or other.parent() != self._parent: -# _other = self._parent(other) -# else: -# _other = other -# x = self._new() -# sig_on() -# mpfi_agm(x.value, self.value, _other.value) -# sig_off() -# return x - - -# def erf(self): -# """ -# Return the value of the error function on ``self``. - -# EXAMPLES:: -# -# sage: R = RealIntervalField() -# sage: R(6).erf() -# 0.999999999999999 -# """ -# cdef RealIntervalFieldElement x -# x = self._new() -# sig_on() -# mpfi_erf(x.value, self.value) -# sig_off() -# return x - - -# def gamma(self): -# """ -# The Euler gamma function. Return gamma of self. - -# EXAMPLES:: -# -# sage: R = RealIntervalField() -# sage: R(6).gamma() -# 120.000000000000 -# sage: R(1.5).gamma() -# 0.886226925452757 -# """ -# cdef RealIntervalFieldElement x -# x = self._new() -# sig_on() -# mpfi_gamma(x.value, self.value) -# sig_off() -# return x - def zeta(self, a=None): """ Return the image of this interval by the Hurwitz zeta function. @@ -5401,4 +5248,4 @@ def __create__RealIntervalFieldElement_version1(parent, lower, upper): sage: sage.rings.real_mpfi.__create__RealIntervalFieldElement_version1(RIF, 2.225, 2.227) 2.226? """ - return RealIntervalFieldElement(parent, (lower, upper)) + return parent([lower, upper])