Arbitrary precision real balls

This is a binding to the arb module of FLINT. It may be useful to refer to its documentation for more details.

Parts of the documentation for this module are copied or adapted from Arb’s (now FLINT’s) own documentation, licenced (at the time) under the GNU General Public License version 2, or later.

See also

• Complex balls

• Real intervals using MPFI

Data Structure

Ball arithmetic, also known as mid-rad interval arithmetic, is an extension of floating-point arithmetic in which an error bound is attached to each variable. This allows doing rigorous computations over the real numbers, while avoiding the overhead of traditional (inf-sup) interval arithmetic at high precision, and eliminating much of the need for time-consuming and bug-prone manual error analysis associated with standard floating-point arithmetic.

Sage RealBall objects wrap FLINT objects of type arb_t. A real ball represents a ball over the real numbers, that is, an interval \([m-r,m+r]\) where the midpoint \(m\) and the radius \(r\) are (extended) real numbers:

Sage

sage: RBF(pi)                                                                       # needs sage.symbolic
[3.141592653589793 +/- ...e-16]
sage: RBF(pi).mid(), RBF(pi).rad()                                                  # needs sage.symbolic
(3.14159265358979, ...e-16)

Python

>>> from sage.all import *
>>> RBF(pi)                                                                       # needs sage.symbolic
[3.141592653589793 +/- ...e-16]
>>> RBF(pi).mid(), RBF(pi).rad()                                                  # needs sage.symbolic
(3.14159265358979, ...e-16)

Sage Live

RBF(pi)                                                                       # needs sage.symbolic
RBF(pi).mid(), RBF(pi).rad()                                                  # needs sage.symbolic

The midpoint is represented as an arbitrary-precision floating-point number with arbitrary-precision exponent. The radius is a floating-point number with fixed-precision mantissa and arbitrary-precision exponent.

Sage

sage: RBF(2)^(2^100)
[2.285367694229514e+381600854690147056244358827360 +/- ...e+381600854690147056244358827344]

Python

>>> from sage.all import *
>>> RBF(Integer(2))**(Integer(2)**Integer(100))
[2.285367694229514e+381600854690147056244358827360 +/- ...e+381600854690147056244358827344]

Sage Live

RBF(2)^(2^100)

RealBallField objects (the parents of real balls) model the field of real numbers represented by balls on which computations are carried out with a certain precision:

Sage

sage: RBF
Real ball field with 53 bits of precision

Python

>>> from sage.all import *
>>> RBF
Real ball field with 53 bits of precision

Sage Live

RBF

It is possible to construct a ball whose parent is the real ball field with precision \(p\) but whose midpoint does not fit on \(p\) bits. However, the results of operations involving such a ball will (usually) be rounded to its parent’s precision:

Sage

sage: RBF(factorial(50)).mid(), RBF(factorial(50)).rad()
(3.0414093201713378043612608166064768844377641568961e64, 0.00000000)
sage: (RBF(factorial(50)) + 0).mid()
3.04140932017134e64

Python

>>> from sage.all import *
>>> RBF(factorial(Integer(50))).mid(), RBF(factorial(Integer(50))).rad()
(3.0414093201713378043612608166064768844377641568961e64, 0.00000000)
>>> (RBF(factorial(Integer(50))) + Integer(0)).mid()
3.04140932017134e64

Sage Live

RBF(factorial(50)).mid(), RBF(factorial(50)).rad()
(RBF(factorial(50)) + 0).mid()

Comparison

Warning

In accordance with the semantics of FLINT/Arb, identical RealBall objects are understood to give permission for algebraic simplification. This assumption is made to improve performance. For example, setting z = x*x may set \(z\) to a ball enclosing the set \(\{t^2 : t \in x\}\) and not the (generally larger) set \(\{tu : t \in x, u \in x\}\).

Two elements are equal if and only if they are exact and equal (in spite of the above warning, inexact balls are not considered equal to themselves):

Sage

sage: a = RBF(1)
sage: b = RBF(1)
sage: a is b
False
sage: a == a
True
sage: a == b
True

Python

>>> from sage.all import *
>>> a = RBF(Integer(1))
>>> b = RBF(Integer(1))
>>> a is b
False
>>> a == a
True
>>> a == b
True

Sage Live

a = RBF(1)
b = RBF(1)
a is b
a == a
a == b

Sage

Sage

sage: a = RBF(1/3)
sage: b = RBF(1/3)
sage: a.is_exact()
False
sage: b.is_exact()
False
sage: a is b
False
sage: a == a
False
sage: a == b
False

Python

>>> from sage.all import *
>>> a = RBF(Integer(1)/Integer(3))
>>> b = RBF(Integer(1)/Integer(3))
>>> a.is_exact()
False
>>> b.is_exact()
False
>>> a is b
False
>>> a == a
False
>>> a == b
False

Sage Live

a = RBF(1/3)
b = RBF(1/3)
a.is_exact()
b.is_exact()
a is b
a == a
a == b

Python

>>> from sage.all import *
>>> a = RBF(Integer(1)/Integer(3))
>>> b = RBF(Integer(1)/Integer(3))
>>> a.is_exact()
False
>>> b.is_exact()
False
>>> a is b
False
>>> a == a
False
>>> a == b
False

Sage Live

a = RBF(1/3)
b = RBF(1/3)
a.is_exact()
b.is_exact()
a is b
a == a
a == b

A ball is nonzero in the sense of comparison if and only if it does not contain zero.

Sage

sage: a = RBF(RIF(-0.5, 0.5))
sage: a != 0
False
sage: b = RBF(1/3)
sage: b != 0
True

Python

>>> from sage.all import *
>>> a = RBF(RIF(-RealNumber('0.5'), RealNumber('0.5')))
>>> a != Integer(0)
False
>>> b = RBF(Integer(1)/Integer(3))
>>> b != Integer(0)
True

Sage Live

a = RBF(RIF(-0.5, 0.5))
a != 0
b = RBF(1/3)
b != 0

However, bool(b) returns False for a ball b only if b is exactly zero:

Sage

sage: bool(a)
True
sage: bool(b)
True
sage: bool(RBF.zero())
False

Python

>>> from sage.all import *
>>> bool(a)
True
>>> bool(b)
True
>>> bool(RBF.zero())
False

Sage Live

bool(a)
bool(b)
bool(RBF.zero())

A ball left is less than a ball right if all elements of left are less than all elements of right.

Sage

sage: a = RBF(RIF(1, 2))
sage: b = RBF(RIF(3, 4))
sage: a < b
True
sage: a <= b
True
sage: a > b
False
sage: a >= b
False
sage: a = RBF(RIF(1, 3))
sage: b = RBF(RIF(2, 4))
sage: a < b
False
sage: a <= b
False
sage: a > b
False
sage: a >= b
False

Python

>>> from sage.all import *
>>> a = RBF(RIF(Integer(1), Integer(2)))
>>> b = RBF(RIF(Integer(3), Integer(4)))
>>> a < b
True
>>> a <= b
True
>>> a > b
False
>>> a >= b
False
>>> a = RBF(RIF(Integer(1), Integer(3)))
>>> b = RBF(RIF(Integer(2), Integer(4)))
>>> a < b
False
>>> a <= b
False
>>> a > b
False
>>> a >= b
False

Sage Live

a = RBF(RIF(1, 2))
b = RBF(RIF(3, 4))
a < b
a <= b
a > b
a >= b
a = RBF(RIF(1, 3))
b = RBF(RIF(2, 4))
a < b
a <= b
a > b
a >= b

Comparisons with Sage symbolic infinities work with some limitations:

Sage

sage: -infinity < RBF(1) < +infinity
True
sage: -infinity < RBF(infinity)
True
sage: RBF(infinity) < infinity
False
sage: RBF(NaN) < infinity                                                           # needs sage.symbolic
Traceback (most recent call last):
...
ValueError: infinite but not with +/- phase
sage: 1/RBF(0) <= infinity
Traceback (most recent call last):
...
ValueError: infinite but not with +/- phase

Python

>>> from sage.all import *
>>> -infinity < RBF(Integer(1)) < +infinity
True
>>> -infinity < RBF(infinity)
True
>>> RBF(infinity) < infinity
False
>>> RBF(NaN) < infinity                                                           # needs sage.symbolic
Traceback (most recent call last):
...
ValueError: infinite but not with +/- phase
>>> Integer(1)/RBF(Integer(0)) <= infinity
Traceback (most recent call last):
...
ValueError: infinite but not with +/- phase

Sage Live

-infinity < RBF(1) < +infinity
-infinity < RBF(infinity)
RBF(infinity) < infinity
RBF(NaN) < infinity                                                           # needs sage.symbolic
1/RBF(0) <= infinity

Comparisons between elements of real ball fields, however, support special values and should be preferred:

Sage

sage: RBF(NaN) < RBF(infinity)                                                      # needs sage.symbolic
False
sage: RBF(0).add_error(infinity) <= RBF(infinity)
True

Python

>>> from sage.all import *
>>> RBF(NaN) < RBF(infinity)                                                      # needs sage.symbolic
False
>>> RBF(Integer(0)).add_error(infinity) <= RBF(infinity)
True

Sage Live

RBF(NaN) < RBF(infinity)                                                      # needs sage.symbolic
RBF(0).add_error(infinity) <= RBF(infinity)

Classes and Methods

class sage.rings.real_arb.RealBall

Bases: RingElement

Hold one arb_t.

EXAMPLES:

Sage

sage: a = RealBallField()(RIF(1))                     # indirect doctest
sage: b = a.psi()
sage: b # abs tol 1e-15
[-0.5772156649015329 +/- 4.84e-17]
sage: RIF(b)
-0.577215664901533?

Python

>>> from sage.all import *
>>> a = RealBallField()(RIF(Integer(1)))                     # indirect doctest
>>> b = a.psi()
>>> b # abs tol 1e-15
[-0.5772156649015329 +/- 4.84e-17]
>>> RIF(b)
-0.577215664901533?

Sage Live

a = RealBallField()(RIF(1))                     # indirect doctest
b = a.psi()
b # abs tol 1e-15
RIF(b)

Chi()

Hyperbolic cosine integral.

EXAMPLES:

Sage

sage: RBF(1).Chi()  # abs tol 1e-17
[0.837866940980208 +/- 4.72e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Chi()  # abs tol 1e-17
[0.837866940980208 +/- 4.72e-16]

Sage Live

RBF(1).Chi()  # abs tol 1e-17

Ci()

Cosine integral.

EXAMPLES:

Sage

sage: RBF(1).Ci()  # abs tol 5e-16
[0.337403922900968 +/- 3.25e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Ci()  # abs tol 5e-16
[0.337403922900968 +/- 3.25e-16]

Sage Live

RBF(1).Ci()  # abs tol 5e-16

Ei()

Exponential integral.

EXAMPLES:

Sage

sage: RBF(1).Ei()  # abs tol 5e-16
[1.89511781635594 +/- 4.94e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Ei()  # abs tol 5e-16
[1.89511781635594 +/- 4.94e-15]

Sage Live

RBF(1).Ei()  # abs tol 5e-16

Li()

Offset logarithmic integral.

EXAMPLES:

Sage

sage: RBF(3).Li()  # abs tol 1e-15
[1.11842481454970 +/- 7.61e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(3)).Li()  # abs tol 1e-15
[1.11842481454970 +/- 7.61e-15]

Sage Live

RBF(3).Li()  # abs tol 1e-15

Shi()

Hyperbolic sine integral.

EXAMPLES:

Sage

sage: RBF(1).Shi()
[1.05725087537573 +/- 2.77e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Shi()
[1.05725087537573 +/- 2.77e-15]

Sage Live

RBF(1).Shi()

Si()

Sine integral.

EXAMPLES:

Sage

sage: RBF(1).Si() # abs tol 1e-15
[0.946083070367183 +/- 9.22e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Si() # abs tol 1e-15
[0.946083070367183 +/- 9.22e-16]

Sage Live

RBF(1).Si() # abs tol 1e-15

above_abs()

Return an upper bound for the absolute value of this ball.

OUTPUT: a ball with zero radius

EXAMPLES:

Sage

sage: b = RealBallField(8)(1/3).above_abs()
sage: b
[0.33 +/- ...e-3]
sage: b.is_exact()
True
sage: QQ(b)
171/512

Python

>>> from sage.all import *
>>> b = RealBallField(Integer(8))(Integer(1)/Integer(3)).above_abs()
>>> b
[0.33 +/- ...e-3]
>>> b.is_exact()
True
>>> QQ(b)
171/512

Sage Live

b = RealBallField(8)(1/3).above_abs()
b
b.is_exact()
QQ(b)

See also

below_abs()

accuracy()

Return the effective relative accuracy of this ball measured in bits.

The accuracy is defined as the difference between the position of the top bit in the midpoint and the top bit in the radius, minus one. The result is clamped between plus/minus maximal_accuracy().

EXAMPLES:

Sage

sage: RBF(pi).accuracy()                                                    # needs sage.symbolic
52
sage: RBF(1).accuracy() == RBF.maximal_accuracy()
True
sage: RBF(NaN).accuracy() == -RBF.maximal_accuracy()                        # needs sage.symbolic
True

Python

>>> from sage.all import *
>>> RBF(pi).accuracy()                                                    # needs sage.symbolic
52
>>> RBF(Integer(1)).accuracy() == RBF.maximal_accuracy()
True
>>> RBF(NaN).accuracy() == -RBF.maximal_accuracy()                        # needs sage.symbolic
True

Sage Live

RBF(pi).accuracy()                                                    # needs sage.symbolic
RBF(1).accuracy() == RBF.maximal_accuracy()
RBF(NaN).accuracy() == -RBF.maximal_accuracy()                        # needs sage.symbolic

See also

maximal_accuracy()

add_error(ampl)

Increase the radius of this ball by (an upper bound on) ampl.

If ampl is negative, the radius is unchanged.

INPUT:

• ampl – a real ball (or an object that can be coerced to a real ball)

OUTPUT: a new real ball

EXAMPLES:

Sage

sage: err = RBF(10^-16)
sage: RBF(1).add_error(err)
[1.000000000000000 +/- ...e-16]

Python

>>> from sage.all import *
>>> err = RBF(Integer(10)**-Integer(16))
>>> RBF(Integer(1)).add_error(err)
[1.000000000000000 +/- ...e-16]

Sage Live

err = RBF(10^-16)
RBF(1).add_error(err)

agm(other)

Return the arithmetic-geometric mean of self and other.

EXAMPLES:

Sage

sage: RBF(1).agm(1)
1.000000000000000
sage: RBF(sqrt(2)).agm(1)^(-1)                                              # needs sage.symbolic
[0.8346268416740...]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).agm(Integer(1))
1.000000000000000
>>> RBF(sqrt(Integer(2))).agm(Integer(1))**(-Integer(1))                                              # needs sage.symbolic
[0.8346268416740...]

Sage Live

RBF(1).agm(1)
RBF(sqrt(2)).agm(1)^(-1)                                              # needs sage.symbolic

arccos()

Return the arccosine of this ball.

EXAMPLES:

Sage

sage: RBF(1).arccos()
0
sage: RBF(1, rad=.125r).arccos()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1)).arccos()
0
>>> RBF(Integer(1), rad=.125).arccos()
nan

Sage Live

RBF(1).arccos()
RBF(1, rad=.125r).arccos()

arccosh()

Return the inverse hyperbolic cosine of this ball.

EXAMPLES:

Sage

sage: RBF(2).arccosh()
[1.316957896924817 +/- ...e-16]
sage: RBF(1).arccosh()
0
sage: RBF(0).arccosh()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(2)).arccosh()
[1.316957896924817 +/- ...e-16]
>>> RBF(Integer(1)).arccosh()
0
>>> RBF(Integer(0)).arccosh()
nan

Sage Live

RBF(2).arccosh()
RBF(1).arccosh()
RBF(0).arccosh()

arcsin()

Return the arcsine of this ball.

EXAMPLES:

Sage

sage: RBF(1).arcsin()
[1.570796326794897 +/- ...e-16]
sage: RBF(1, rad=.125r).arcsin()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1)).arcsin()
[1.570796326794897 +/- ...e-16]
>>> RBF(Integer(1), rad=.125).arcsin()
nan

Sage Live

RBF(1).arcsin()
RBF(1, rad=.125r).arcsin()

arcsinh()

Return the inverse hyperbolic sine of this ball.

EXAMPLES:

Sage

sage: RBF(1).arcsinh()
[0.881373587019543 +/- ...e-16]
sage: RBF(0).arcsinh()
0

Python

>>> from sage.all import *
>>> RBF(Integer(1)).arcsinh()
[0.881373587019543 +/- ...e-16]
>>> RBF(Integer(0)).arcsinh()
0

Sage Live

RBF(1).arcsinh()
RBF(0).arcsinh()

arctan()

Return the arctangent of this ball.

EXAMPLES:

Sage

sage: RBF(1).arctan()
[0.7853981633974483 +/- ...e-17]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).arctan()
[0.7853981633974483 +/- ...e-17]

Sage Live

RBF(1).arctan()

arctanh()

Return the inverse hyperbolic tangent of this ball.

EXAMPLES:

Sage

sage: RBF(0).arctanh()
0
sage: RBF(1/2).arctanh()
[0.549306144334055 +/- ...e-16]
sage: RBF(1).arctanh()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(0)).arctanh()
0
>>> RBF(Integer(1)/Integer(2)).arctanh()
[0.549306144334055 +/- ...e-16]
>>> RBF(Integer(1)).arctanh()
nan

Sage Live

RBF(0).arctanh()
RBF(1/2).arctanh()
RBF(1).arctanh()

below_abs(test_zero=False)

Return a lower bound for the absolute value of this ball.

INPUT:

• test_zero – boolean (default: False); if True, make sure that the returned lower bound is positive, raising an error if the ball contains zero.

OUTPUT: a ball with zero radius

EXAMPLES:

Sage

sage: RealBallField(8)(1/3).below_abs()
[0.33 +/- ...e-5]
sage: b = RealBallField(8)(1/3).below_abs()
sage: b
[0.33 +/- ...e-5]
sage: b.is_exact()
True
sage: QQ(b)
169/512

sage: RBF(0).below_abs()
0
sage: RBF(0).below_abs(test_zero=True)
Traceback (most recent call last):
...
ValueError: ball contains zero

Python

>>> from sage.all import *
>>> RealBallField(Integer(8))(Integer(1)/Integer(3)).below_abs()
[0.33 +/- ...e-5]
>>> b = RealBallField(Integer(8))(Integer(1)/Integer(3)).below_abs()
>>> b
[0.33 +/- ...e-5]
>>> b.is_exact()
True
>>> QQ(b)
169/512

>>> RBF(Integer(0)).below_abs()
0
>>> RBF(Integer(0)).below_abs(test_zero=True)
Traceback (most recent call last):
...
ValueError: ball contains zero

Sage Live

RealBallField(8)(1/3).below_abs()
b = RealBallField(8)(1/3).below_abs()
b
b.is_exact()
QQ(b)
RBF(0).below_abs()
RBF(0).below_abs(test_zero=True)

See also

above_abs()

beta(a, z=1)

(Incomplete) beta function.

INPUT:

• a, z – (optional) real balls

OUTPUT:

The lower incomplete beta function \(B(self, a, z)\).

With the default value of z, the complete beta function \(B(self, a)\).

EXAMPLES:

Sage

sage: RBF(sin(3)).beta(RBF(2/3).sqrt())  # abs tol 1e-13                    # needs sage.symbolic
[7.407661629415 +/- 1.07e-13]
sage: RealBallField(100)(7/2).beta(1)  # abs tol 1e-30
[0.28571428571428571428571428571 +/- 5.23e-30]
sage: RealBallField(100)(7/2).beta(1, 1/2)
[0.025253813613805268728601584361 +/- 2.53e-31]

Python

>>> from sage.all import *
>>> RBF(sin(Integer(3))).beta(RBF(Integer(2)/Integer(3)).sqrt())  # abs tol 1e-13                    # needs sage.symbolic
[7.407661629415 +/- 1.07e-13]
>>> RealBallField(Integer(100))(Integer(7)/Integer(2)).beta(Integer(1))  # abs tol 1e-30
[0.28571428571428571428571428571 +/- 5.23e-30]
>>> RealBallField(Integer(100))(Integer(7)/Integer(2)).beta(Integer(1), Integer(1)/Integer(2))
[0.025253813613805268728601584361 +/- 2.53e-31]

Sage Live

RBF(sin(3)).beta(RBF(2/3).sqrt())  # abs tol 1e-13                    # needs sage.symbolic
RealBallField(100)(7/2).beta(1)  # abs tol 1e-30
RealBallField(100)(7/2).beta(1, 1/2)

Todo

At the moment RBF(beta(a,b)) does not work, one needs RBF(a).beta(b) for this to work. See Issue #32851 and Issue #24641.

ceil()

Return the ceil of this ball.

EXAMPLES:

Sage

sage: RBF(1000+1/3, rad=1.r).ceil()
[1.00e+3 +/- 2.01]

Python

>>> from sage.all import *
>>> RBF(Integer(1000)+Integer(1)/Integer(3), rad=1.).ceil()
[1.00e+3 +/- 2.01]

Sage Live

RBF(1000+1/3, rad=1.r).ceil()

center()

Return the center of this ball.

EXAMPLES:

Sage

sage: RealBallField(16)(1/3).mid()
0.3333
sage: RealBallField(16)(1/3).mid().parent()
Real Field with 16 bits of precision
sage: RealBallField(16)(RBF(1/3)).mid().parent()
Real Field with 53 bits of precision
sage: RBF('inf').mid()
+infinity

Python

>>> from sage.all import *
>>> RealBallField(Integer(16))(Integer(1)/Integer(3)).mid()
0.3333
>>> RealBallField(Integer(16))(Integer(1)/Integer(3)).mid().parent()
Real Field with 16 bits of precision
>>> RealBallField(Integer(16))(RBF(Integer(1)/Integer(3))).mid().parent()
Real Field with 53 bits of precision
>>> RBF('inf').mid()
+infinity

Sage Live

RealBallField(16)(1/3).mid()
RealBallField(16)(1/3).mid().parent()
RealBallField(16)(RBF(1/3)).mid().parent()
RBF('inf').mid()

Sage

Sage

sage: b = RBF(2)^(2^1000)
sage: b.mid()
+infinity

Python

>>> from sage.all import *
>>> b = RBF(Integer(2))**(Integer(2)**Integer(1000))
>>> b.mid()
+infinity

Sage Live

b = RBF(2)^(2^1000)
b.mid()

Python

>>> from sage.all import *
>>> b = RBF(Integer(2))**(Integer(2)**Integer(1000))
>>> b.mid()
+infinity

Sage Live

b = RBF(2)^(2^1000)
b.mid()

See also

rad(), squash()

chebyshev_T(n)

Evaluate the Chebyshev polynomial of the first kind T_n at this ball.

EXAMPLES:

Sage

sage: # needs sage.symbolic
sage: RBF(pi).chebyshev_T(0)
1.000000000000000
sage: RBF(pi).chebyshev_T(1)
[3.141592653589793 +/- ...e-16]
sage: RBF(pi).chebyshev_T(10**20)
Traceback (most recent call last):
...
ValueError: index too large
sage: RBF(pi).chebyshev_T(-1)
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Python

>>> from sage.all import *
>>> # needs sage.symbolic
>>> RBF(pi).chebyshev_T(Integer(0))
1.000000000000000
>>> RBF(pi).chebyshev_T(Integer(1))
[3.141592653589793 +/- ...e-16]
>>> RBF(pi).chebyshev_T(Integer(10)**Integer(20))
Traceback (most recent call last):
...
ValueError: index too large
>>> RBF(pi).chebyshev_T(-Integer(1))
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Sage Live

# needs sage.symbolic
RBF(pi).chebyshev_T(0)
RBF(pi).chebyshev_T(1)
RBF(pi).chebyshev_T(10**20)
RBF(pi).chebyshev_T(-1)

chebyshev_U(n)

Evaluate the Chebyshev polynomial of the second kind U_n at this ball.

EXAMPLES:

Sage

sage: # needs sage.symbolic
sage: RBF(pi).chebyshev_U(0)
1.000000000000000
sage: RBF(pi).chebyshev_U(1)
[6.283185307179586 +/- ...e-16]
sage: RBF(pi).chebyshev_U(10**20)
Traceback (most recent call last):
...
ValueError: index too large
sage: RBF(pi).chebyshev_U(-1)
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Python

>>> from sage.all import *
>>> # needs sage.symbolic
>>> RBF(pi).chebyshev_U(Integer(0))
1.000000000000000
>>> RBF(pi).chebyshev_U(Integer(1))
[6.283185307179586 +/- ...e-16]
>>> RBF(pi).chebyshev_U(Integer(10)**Integer(20))
Traceback (most recent call last):
...
ValueError: index too large
>>> RBF(pi).chebyshev_U(-Integer(1))
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Sage Live

# needs sage.symbolic
RBF(pi).chebyshev_U(0)
RBF(pi).chebyshev_U(1)
RBF(pi).chebyshev_U(10**20)
RBF(pi).chebyshev_U(-1)

contains_exact(other)

Return True iff the given number (or ball) other is contained in the interval represented by self.

If self contains NaN, this function always returns True (as it could represent anything, and in particular could represent all the points included in other). If other contains NaN and self does not, it always returns False.

Use other in self for a test that works for a wider range of inputs but may return false negatives.

EXAMPLES:

Sage

sage: b = RBF(1)
sage: b.contains_exact(1)
True
sage: b.contains_exact(QQ(1))
True
sage: b.contains_exact(1.)
True
sage: b.contains_exact(b)
True

Python

>>> from sage.all import *
>>> b = RBF(Integer(1))
>>> b.contains_exact(Integer(1))
True
>>> b.contains_exact(QQ(Integer(1)))
True
>>> b.contains_exact(RealNumber('1.'))
True
>>> b.contains_exact(b)
True

Sage Live

b = RBF(1)
b.contains_exact(1)
b.contains_exact(QQ(1))
b.contains_exact(1.)
b.contains_exact(b)

Sage

Sage

sage: RBF(1/3).contains_exact(1/3)
True
sage: RBF(sqrt(2)).contains_exact(sqrt(2))                                  # needs sage.symbolic
Traceback (most recent call last):
...
TypeError: unsupported type: <class 'sage.symbolic.expression.Expression'>

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).contains_exact(Integer(1)/Integer(3))
True
>>> RBF(sqrt(Integer(2))).contains_exact(sqrt(Integer(2)))                                  # needs sage.symbolic
Traceback (most recent call last):
...
TypeError: unsupported type: <class 'sage.symbolic.expression.Expression'>

Sage Live

RBF(1/3).contains_exact(1/3)
RBF(sqrt(2)).contains_exact(sqrt(2))                                  # needs sage.symbolic

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).contains_exact(Integer(1)/Integer(3))
True
>>> RBF(sqrt(Integer(2))).contains_exact(sqrt(Integer(2)))                                  # needs sage.symbolic
Traceback (most recent call last):
...
TypeError: unsupported type: <class 'sage.symbolic.expression.Expression'>

Sage Live

RBF(1/3).contains_exact(1/3)
RBF(sqrt(2)).contains_exact(sqrt(2))                                  # needs sage.symbolic

contains_integer()

Return True iff this ball contains any integer.

EXAMPLES:

Sage

sage: RBF(3.1, 0.1).contains_integer()
True
sage: RBF(3.1, 0.05).contains_integer()
False

Python

>>> from sage.all import *
>>> RBF(RealNumber('3.1'), RealNumber('0.1')).contains_integer()
True
>>> RBF(RealNumber('3.1'), RealNumber('0.05')).contains_integer()
False

Sage Live

RBF(3.1, 0.1).contains_integer()
RBF(3.1, 0.05).contains_integer()

contains_zero()

Return True iff this ball contains zero.

EXAMPLES:

Sage

sage: RBF(0).contains_zero()
True
sage: RBF(RIF(-1, 1)).contains_zero()
True
sage: RBF(1/3).contains_zero()
False

Python

>>> from sage.all import *
>>> RBF(Integer(0)).contains_zero()
True
>>> RBF(RIF(-Integer(1), Integer(1))).contains_zero()
True
>>> RBF(Integer(1)/Integer(3)).contains_zero()
False

Sage Live

RBF(0).contains_zero()
RBF(RIF(-1, 1)).contains_zero()
RBF(1/3).contains_zero()

cos()

Return the cosine of this ball.

EXAMPLES:

Sage

sage: RBF(pi).cos()                                                         # needs sage.symbolic
[-1.00000000000000 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(pi).cos()                                                         # needs sage.symbolic
[-1.00000000000000 +/- ...e-16]

Sage Live

RBF(pi).cos()                                                         # needs sage.symbolic

See also

cospi()

cos_integral()

Cosine integral.

EXAMPLES:

Sage

sage: RBF(1).Ci()  # abs tol 5e-16
[0.337403922900968 +/- 3.25e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Ci()  # abs tol 5e-16
[0.337403922900968 +/- 3.25e-16]

Sage Live

RBF(1).Ci()  # abs tol 5e-16

cosh()

Return the hyperbolic cosine of this ball.

EXAMPLES:

Sage

sage: RBF(1).cosh()
[1.543080634815244 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).cosh()
[1.543080634815244 +/- ...e-16]

Sage Live

RBF(1).cosh()

cosh_integral()

Hyperbolic cosine integral.

EXAMPLES:

Sage

sage: RBF(1).Chi()  # abs tol 1e-17
[0.837866940980208 +/- 4.72e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Chi()  # abs tol 1e-17
[0.837866940980208 +/- 4.72e-16]

Sage Live

RBF(1).Chi()  # abs tol 1e-17

cot()

Return the cotangent of this ball.

EXAMPLES:

Sage

sage: RBF(1).cot()
[0.642092615934331 +/- ...e-16]
sage: RBF(pi).cot()                                                         # needs sage.symbolic
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1)).cot()
[0.642092615934331 +/- ...e-16]
>>> RBF(pi).cot()                                                         # needs sage.symbolic
nan

Sage Live

RBF(1).cot()
RBF(pi).cot()                                                         # needs sage.symbolic

coth()

Return the hyperbolic cotangent of this ball.

EXAMPLES:

Sage

sage: RBF(1).coth()
[1.313035285499331 +/- ...e-16]
sage: RBF(0).coth()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1)).coth()
[1.313035285499331 +/- ...e-16]
>>> RBF(Integer(0)).coth()
nan

Sage Live

RBF(1).coth()
RBF(0).coth()

csc()

Return the cosecant of this ball.

EXAMPLES:

Sage

sage: RBF(1).csc()
[1.188395105778121 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).csc()
[1.188395105778121 +/- ...e-16]

Sage Live

RBF(1).csc()

csch()

Return the hyperbolic cosecant of this ball.

EXAMPLES:

Sage

sage: RBF(1).csch()
[0.850918128239321 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).csch()
[0.850918128239321 +/- ...e-16]

Sage Live

RBF(1).csch()

diameter()

Return the diameter of this ball.

EXAMPLES:

Sage

sage: RBF(1/3).diameter()
1.1102230e-16
sage: RBF(1/3).diameter().parent()
Real Field with 30 bits of precision
sage: RBF(RIF(1.02, 1.04)).diameter()
0.020000000

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).diameter()
1.1102230e-16
>>> RBF(Integer(1)/Integer(3)).diameter().parent()
Real Field with 30 bits of precision
>>> RBF(RIF(RealNumber('1.02'), RealNumber('1.04'))).diameter()
0.020000000

Sage Live

RBF(1/3).diameter()
RBF(1/3).diameter().parent()
RBF(RIF(1.02, 1.04)).diameter()

See also

rad(), rad_as_ball(), mid()

endpoints(rnd=None)

Return the endpoints of this ball, rounded outwards.

INPUT:

• rnd – string; rounding mode for the parent of the resulting floating-point numbers (does not affect their values!), see sage.rings.real_mpfi.RealIntervalFieldElement.upper()

OUTPUT: a pair of real numbers

EXAMPLES:

Sage

sage: RBF(-1/3).endpoints()
(-0.333333333333334, -0.333333333333333)

Python

>>> from sage.all import *
>>> RBF(-Integer(1)/Integer(3)).endpoints()
(-0.333333333333334, -0.333333333333333)

Sage Live

RBF(-1/3).endpoints()

See also

lower(), upper()

erf()

Error function.

EXAMPLES:

Sage

sage: RBF(1/2).erf() # abs tol 1e-16
[0.520499877813047 +/- 6.10e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).erf() # abs tol 1e-16
[0.520499877813047 +/- 6.10e-16]

Sage Live

RBF(1/2).erf() # abs tol 1e-16

erfi()

Imaginary error function.

EXAMPLES:

Sage

sage: RBF(1/2).erfi()
[0.614952094696511 +/- 2.22e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).erfi()
[0.614952094696511 +/- 2.22e-16]

Sage Live

RBF(1/2).erfi()

exp()

Return the exponential of this ball.

EXAMPLES:

Sage

sage: RBF(1).exp()
[2.718281828459045 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).exp()
[2.718281828459045 +/- ...e-16]

Sage Live

RBF(1).exp()

expm1()

Return exp(self) - 1, computed accurately when self is close to zero.

EXAMPLES:

Sage

sage: eps = RBF(1e-30)
sage: exp(eps) - 1
[+/- ...e-30]
sage: eps.expm1()
[1.000000000000000e-30 +/- ...e-47]

Python

>>> from sage.all import *
>>> eps = RBF(RealNumber('1e-30'))
>>> exp(eps) - Integer(1)
[+/- ...e-30]
>>> eps.expm1()
[1.000000000000000e-30 +/- ...e-47]

Sage Live

eps = RBF(1e-30)
exp(eps) - 1
eps.expm1()

floor()

Return the floor of this ball.

EXAMPLES:

Sage

sage: RBF(1000+1/3, rad=1.r).floor()
[1.00e+3 +/- 1.01]

Python

>>> from sage.all import *
>>> RBF(Integer(1000)+Integer(1)/Integer(3), rad=1.).floor()
[1.00e+3 +/- 1.01]

Sage Live

RBF(1000+1/3, rad=1.r).floor()

gamma(a=None)

Image of this ball by the (upper incomplete) Euler Gamma function.

For \(a\) real, return the upper incomplete Gamma function \(\Gamma(self,a)\).

For integer and rational arguments, gamma() may be faster.

EXAMPLES:

Sage

sage: RBF(1/2).gamma()
[1.772453850905516 +/- ...e-16]
sage: RBF(gamma(3/2, RBF(2).sqrt()))  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]
sage: RBF(3/2).gamma_inc(RBF(2).sqrt())  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).gamma()
[1.772453850905516 +/- ...e-16]
>>> RBF(gamma(Integer(3)/Integer(2), RBF(Integer(2)).sqrt()))  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]
>>> RBF(Integer(3)/Integer(2)).gamma_inc(RBF(Integer(2)).sqrt())  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]

Sage Live

RBF(1/2).gamma()
RBF(gamma(3/2, RBF(2).sqrt()))  # abs tol 2e-17
RBF(3/2).gamma_inc(RBF(2).sqrt())  # abs tol 2e-17

See also

gamma()

gamma_inc(a=None)

Image of this ball by the (upper incomplete) Euler Gamma function.

For \(a\) real, return the upper incomplete Gamma function \(\Gamma(self,a)\).

For integer and rational arguments, gamma() may be faster.

EXAMPLES:

Sage

sage: RBF(1/2).gamma()
[1.772453850905516 +/- ...e-16]
sage: RBF(gamma(3/2, RBF(2).sqrt()))  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]
sage: RBF(3/2).gamma_inc(RBF(2).sqrt())  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).gamma()
[1.772453850905516 +/- ...e-16]
>>> RBF(gamma(Integer(3)/Integer(2), RBF(Integer(2)).sqrt()))  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]
>>> RBF(Integer(3)/Integer(2)).gamma_inc(RBF(Integer(2)).sqrt())  # abs tol 2e-17
[0.37118875695353 +/- 3.00e-15]

Sage Live

RBF(1/2).gamma()
RBF(gamma(3/2, RBF(2).sqrt()))  # abs tol 2e-17
RBF(3/2).gamma_inc(RBF(2).sqrt())  # abs tol 2e-17

See also

gamma()

gamma_inc_lower(a)

Image of this ball by the lower incomplete Euler Gamma function.

For \(a\) real, return the lower incomplete Gamma function of \(\Gamma(self,a)\).

EXAMPLES:

Sage

sage: RBF(gamma_inc_lower(1/2, RBF(2).sqrt()))
[1.608308637729248 +/- 8.14e-16]
sage: RealBallField(100)(7/2).gamma_inc_lower(5)
[2.6966551541863035516887949614 +/- 8.91e-29]

Python

>>> from sage.all import *
>>> RBF(gamma_inc_lower(Integer(1)/Integer(2), RBF(Integer(2)).sqrt()))
[1.608308637729248 +/- 8.14e-16]
>>> RealBallField(Integer(100))(Integer(7)/Integer(2)).gamma_inc_lower(Integer(5))
[2.6966551541863035516887949614 +/- 8.91e-29]

Sage Live

RBF(gamma_inc_lower(1/2, RBF(2).sqrt()))
RealBallField(100)(7/2).gamma_inc_lower(5)

identical(other)

Return True iff self and other are equal as balls, i.e. have both the same midpoint and radius.

Note that this is not the same thing as testing whether both self and other certainly represent the same real number, unless either self or other is exact (and neither contains NaN). To test whether both operands might represent the same mathematical quantity, use overlaps() or contains(), depending on the circumstance.

EXAMPLES:

Sage

sage: RBF(1).identical(RBF(3)-RBF(2))
True
sage: RBF(1, rad=0.25r).identical(RBF(1, rad=0.25r))
True
sage: RBF(1).identical(RBF(1, rad=0.25r))
False

Python

>>> from sage.all import *
>>> RBF(Integer(1)).identical(RBF(Integer(3))-RBF(Integer(2)))
True
>>> RBF(Integer(1), rad=0.25).identical(RBF(Integer(1), rad=0.25))
True
>>> RBF(Integer(1)).identical(RBF(Integer(1), rad=0.25))
False

Sage Live

RBF(1).identical(RBF(3)-RBF(2))
RBF(1, rad=0.25r).identical(RBF(1, rad=0.25r))
RBF(1).identical(RBF(1, rad=0.25r))

imag()

Return the imaginary part of this ball.

EXAMPLES:

Sage

sage: RBF(1/3).imag()
0

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).imag()
0

Sage Live

RBF(1/3).imag()

is_NaN()

Return True if this ball is not-a-number.

EXAMPLES:

Sage

sage: RBF(NaN).is_NaN()                                                     # needs sage.symbolic
True
sage: RBF(-5).gamma().is_NaN()
True
sage: RBF(infinity).is_NaN()
False
sage: RBF(42, rad=1.r).is_NaN()
False

Python

>>> from sage.all import *
>>> RBF(NaN).is_NaN()                                                     # needs sage.symbolic
True
>>> RBF(-Integer(5)).gamma().is_NaN()
True
>>> RBF(infinity).is_NaN()
False
>>> RBF(Integer(42), rad=1.).is_NaN()
False

Sage Live

RBF(NaN).is_NaN()                                                     # needs sage.symbolic
RBF(-5).gamma().is_NaN()
RBF(infinity).is_NaN()
RBF(42, rad=1.r).is_NaN()

is_exact()

Return True iff the radius of this ball is zero.

EXAMPLES:

Sage

sage: RBF = RealBallField()
sage: RBF(1).is_exact()
True
sage: RBF(RIF(0.1, 0.2)).is_exact()
False

Python

>>> from sage.all import *
>>> RBF = RealBallField()
>>> RBF(Integer(1)).is_exact()
True
>>> RBF(RIF(RealNumber('0.1'), RealNumber('0.2'))).is_exact()
False

Sage Live

RBF = RealBallField()
RBF(1).is_exact()
RBF(RIF(0.1, 0.2)).is_exact()

is_finite()

Return True iff the midpoint and radius of this ball are both finite floating-point numbers, i.e. not infinities or NaN.

EXAMPLES:

Sage

sage: (RBF(2)^(2^1000)).is_finite()
True
sage: RBF(oo).is_finite()
False

Python

>>> from sage.all import *
>>> (RBF(Integer(2))**(Integer(2)**Integer(1000))).is_finite()
True
>>> RBF(oo).is_finite()
False

Sage Live

(RBF(2)^(2^1000)).is_finite()
RBF(oo).is_finite()

is_infinity()

Return True if this ball contains or may represent a point at infinity.

This is the exact negation of is_finite(), used in comparisons with Sage symbolic infinities.

Warning

Contrary to the usual convention, a return value of True does not imply that all points of the ball satisfy the predicate. This is due to the way comparisons with symbolic infinities work in sage.

EXAMPLES:

Sage

sage: RBF(infinity).is_infinity()
True
sage: RBF(-infinity).is_infinity()
True
sage: RBF(NaN).is_infinity()                                                # needs sage.symbolic
True
sage: (~RBF(0)).is_infinity()
True
sage: RBF(42, rad=1.r).is_infinity()
False

Python

>>> from sage.all import *
>>> RBF(infinity).is_infinity()
True
>>> RBF(-infinity).is_infinity()
True
>>> RBF(NaN).is_infinity()                                                # needs sage.symbolic
True
>>> (~RBF(Integer(0))).is_infinity()
True
>>> RBF(Integer(42), rad=1.).is_infinity()
False

Sage Live

RBF(infinity).is_infinity()
RBF(-infinity).is_infinity()
RBF(NaN).is_infinity()                                                # needs sage.symbolic
(~RBF(0)).is_infinity()
RBF(42, rad=1.r).is_infinity()

is_negative_infinity()

Return True if this ball is the point -∞.

EXAMPLES:

Sage

sage: RBF(-infinity).is_negative_infinity()
True

Python

>>> from sage.all import *
>>> RBF(-infinity).is_negative_infinity()
True

Sage Live

RBF(-infinity).is_negative_infinity()

is_nonzero()

Return True iff zero is not contained in the interval represented by this ball.

Note

This method is not the negation of is_zero(): it only returns True if zero is known not to be contained in the ball.

Use bool(b) (or, equivalently, not b.is_zero()) to check if a ball b may represent a nonzero number (for instance, to determine the “degree” of a polynomial with ball coefficients).

EXAMPLES:

Sage

sage: RBF = RealBallField()
sage: RBF(pi).is_nonzero()                                                  # needs sage.symbolic
True
sage: RBF(RIF(-0.5, 0.5)).is_nonzero()
False

Python

>>> from sage.all import *
>>> RBF = RealBallField()
>>> RBF(pi).is_nonzero()                                                  # needs sage.symbolic
True
>>> RBF(RIF(-RealNumber('0.5'), RealNumber('0.5'))).is_nonzero()
False

Sage Live

RBF = RealBallField()
RBF(pi).is_nonzero()                                                  # needs sage.symbolic
RBF(RIF(-0.5, 0.5)).is_nonzero()

See also

is_zero()

is_positive_infinity()

Return True if this ball is the point +∞.

EXAMPLES:

Sage

sage: RBF(infinity).is_positive_infinity()
True

Python

>>> from sage.all import *
>>> RBF(infinity).is_positive_infinity()
True

Sage Live

RBF(infinity).is_positive_infinity()

is_zero()

Return True iff the midpoint and radius of this ball are both zero.

EXAMPLES:

Sage

sage: RBF = RealBallField()
sage: RBF(0).is_zero()
True
sage: RBF(RIF(-0.5, 0.5)).is_zero()
False

Python

>>> from sage.all import *
>>> RBF = RealBallField()
>>> RBF(Integer(0)).is_zero()
True
>>> RBF(RIF(-RealNumber('0.5'), RealNumber('0.5'))).is_zero()
False

Sage Live

RBF = RealBallField()
RBF(0).is_zero()
RBF(RIF(-0.5, 0.5)).is_zero()

See also

is_nonzero()

lambert_w()

Return the image of this ball by the Lambert W function.

EXAMPLES:

Sage

sage: RBF(1).lambert_w()
[0.5671432904097...]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).lambert_w()
[0.5671432904097...]

Sage Live

RBF(1).lambert_w()

li()

Logarithmic integral.

EXAMPLES:

Sage

sage: RBF(3).li()  # abs tol 1e-15
[2.16358859466719 +/- 4.72e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(3)).li()  # abs tol 1e-15
[2.16358859466719 +/- 4.72e-15]

Sage Live

RBF(3).li()  # abs tol 1e-15

log(base=None)

Return the logarithm of this ball.

INPUT:

• base – (optional) positive real ball or number; if None, return the natural logarithm ln(self), otherwise, return the general logarithm ln(self)/ln(base)

EXAMPLES:

Sage

sage: RBF(3).log()
[1.098612288668110 +/- ...e-16]
sage: RBF(3).log(2)
[1.58496250072116 +/- ...e-15]
sage: log(RBF(5), 2)
[2.32192809488736 +/- ...e-15]

sage: RBF(-1/3).log()
nan
sage: RBF(3).log(-1)
nan
sage: RBF(2).log(0)
nan

Python

>>> from sage.all import *
>>> RBF(Integer(3)).log()
[1.098612288668110 +/- ...e-16]
>>> RBF(Integer(3)).log(Integer(2))
[1.58496250072116 +/- ...e-15]
>>> log(RBF(Integer(5)), Integer(2))
[2.32192809488736 +/- ...e-15]

>>> RBF(-Integer(1)/Integer(3)).log()
nan
>>> RBF(Integer(3)).log(-Integer(1))
nan
>>> RBF(Integer(2)).log(Integer(0))
nan

Sage Live

RBF(3).log()
RBF(3).log(2)
log(RBF(5), 2)
RBF(-1/3).log()
RBF(3).log(-1)
RBF(2).log(0)

log1p()

Return log(1 + self), computed accurately when self is close to zero.

EXAMPLES:

Sage

sage: eps = RBF(1e-30)
sage: (1 + eps).log()
[+/- ...e-16]
sage: eps.log1p()
[1.00000000000000e-30 +/- ...e-46]

Python

>>> from sage.all import *
>>> eps = RBF(RealNumber('1e-30'))
>>> (Integer(1) + eps).log()
[+/- ...e-16]
>>> eps.log1p()
[1.00000000000000e-30 +/- ...e-46]

Sage Live

eps = RBF(1e-30)
(1 + eps).log()
eps.log1p()

log_gamma()

Return the image of this ball by the logarithmic Gamma function.

The complex branch structure is assumed, so if self <= 0, the result is an indeterminate interval.

EXAMPLES:

Sage

sage: RBF(1/2).log_gamma()
[0.572364942924700 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).log_gamma()
[0.572364942924700 +/- ...e-16]

Sage Live

RBF(1/2).log_gamma()

log_integral()

Logarithmic integral.

EXAMPLES:

Sage

sage: RBF(3).li()  # abs tol 1e-15
[2.16358859466719 +/- 4.72e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(3)).li()  # abs tol 1e-15
[2.16358859466719 +/- 4.72e-15]

Sage Live

RBF(3).li()  # abs tol 1e-15

log_integral_offset()

Offset logarithmic integral.

EXAMPLES:

Sage

sage: RBF(3).Li()  # abs tol 1e-15
[1.11842481454970 +/- 7.61e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(3)).Li()  # abs tol 1e-15
[1.11842481454970 +/- 7.61e-15]

Sage Live

RBF(3).Li()  # abs tol 1e-15

lower(rnd=None)

Return the right endpoint of this ball, rounded downwards.

INPUT:

• rnd – string; rounding mode for the parent of the result (does not affect its value!), see sage.rings.real_mpfi.RealIntervalFieldElement.lower()

OUTPUT: a real number

EXAMPLES:

Sage

sage: RBF(-1/3).lower()
-0.333333333333334
sage: RBF(-1/3).lower().parent()
Real Field with 53 bits of precision and rounding RNDD

Python

>>> from sage.all import *
>>> RBF(-Integer(1)/Integer(3)).lower()
-0.333333333333334
>>> RBF(-Integer(1)/Integer(3)).lower().parent()
Real Field with 53 bits of precision and rounding RNDD

Sage Live

RBF(-1/3).lower()
RBF(-1/3).lower().parent()

See also

upper(), endpoints()

max(*others)

Return a ball containing the maximum of this ball and the remaining arguments.

EXAMPLES:

Sage

sage: RBF(-1, rad=.5).max(0)
0

sage: RBF(0, rad=2.).max(RBF(0, rad=1.)).endpoints()
(-1.00000000465662, 2.00000000651926)

sage: RBF(-infinity).max(-3, 1/3)
[0.3333333333333333 +/- ...e-17]

sage: RBF('nan').max(0)
nan

Python

>>> from sage.all import *
>>> RBF(-Integer(1), rad=RealNumber('.5')).max(Integer(0))
0

>>> RBF(Integer(0), rad=RealNumber('2.')).max(RBF(Integer(0), rad=RealNumber('1.'))).endpoints()
(-1.00000000465662, 2.00000000651926)

>>> RBF(-infinity).max(-Integer(3), Integer(1)/Integer(3))
[0.3333333333333333 +/- ...e-17]

>>> RBF('nan').max(Integer(0))
nan

Sage Live

RBF(-1, rad=.5).max(0)
RBF(0, rad=2.).max(RBF(0, rad=1.)).endpoints()
RBF(-infinity).max(-3, 1/3)
RBF('nan').max(0)

See also

min()

mid()

Return the center of this ball.

EXAMPLES:

Sage

sage: RealBallField(16)(1/3).mid()
0.3333
sage: RealBallField(16)(1/3).mid().parent()
Real Field with 16 bits of precision
sage: RealBallField(16)(RBF(1/3)).mid().parent()
Real Field with 53 bits of precision
sage: RBF('inf').mid()
+infinity

Python

>>> from sage.all import *
>>> RealBallField(Integer(16))(Integer(1)/Integer(3)).mid()
0.3333
>>> RealBallField(Integer(16))(Integer(1)/Integer(3)).mid().parent()
Real Field with 16 bits of precision
>>> RealBallField(Integer(16))(RBF(Integer(1)/Integer(3))).mid().parent()
Real Field with 53 bits of precision
>>> RBF('inf').mid()
+infinity

Sage Live

RealBallField(16)(1/3).mid()
RealBallField(16)(1/3).mid().parent()
RealBallField(16)(RBF(1/3)).mid().parent()
RBF('inf').mid()

Sage

Sage

sage: b = RBF(2)^(2^1000)
sage: b.mid()
+infinity

Python

>>> from sage.all import *
>>> b = RBF(Integer(2))**(Integer(2)**Integer(1000))
>>> b.mid()
+infinity

Sage Live

b = RBF(2)^(2^1000)
b.mid()

Python

>>> from sage.all import *
>>> b = RBF(Integer(2))**(Integer(2)**Integer(1000))
>>> b.mid()
+infinity

Sage Live

b = RBF(2)^(2^1000)
b.mid()

See also

rad(), squash()

min(*others)

Return a ball containing the minimum of this ball and the remaining arguments.

EXAMPLES:

Sage

sage: RBF(1, rad=.5).min(0)
0

sage: RBF(0, rad=2.).min(RBF(0, rad=1.)).endpoints()
(-2.00000000651926, 1.00000000465662)

sage: RBF(infinity).min(3, 1/3)
[0.3333333333333333 +/- ...e-17]

sage: RBF('nan').min(0)
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1), rad=RealNumber('.5')).min(Integer(0))
0

>>> RBF(Integer(0), rad=RealNumber('2.')).min(RBF(Integer(0), rad=RealNumber('1.'))).endpoints()
(-2.00000000651926, 1.00000000465662)

>>> RBF(infinity).min(Integer(3), Integer(1)/Integer(3))
[0.3333333333333333 +/- ...e-17]

>>> RBF('nan').min(Integer(0))
nan

Sage Live

RBF(1, rad=.5).min(0)
RBF(0, rad=2.).min(RBF(0, rad=1.)).endpoints()
RBF(infinity).min(3, 1/3)
RBF('nan').min(0)

See also

max()

nbits()

Return the minimum precision sufficient to represent this ball exactly.

In other words, return the number of bits needed to represent the absolute value of the mantissa of the midpoint of this ball. The result is 0 if the midpoint is a special value.

EXAMPLES:

Sage

sage: RBF(1/3).nbits()
53
sage: RBF(1023, .1).nbits()
10
sage: RBF(1024, .1).nbits()
1
sage: RBF(0).nbits()
0
sage: RBF(infinity).nbits()
0

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).nbits()
53
>>> RBF(Integer(1023), RealNumber('.1')).nbits()
10
>>> RBF(Integer(1024), RealNumber('.1')).nbits()
1
>>> RBF(Integer(0)).nbits()
0
>>> RBF(infinity).nbits()
0

Sage Live

RBF(1/3).nbits()
RBF(1023, .1).nbits()
RBF(1024, .1).nbits()
RBF(0).nbits()
RBF(infinity).nbits()

overlaps(other)

Return True iff self and other have some point in common.

If either self or other contains NaN, this method always returns nonzero (as a NaN could be anything, it could in particular contain any number that is included in the other operand).

EXAMPLES:

Sage

sage: RBF(pi).overlaps(RBF(pi) + 2**(-100))                                 # needs sage.symbolic
True
sage: RBF(pi).overlaps(RBF(3))                                              # needs sage.symbolic
False

Python

>>> from sage.all import *
>>> RBF(pi).overlaps(RBF(pi) + Integer(2)**(-Integer(100)))                                 # needs sage.symbolic
True
>>> RBF(pi).overlaps(RBF(Integer(3)))                                              # needs sage.symbolic
False

Sage Live

RBF(pi).overlaps(RBF(pi) + 2**(-100))                                 # needs sage.symbolic
RBF(pi).overlaps(RBF(3))                                              # needs sage.symbolic

polylog(s)

Return the polylogarithm \(\operatorname{Li}_s(\mathrm{self})\).

EXAMPLES:

Sage

sage: polylog(0, -1)                                                        # needs sage.symbolic
-1/2
sage: RBF(-1).polylog(0)
[-0.50000000000000 +/- ...e-16]
sage: polylog(1, 1/2)                                                       # needs sage.symbolic
-log(1/2)
sage: RBF(1/2).polylog(1)
[0.69314718055995 +/- ...e-15]
sage: RBF(1/3).polylog(1/2)
[0.44210883528067 +/- 6.7...e-15]
sage: RBF(1/3).polylog(RLF(pi))                                             # needs sage.symbolic
[0.34728895057225 +/- ...e-15]

Python

>>> from sage.all import *
>>> polylog(Integer(0), -Integer(1))                                                        # needs sage.symbolic
-1/2
>>> RBF(-Integer(1)).polylog(Integer(0))
[-0.50000000000000 +/- ...e-16]
>>> polylog(Integer(1), Integer(1)/Integer(2))                                                       # needs sage.symbolic
-log(1/2)
>>> RBF(Integer(1)/Integer(2)).polylog(Integer(1))
[0.69314718055995 +/- ...e-15]
>>> RBF(Integer(1)/Integer(3)).polylog(Integer(1)/Integer(2))
[0.44210883528067 +/- 6.7...e-15]
>>> RBF(Integer(1)/Integer(3)).polylog(RLF(pi))                                             # needs sage.symbolic
[0.34728895057225 +/- ...e-15]

Sage Live

polylog(0, -1)                                                        # needs sage.symbolic
RBF(-1).polylog(0)
polylog(1, 1/2)                                                       # needs sage.symbolic
RBF(1/2).polylog(1)
RBF(1/3).polylog(1/2)
RBF(1/3).polylog(RLF(pi))                                             # needs sage.symbolic

psi()

Compute the digamma function with argument self.

EXAMPLES:

Sage

sage: RBF(1).psi() # abs tol 1e-15
[-0.5772156649015329 +/- 4.84e-17]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).psi() # abs tol 1e-15
[-0.5772156649015329 +/- 4.84e-17]

Sage Live

RBF(1).psi() # abs tol 1e-15

rad()

Return the radius of this ball.

EXAMPLES:

Sage

sage: RBF(1/3).rad()
5.5511151e-17
sage: RBF(1/3).rad().parent()
Real Field with 30 bits of precision

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).rad()
5.5511151e-17
>>> RBF(Integer(1)/Integer(3)).rad().parent()
Real Field with 30 bits of precision

Sage Live

RBF(1/3).rad()
RBF(1/3).rad().parent()

See also

mid(), rad_as_ball(), diameter()

rad_as_ball()

Return an exact ball with center equal to the radius of this ball.

EXAMPLES:

Sage

sage: rad = RBF(1/3).rad_as_ball()
sage: rad
[5.55111512e-17 +/- ...e-26]
sage: rad.is_exact()
True
sage: rad.parent()
Real ball field with 30 bits of precision

Python

>>> from sage.all import *
>>> rad = RBF(Integer(1)/Integer(3)).rad_as_ball()
>>> rad
[5.55111512e-17 +/- ...e-26]
>>> rad.is_exact()
True
>>> rad.parent()
Real ball field with 30 bits of precision

Sage Live

rad = RBF(1/3).rad_as_ball()
rad
rad.is_exact()
rad.parent()

See also

squash(), rad()

real()

Return the real part of this ball.

EXAMPLES:

Sage

sage: RBF(1/3).real()
[0.3333333333333333 +/- 7.04e-17]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(3)).real()
[0.3333333333333333 +/- 7.04e-17]

Sage Live

RBF(1/3).real()

rgamma()

Return the image of this ball by the function 1/Γ, avoiding division by zero at the poles of the gamma function.

EXAMPLES:

Sage

sage: RBF(-1).rgamma()
0
sage: RBF(3).rgamma()
0.5000000000000000

Python

>>> from sage.all import *
>>> RBF(-Integer(1)).rgamma()
0
>>> RBF(Integer(3)).rgamma()
0.5000000000000000

Sage Live

RBF(-1).rgamma()
RBF(3).rgamma()

rising_factorial(n)

Return the n-th rising factorial of this ball.

The \(n\)-th rising factorial of \(x\) is equal to \(x (x+1) \cdots (x+n-1)\).

For real \(n\), it is a quotient of gamma functions.

EXAMPLES:

Sage

sage: RBF(1).rising_factorial(5)
120.0000000000000
sage: RBF(1/2).rising_factorial(1/3) # abs tol 1e-14
[0.636849884317974 +/- 8.98e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).rising_factorial(Integer(5))
120.0000000000000
>>> RBF(Integer(1)/Integer(2)).rising_factorial(Integer(1)/Integer(3)) # abs tol 1e-14
[0.636849884317974 +/- 8.98e-16]

Sage Live

RBF(1).rising_factorial(5)
RBF(1/2).rising_factorial(1/3) # abs tol 1e-14

round()

Return a copy of this ball with center rounded to the precision of the parent.

EXAMPLES:

It is possible to create balls whose midpoint is more precise than their parent’s nominal precision (see real_arb for more information):

Sage

sage: b = RBF(pi.n(100))                                                    # needs sage.symbolic
sage: b.mid()                                                               # needs sage.symbolic
3.141592653589793238462643383

Python

>>> from sage.all import *
>>> b = RBF(pi.n(Integer(100)))                                                    # needs sage.symbolic
>>> b.mid()                                                               # needs sage.symbolic
3.141592653589793238462643383

Sage Live

b = RBF(pi.n(100))                                                    # needs sage.symbolic
b.mid()                                                               # needs sage.symbolic

The round() method rounds such a ball to its parent’s precision:

Sage

sage: b.round().mid()                                                       # needs sage.symbolic
3.14159265358979

Python

>>> from sage.all import *
>>> b.round().mid()                                                       # needs sage.symbolic
3.14159265358979

Sage Live

b.round().mid()                                                       # needs sage.symbolic

See also

trim()

rsqrt()

Return the reciprocal square root of self.

At high precision, this is faster than computing a square root.

EXAMPLES:

Sage

sage: RBF(2).rsqrt()
[0.707106781186547 +/- ...e-16]
sage: RBF(0).rsqrt()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(2)).rsqrt()
[0.707106781186547 +/- ...e-16]
>>> RBF(Integer(0)).rsqrt()
nan

Sage Live

RBF(2).rsqrt()
RBF(0).rsqrt()

sec()

Return the secant of this ball.

EXAMPLES:

Sage

sage: RBF(1).sec()
[1.850815717680925 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).sec()
[1.850815717680925 +/- ...e-16]

Sage Live

RBF(1).sec()

sech()

Return the hyperbolic secant of this ball.

EXAMPLES:

Sage

sage: RBF(1).sech()
[0.648054273663885 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).sech()
[0.648054273663885 +/- ...e-16]

Sage Live

RBF(1).sech()

sin()

Return the sine of this ball.

EXAMPLES:

Sage

sage: RBF(pi).sin()                                                         # needs sage.symbolic
[+/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(pi).sin()                                                         # needs sage.symbolic
[+/- ...e-16]

Sage Live

RBF(pi).sin()                                                         # needs sage.symbolic

See also

sinpi()

sin_integral()

Sine integral.

EXAMPLES:

Sage

sage: RBF(1).Si() # abs tol 1e-15
[0.946083070367183 +/- 9.22e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Si() # abs tol 1e-15
[0.946083070367183 +/- 9.22e-16]

Sage Live

RBF(1).Si() # abs tol 1e-15

sinh()

Return the hyperbolic sine of this ball.

EXAMPLES:

Sage

sage: RBF(1).sinh()
[1.175201193643801 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).sinh()
[1.175201193643801 +/- ...e-16]

Sage Live

RBF(1).sinh()

sinh_integral()

Hyperbolic sine integral.

EXAMPLES:

Sage

sage: RBF(1).Shi()
[1.05725087537573 +/- 2.77e-15]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).Shi()
[1.05725087537573 +/- 2.77e-15]

Sage Live

RBF(1).Shi()

sqrt()

Return the square root of this ball.

EXAMPLES:

Sage

sage: RBF(2).sqrt()
[1.414213562373095 +/- ...e-16]
sage: RBF(-1/3).sqrt()
nan

Python

>>> from sage.all import *
>>> RBF(Integer(2)).sqrt()
[1.414213562373095 +/- ...e-16]
>>> RBF(-Integer(1)/Integer(3)).sqrt()
nan

Sage Live

RBF(2).sqrt()
RBF(-1/3).sqrt()

sqrt1pm1()

Return \(\sqrt{1+\mathrm{self}}-1\), computed accurately when self is close to zero.

EXAMPLES:

Sage

sage: eps = RBF(10^(-20))
sage: (1 + eps).sqrt() - 1
[+/- ...e-16]
sage: eps.sqrt1pm1()
[5.00000000000000e-21 +/- ...e-36]

Python

>>> from sage.all import *
>>> eps = RBF(Integer(10)**(-Integer(20)))
>>> (Integer(1) + eps).sqrt() - Integer(1)
[+/- ...e-16]
>>> eps.sqrt1pm1()
[5.00000000000000e-21 +/- ...e-36]

Sage Live

eps = RBF(10^(-20))
(1 + eps).sqrt() - 1
eps.sqrt1pm1()

sqrtpos()

Return the square root of this ball, assuming that it represents a nonnegative number.

Any negative numbers in the input interval are discarded.

EXAMPLES:

Sage

sage: RBF(2).sqrtpos()
[1.414213562373095 +/- ...e-16]
sage: RBF(-1/3).sqrtpos()
0
sage: RBF(0, rad=2.r).sqrtpos()
[+/- 1.42]

Python

>>> from sage.all import *
>>> RBF(Integer(2)).sqrtpos()
[1.414213562373095 +/- ...e-16]
>>> RBF(-Integer(1)/Integer(3)).sqrtpos()
0
>>> RBF(Integer(0), rad=2.).sqrtpos()
[+/- 1.42]

Sage Live

RBF(2).sqrtpos()
RBF(-1/3).sqrtpos()
RBF(0, rad=2.r).sqrtpos()

squash()

Return an exact ball with the same center as this ball.

EXAMPLES:

Sage

sage: mid = RealBallField(16)(1/3).squash()
sage: mid
[0.3333 +/- ...e-5]
sage: mid.is_exact()
True
sage: mid.parent()
Real ball field with 16 bits of precision

Python

>>> from sage.all import *
>>> mid = RealBallField(Integer(16))(Integer(1)/Integer(3)).squash()
>>> mid
[0.3333 +/- ...e-5]
>>> mid.is_exact()
True
>>> mid.parent()
Real ball field with 16 bits of precision

Sage Live

mid = RealBallField(16)(1/3).squash()
mid
mid.is_exact()
mid.parent()

See also

mid(), rad_as_ball()

tan()

Return the tangent of this ball.

EXAMPLES:

Sage

sage: RBF(1).tan()
[1.557407724654902 +/- ...e-16]
sage: RBF(pi/2).tan()                                                       # needs sage.symbolic
nan

Python

>>> from sage.all import *
>>> RBF(Integer(1)).tan()
[1.557407724654902 +/- ...e-16]
>>> RBF(pi/Integer(2)).tan()                                                       # needs sage.symbolic
nan

Sage Live

RBF(1).tan()
RBF(pi/2).tan()                                                       # needs sage.symbolic

tanh()

Return the hyperbolic tangent of this ball.

EXAMPLES:

Sage

sage: RBF(1).tanh()
[0.761594155955765 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(Integer(1)).tanh()
[0.761594155955765 +/- ...e-16]

Sage Live

RBF(1).tanh()

trim()

Return a trimmed copy of this ball.

Round self to a number of bits equal to the accuracy() of self (as indicated by its radius), plus a few guard bits. The resulting ball is guaranteed to contain self, but is more economical if self has less than full accuracy.

EXAMPLES:

Sage

sage: b = RBF(0.11111111111111, rad=.001)
sage: b.mid()
0.111111111111110
sage: b.trim().mid()
0.111111104488373

Python

>>> from sage.all import *
>>> b = RBF(RealNumber('0.11111111111111'), rad=RealNumber('.001'))
>>> b.mid()
0.111111111111110
>>> b.trim().mid()
0.111111104488373

Sage Live

b = RBF(0.11111111111111, rad=.001)
b.mid()
b.trim().mid()

See also

round()

union(other)

Return a ball containing the convex hull of self and other.

EXAMPLES:

Sage

sage: RBF(0).union(1).endpoints()
(-9.31322574615479e-10, 1.00000000093133)

Python

>>> from sage.all import *
>>> RBF(Integer(0)).union(Integer(1)).endpoints()
(-9.31322574615479e-10, 1.00000000093133)

Sage Live

RBF(0).union(1).endpoints()

upper(rnd=None)

Return the right endpoint of this ball, rounded upwards.

INPUT:

• rnd – string; rounding mode for the parent of the result (does not affect its value!), see sage.rings.real_mpfi.RealIntervalFieldElement.upper()

OUTPUT: a real number

EXAMPLES:

Sage

sage: RBF(-1/3).upper()
-0.333333333333333
sage: RBF(-1/3).upper().parent()
Real Field with 53 bits of precision and rounding RNDU

Python

>>> from sage.all import *
>>> RBF(-Integer(1)/Integer(3)).upper()
-0.333333333333333
>>> RBF(-Integer(1)/Integer(3)).upper().parent()
Real Field with 53 bits of precision and rounding RNDU

Sage Live

RBF(-1/3).upper()
RBF(-1/3).upper().parent()

See also

lower(), endpoints()

zeta(a=None)

Return the image of this ball by the Hurwitz zeta function.

For a = 1 (or a = None), this computes the Riemann zeta function.

Otherwise, it computes the Hurwitz zeta function.

Use RealBallField.zeta() to compute the Riemann zeta function of a small integer without first converting it to a real ball.

EXAMPLES:

Sage

sage: RBF(-1).zeta()
[-0.0833333333333333 +/- ...e-17]
sage: RBF(-1).zeta(1)
[-0.0833333333333333 +/- ...e-17]
sage: RBF(-1).zeta(2)
[-1.083333333333333 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF(-Integer(1)).zeta()
[-0.0833333333333333 +/- ...e-17]
>>> RBF(-Integer(1)).zeta(Integer(1))
[-0.0833333333333333 +/- ...e-17]
>>> RBF(-Integer(1)).zeta(Integer(2))
[-1.083333333333333 +/- ...e-16]

Sage Live

RBF(-1).zeta()
RBF(-1).zeta(1)
RBF(-1).zeta(2)

zetaderiv(k)

Return the image of this ball by the \(k\)-th derivative of the Riemann zeta function.

For a more flexible interface, see the low-level method _zeta_series of polynomials with complex ball coefficients.

EXAMPLES:

Sage

sage: RBF(1/2).zetaderiv(1)
[-3.92264613920915...]
sage: RBF(2).zetaderiv(3)
[-6.0001458028430...]

Python

>>> from sage.all import *
>>> RBF(Integer(1)/Integer(2)).zetaderiv(Integer(1))
[-3.92264613920915...]
>>> RBF(Integer(2)).zetaderiv(Integer(3))
[-6.0001458028430...]

Sage Live

RBF(1/2).zetaderiv(1)
RBF(2).zetaderiv(3)

class sage.rings.real_arb.RealBallField(precision=53)

Bases: UniqueRepresentation, RealBallField

An approximation of the field of real numbers using mid-rad intervals, also known as balls.

INPUT:

• precision – integer \(\ge 2\)

EXAMPLES:

Sage

sage: RBF = RealBallField() # indirect doctest
sage: RBF(1)
1.000000000000000

Python

>>> from sage.all import *
>>> RBF = RealBallField() # indirect doctest
>>> RBF(Integer(1))
1.000000000000000

Sage Live

RBF = RealBallField() # indirect doctest
RBF(1)

Sage

Sage

sage: (1/2*RBF(1)) + AA(sqrt(2)) - 1 + polygen(QQ, 'x')                         # needs sage.symbolic
x + [0.914213562373095 +/- ...e-16]

Python

>>> from sage.all import *
>>> (Integer(1)/Integer(2)*RBF(Integer(1))) + AA(sqrt(Integer(2))) - Integer(1) + polygen(QQ, 'x')                         # needs sage.symbolic
x + [0.914213562373095 +/- ...e-16]

Sage Live

(1/2*RBF(1)) + AA(sqrt(2)) - 1 + polygen(QQ, 'x')                         # needs sage.symbolic

Python

>>> from sage.all import *
>>> (Integer(1)/Integer(2)*RBF(Integer(1))) + AA(sqrt(Integer(2))) - Integer(1) + polygen(QQ, 'x')                         # needs sage.symbolic
x + [0.914213562373095 +/- ...e-16]

Sage Live

(1/2*RBF(1)) + AA(sqrt(2)) - 1 + polygen(QQ, 'x')                         # needs sage.symbolic

See also

• sage.rings.real_arb

• sage.rings.real_mpfr

• sage.rings.real_mpfi (real intervals represented by their endpoints)

• sage.rings.complex_arb

Element

alias of RealBall

algebraic_closure()

Return the complex ball field with the same precision.

EXAMPLES:

Sage

sage: from sage.rings.complex_arb import ComplexBallField
sage: RBF.complex_field()
Complex ball field with 53 bits of precision
sage: RealBallField(3).algebraic_closure()
Complex ball field with 3 bits of precision

Python

>>> from sage.all import *
>>> from sage.rings.complex_arb import ComplexBallField
>>> RBF.complex_field()
Complex ball field with 53 bits of precision
>>> RealBallField(Integer(3)).algebraic_closure()
Complex ball field with 3 bits of precision

Sage Live

from sage.rings.complex_arb import ComplexBallField
RBF.complex_field()
RealBallField(3).algebraic_closure()

bell_number(n)

Return a ball enclosing the n-th Bell number.

EXAMPLES:

Sage

sage: [RBF.bell_number(n) for n in range(7)]
[1.000000000000000,
 1.000000000000000,
 2.000000000000000,
 5.000000000000000,
 15.00000000000000,
 52.00000000000000,
 203.0000000000000]
sage: RBF.bell_number(-1)
Traceback (most recent call last):
...
ValueError: expected a nonnegative index
sage: RBF.bell_number(10**20)
[5.38270113176282e+1794956117137290721328 +/- ...e+1794956117137290721313]

Python

>>> from sage.all import *
>>> [RBF.bell_number(n) for n in range(Integer(7))]
[1.000000000000000,
 1.000000000000000,
 2.000000000000000,
 5.000000000000000,
 15.00000000000000,
 52.00000000000000,
 203.0000000000000]
>>> RBF.bell_number(-Integer(1))
Traceback (most recent call last):
...
ValueError: expected a nonnegative index
>>> RBF.bell_number(Integer(10)**Integer(20))
[5.38270113176282e+1794956117137290721328 +/- ...e+1794956117137290721313]

Sage Live

[RBF.bell_number(n) for n in range(7)]
RBF.bell_number(-1)
RBF.bell_number(10**20)

bernoulli(n)

Return a ball enclosing the n-th Bernoulli number.

EXAMPLES:

Sage

sage: [RBF.bernoulli(n) for n in range(4)]
[1.000000000000000, -0.5000000000000000, [0.1666666666666667 +/- ...e-17], 0]
sage: RBF.bernoulli(2**20)
[-1.823002872104961e+5020717 +/- ...e+5020701]
sage: RBF.bernoulli(2**1000)
Traceback (most recent call last):
...
ValueError: argument too large

Python

>>> from sage.all import *
>>> [RBF.bernoulli(n) for n in range(Integer(4))]
[1.000000000000000, -0.5000000000000000, [0.1666666666666667 +/- ...e-17], 0]
>>> RBF.bernoulli(Integer(2)**Integer(20))
[-1.823002872104961e+5020717 +/- ...e+5020701]
>>> RBF.bernoulli(Integer(2)**Integer(1000))
Traceback (most recent call last):
...
ValueError: argument too large

Sage Live

[RBF.bernoulli(n) for n in range(4)]
RBF.bernoulli(2**20)
RBF.bernoulli(2**1000)

catalan_constant()

Return a ball enclosing the Catalan constant.

EXAMPLES:

Sage

sage: RBF.catalan_constant()
[0.915965594177219 +/- ...e-16]
sage: RealBallField(128).catalan_constant()
[0.91596559417721901505460351493238411077 +/- ...e-39]

Python

>>> from sage.all import *
>>> RBF.catalan_constant()
[0.915965594177219 +/- ...e-16]
>>> RealBallField(Integer(128)).catalan_constant()
[0.91596559417721901505460351493238411077 +/- ...e-39]

Sage Live

RBF.catalan_constant()
RealBallField(128).catalan_constant()

characteristic()

Real ball fields have characteristic zero.

EXAMPLES:

Sage

sage: RealBallField().characteristic()
0

Python

>>> from sage.all import *
>>> RealBallField().characteristic()
0

Sage Live

RealBallField().characteristic()

complex_field()

Return the complex ball field with the same precision.

EXAMPLES:

Sage

sage: from sage.rings.complex_arb import ComplexBallField
sage: RBF.complex_field()
Complex ball field with 53 bits of precision
sage: RealBallField(3).algebraic_closure()
Complex ball field with 3 bits of precision

Python

>>> from sage.all import *
>>> from sage.rings.complex_arb import ComplexBallField
>>> RBF.complex_field()
Complex ball field with 53 bits of precision
>>> RealBallField(Integer(3)).algebraic_closure()
Complex ball field with 3 bits of precision

Sage Live

from sage.rings.complex_arb import ComplexBallField
RBF.complex_field()
RealBallField(3).algebraic_closure()

construction()

Return the construction of a real ball field as a completion of the rationals.

EXAMPLES:

Sage

sage: RBF = RealBallField(42)
sage: functor, base = RBF.construction()
sage: functor, base
(Completion[+Infinity, prec=42], Rational Field)
sage: functor(base) is RBF
True

Python

>>> from sage.all import *
>>> RBF = RealBallField(Integer(42))
>>> functor, base = RBF.construction()
>>> functor, base
(Completion[+Infinity, prec=42], Rational Field)
>>> functor(base) is RBF
True

Sage Live

RBF = RealBallField(42)
functor, base = RBF.construction()
functor, base
functor(base) is RBF

cospi(x)

Return a ball enclosing \(\cos(\pi x)\).

This works even if x itself is not a ball, and may be faster or more accurate where x is a rational number.

EXAMPLES:

Sage

sage: RBF.cospi(1)
-1.000000000000000
sage: RBF.cospi(1/3)
0.5000000000000000

Python

>>> from sage.all import *
>>> RBF.cospi(Integer(1))
-1.000000000000000
>>> RBF.cospi(Integer(1)/Integer(3))
0.5000000000000000

Sage Live

RBF.cospi(1)
RBF.cospi(1/3)

See also

cos()

double_factorial(n)

Return a ball enclosing the n-th double factorial.

EXAMPLES:

Sage

sage: [RBF.double_factorial(n) for n in range(7)]
[1.000000000000000,
 1.000000000000000,
 2.000000000000000,
 3.000000000000000,
 8.000000000000000,
 15.00000000000000,
 48.00000000000000]
sage: RBF.double_factorial(2**20)
[1.448372990...e+2928836 +/- ...]
sage: RBF.double_factorial(2**1000)
Traceback (most recent call last):
...
ValueError: argument too large
sage: RBF.double_factorial(-1)
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Python

>>> from sage.all import *
>>> [RBF.double_factorial(n) for n in range(Integer(7))]
[1.000000000000000,
 1.000000000000000,
 2.000000000000000,
 3.000000000000000,
 8.000000000000000,
 15.00000000000000,
 48.00000000000000]
>>> RBF.double_factorial(Integer(2)**Integer(20))
[1.448372990...e+2928836 +/- ...]
>>> RBF.double_factorial(Integer(2)**Integer(1000))
Traceback (most recent call last):
...
ValueError: argument too large
>>> RBF.double_factorial(-Integer(1))
Traceback (most recent call last):
...
ValueError: expected a nonnegative index

Sage Live

[RBF.double_factorial(n) for n in range(7)]
RBF.double_factorial(2**20)
RBF.double_factorial(2**1000)
RBF.double_factorial(-1)

euler_constant()

Return a ball enclosing the Euler constant.

EXAMPLES:

Sage

sage: RBF.euler_constant() # abs tol 1e-15
[0.5772156649015329 +/- 9.00e-17]
sage: RealBallField(128).euler_constant()
[0.57721566490153286060651209008240243104 +/- ...e-39]

Python

>>> from sage.all import *
>>> RBF.euler_constant() # abs tol 1e-15
[0.5772156649015329 +/- 9.00e-17]
>>> RealBallField(Integer(128)).euler_constant()
[0.57721566490153286060651209008240243104 +/- ...e-39]

Sage Live

RBF.euler_constant() # abs tol 1e-15
RealBallField(128).euler_constant()

fibonacci(n)

Return a ball enclosing the n-th Fibonacci number.

EXAMPLES:

Sage

sage: [RBF.fibonacci(n) for n in range(7)]
[0,
1.000000000000000,
1.000000000000000,
2.000000000000000,
3.000000000000000,
5.000000000000000,
8.000000000000000]
sage: RBF.fibonacci(-2)
-1.000000000000000
sage: RBF.fibonacci(10**20)
[3.78202087472056e+20898764024997873376 +/- ...e+20898764024997873361]

Python

>>> from sage.all import *
>>> [RBF.fibonacci(n) for n in range(Integer(7))]
[0,
1.000000000000000,
1.000000000000000,
2.000000000000000,
3.000000000000000,
5.000000000000000,
8.000000000000000]
>>> RBF.fibonacci(-Integer(2))
-1.000000000000000
>>> RBF.fibonacci(Integer(10)**Integer(20))
[3.78202087472056e+20898764024997873376 +/- ...e+20898764024997873361]

Sage Live

[RBF.fibonacci(n) for n in range(7)]
RBF.fibonacci(-2)
RBF.fibonacci(10**20)

gamma(x)

Return a ball enclosing the gamma function of x.

This works even if x itself is not a ball, and may be more efficient in the case where x is an integer or a rational number.

EXAMPLES:

Sage

sage: RBF.gamma(5)
24.00000000000000
sage: RBF.gamma(10**20)
[1.932849514310098...+1956570551809674817225 +/- ...]
sage: RBF.gamma(1/3)
[2.678938534707747 +/- ...e-16]
sage: RBF.gamma(-5)
nan

Python

>>> from sage.all import *
>>> RBF.gamma(Integer(5))
24.00000000000000
>>> RBF.gamma(Integer(10)**Integer(20))
[1.932849514310098...+1956570551809674817225 +/- ...]
>>> RBF.gamma(Integer(1)/Integer(3))
[2.678938534707747 +/- ...e-16]
>>> RBF.gamma(-Integer(5))
nan

Sage Live

RBF.gamma(5)
RBF.gamma(10**20)
RBF.gamma(1/3)
RBF.gamma(-5)

See also

gamma()

gens()

EXAMPLES:

Sage

sage: RBF.gens()
(1.000000000000000,)
sage: RBF.gens_dict()
{'1.000000000000000': 1.000000000000000}

Python

>>> from sage.all import *
>>> RBF.gens()
(1.000000000000000,)
>>> RBF.gens_dict()
{'1.000000000000000': 1.000000000000000}

Sage Live

RBF.gens()
RBF.gens_dict()

is_exact()

Real ball fields are not exact.

EXAMPLES:

Sage

sage: RealBallField().is_exact()
False

Python

>>> from sage.all import *
>>> RealBallField().is_exact()
False

Sage Live

RealBallField().is_exact()

log2()

Return a ball enclosing \(\log(2)\).

EXAMPLES:

Sage

sage: RBF.log2()
[0.6931471805599453 +/- ...e-17]
sage: RealBallField(128).log2()
[0.69314718055994530941723212145817656807 +/- ...e-39]

Python

>>> from sage.all import *
>>> RBF.log2()
[0.6931471805599453 +/- ...e-17]
>>> RealBallField(Integer(128)).log2()
[0.69314718055994530941723212145817656807 +/- ...e-39]

Sage Live

RBF.log2()
RealBallField(128).log2()

maximal_accuracy()

Return the relative accuracy of exact elements measured in bits.

OUTPUT: integer

EXAMPLES:

Sage

sage: RBF.maximal_accuracy()
9223372036854775807 # 64-bit
2147483647          # 32-bit

Python

>>> from sage.all import *
>>> RBF.maximal_accuracy()
9223372036854775807 # 64-bit
2147483647          # 32-bit

Sage Live

RBF.maximal_accuracy()

See also

RealBall.accuracy()

pi()

Return a ball enclosing \(\pi\).

EXAMPLES:

Sage

sage: RBF.pi()
[3.141592653589793 +/- ...e-16]
sage: RealBallField(128).pi()
[3.1415926535897932384626433832795028842 +/- ...e-38]

Python

>>> from sage.all import *
>>> RBF.pi()
[3.141592653589793 +/- ...e-16]
>>> RealBallField(Integer(128)).pi()
[3.1415926535897932384626433832795028842 +/- ...e-38]

Sage Live

RBF.pi()
RealBallField(128).pi()

prec()

Return the bit precision used for operations on elements of this field.

EXAMPLES:

Sage

sage: RealBallField().precision()
53

Python

>>> from sage.all import *
>>> RealBallField().precision()
53

Sage Live

RealBallField().precision()

precision()

Return the bit precision used for operations on elements of this field.

EXAMPLES:

Sage

sage: RealBallField().precision()
53

Python

>>> from sage.all import *
>>> RealBallField().precision()
53

Sage Live

RealBallField().precision()

sinpi(x)

Return a ball enclosing \(\sin(\pi x)\).

This works even if x itself is not a ball, and may be faster or more accurate where x is a rational number.

EXAMPLES:

Sage

sage: RBF.sinpi(1)
0
sage: RBF.sinpi(1/3)
[0.866025403784439 +/- ...e-16]
sage: RBF.sinpi(1 + 2^(-100))
[-2.478279624546525e-30 +/- ...e-46]

Python

>>> from sage.all import *
>>> RBF.sinpi(Integer(1))
0
>>> RBF.sinpi(Integer(1)/Integer(3))
[0.866025403784439 +/- ...e-16]
>>> RBF.sinpi(Integer(1) + Integer(2)**(-Integer(100)))
[-2.478279624546525e-30 +/- ...e-46]

Sage Live

RBF.sinpi(1)
RBF.sinpi(1/3)
RBF.sinpi(1 + 2^(-100))

See also

sin()

some_elements()

Real ball fields contain exact balls, inexact balls, infinities, and more.

EXAMPLES:

Sage

sage: RBF.some_elements()
[0, 1.000000000000000, [0.3333333333333333 +/- ...e-17],
[-4.733045976388941e+363922934236666733021124 +/- ...e+363922934236666733021108],
[+/- inf], [+/- inf], [+/- inf], nan]

Python

>>> from sage.all import *
>>> RBF.some_elements()
[0, 1.000000000000000, [0.3333333333333333 +/- ...e-17],
[-4.733045976388941e+363922934236666733021124 +/- ...e+363922934236666733021108],
[+/- inf], [+/- inf], [+/- inf], nan]

Sage Live

RBF.some_elements()

zeta(s)

Return a ball enclosing the Riemann zeta function of s.

This works even if s itself is not a ball, and may be more efficient in the case where s is an integer.

EXAMPLES:

Sage

sage: RBF.zeta(3)
[1.202056903159594 +/- ...e-16]
sage: RBF.zeta(1)
nan
sage: RBF.zeta(1/2)
[-1.460354508809587 +/- ...e-16]

Python

>>> from sage.all import *
>>> RBF.zeta(Integer(3))
[1.202056903159594 +/- ...e-16]
>>> RBF.zeta(Integer(1))
nan
>>> RBF.zeta(Integer(1)/Integer(2))
[-1.460354508809587 +/- ...e-16]

Sage Live

RBF.zeta(3)
RBF.zeta(1)
RBF.zeta(1/2)

See also

zeta()

sage.rings.real_arb.create_RealBall(parent, serialized)

Create a RealBall from a serialized representation.

Make live