Double Precision Real Numbers¶

EXAMPLES:

We create the real double vector space of dimension $$3$$:

sage: V = RDF^3; V
Vector space of dimension 3 over Real Double Field


Notice that this space is unique:

sage: V is RDF^3
True
sage: V is FreeModule(RDF, 3)
True
sage: V is VectorSpace(RDF, 3)
True


Also, you can instantly create a space of large dimension:

sage: V = RDF^10000


TESTS:

Test NumPy conversions:

sage: RDF(1).__array_interface__
{'typestr': '=f8'}
sage: import numpy
sage: numpy.array([RDF.pi()]).dtype
dtype('float64')

class sage.rings.real_double.RealDoubleElement

An approximation to a real number using double precision floating point numbers. Answers derived from calculations with such approximations may differ from what they would be if those calculations were performed with true real numbers. This is due to the rounding errors inherent to finite precision calculations.

NaN()

Return Not-a-Number NaN.

EXAMPLES:

sage: RDF.NaN()
NaN

abs()

Returns the absolute value of self.

EXAMPLES:

sage: RDF(1e10).abs()
10000000000.0
sage: RDF(-1e10).abs()
10000000000.0

acosh()

Return the hyperbolic inverse cosine of self.

EXAMPLES:

sage: q = RDF.pi()/2
sage: i = q.cosh(); i
2.5091784786580567
sage: abs(i.acosh()-q) < 1e-15
True

agm(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 NaN.

EXAMPLES:

sage: a = RDF(1.5)
sage: b = RDF(2.3)
sage: a.agm(b)
1.8786484558146697


The arithmetic-geometric mean always lies between the geometric and arithmetic mean:

sage: sqrt(a*b) < a.agm(b) < (a+b)/2
True

algdep(n)

Return a polynomial of degree at most $$n$$ which is approximately satisfied by this number.

Note

The resulting polynomial need not be irreducible, and indeed usually won’t be if this number is a good approximation to an algebraic number of degree less than $$n$$.

ALGORITHM:

Uses the PARI C-library algdep command.

EXAMPLE:

sage: r = sqrt(RDF(2)); r
1.4142135623730951
sage: r.algebraic_dependency(5)
x^2 - 2

algebraic_dependency(n)

Return a polynomial of degree at most $$n$$ which is approximately satisfied by this number.

Note

The resulting polynomial need not be irreducible, and indeed usually won’t be if this number is a good approximation to an algebraic number of degree less than $$n$$.

ALGORITHM:

Uses the PARI C-library algdep command.

EXAMPLE:

sage: r = sqrt(RDF(2)); r
1.4142135623730951
sage: r.algebraic_dependency(5)
x^2 - 2

arccos()

Return the inverse cosine of self.

EXAMPLES:

sage: q = RDF.pi()/3
sage: i = q.cos()
sage: i.arccos() == q
True

arcsin()

Return the inverse sine of self.

EXAMPLES:

sage: q = RDF.pi()/5
sage: i = q.sin()
sage: i.arcsin() == q
True

arcsinh()

Return the hyperbolic inverse sine of self.

EXAMPLES:

sage: q = RDF.pi()/2
sage: i = q.sinh(); i
2.3012989023072947
sage: abs(i.arcsinh()-q) < 1e-15
True

arctan()

Return the inverse tangent of self.

EXAMPLES:

sage: q = RDF.pi()/5
sage: i = q.tan()
sage: i.arctan() == q
True

arctanh()

Return the hyperbolic inverse tangent of self.

EXAMPLES:

sage: q = RDF.pi()/2
sage: i = q.tanh(); i
0.9171523356672744
sage: i.arctanh() - q  # rel tol 1
4.440892098500626e-16

ceil()

Return the ceiling of self.

EXAMPLES:

sage: RDF(2.99).ceil()
3
sage: RDF(2.00).ceil()
2
sage: RDF(-5/2).ceil()
-2

ceiling()

Return the ceiling of self.

EXAMPLES:

sage: RDF(2.99).ceil()
3
sage: RDF(2.00).ceil()
2
sage: RDF(-5/2).ceil()
-2

conjugate()

Returns the complex conjugate of this real number, which is the real number itself.

EXAMPLES:

sage: RDF(4).conjugate()
4.0

cos()

Return the cosine of self.

EXAMPLES:

sage: t=RDF.pi()/2
sage: t.cos()
6.123233995736757e-17

cosh()

Return the hyperbolic cosine of self.

EXAMPLES:

sage: q = RDF.pi()/12
sage: q.cosh()
1.0344656400955106

coth()

Return the hyperbolic cotangent of self.

EXAMPLES:

sage: RDF(pi).coth()
1.003741873197321
sage: CDF(pi).coth()
1.0037418731973213

csch()

Return the hyperbolic cosecant of self.

EXAMPLES:

sage: RDF(pi).csch()
0.08658953753004694
sage: CDF(pi).csch()  # rel tol 1e-15
0.08658953753004696

cube_root()

Return the cubic root (defined over the real numbers) of self.

EXAMPLES:

sage: r = RDF(125.0); r.cube_root()
5.000000000000001
sage: r = RDF(-119.0)
sage: r.cube_root()^3 - r  # rel tol 1
-1.4210854715202004e-14

erf()

Return the value of the error function on self.

EXAMPLES:

sage: RDF(6).erf()
1.0

exp()

Return $$e^\mathtt{self}$$.

EXAMPLES:

sage: r = RDF(0.0)
sage: r.exp()
1.0

sage: r = RDF('32.3')
sage: a = r.exp(); a
106588847274864.47
sage: a.log()
32.3

sage: r = RDF('-32.3')
sage: r.exp()
9.381844588498685e-15

sage: RDF(1000).exp()
+infinity

exp10()

Return $$10^\mathtt{self}$$.

EXAMPLES:

sage: r = RDF(0.0)
sage: r.exp10()
1.0

sage: r = RDF(32.0)
sage: r.exp10()
1.0000000000000069e+32

sage: r = RDF(-32.3)
sage: r.exp10()
5.011872336272702e-33

exp2()

Return $$2^\mathtt{self}$$.

EXAMPLES:

sage: r = RDF(0.0)
sage: r.exp2()
1.0

sage: r = RDF(32.0)
sage: r.exp2()
4294967295.9999967

sage: r = RDF(-32.3)
sage: r.exp2()
1.8911724825302065e-10

floor()

Return the floor of self.

EXAMPLES:

sage: RDF(2.99).floor()
2
sage: RDF(2.00).floor()
2
sage: RDF(-5/2).floor()
-3

frac()

Return a real number in $$(-1, 1)$$. It satisfies the relation: x = x.trunc() + x.frac()

EXAMPLES:

sage: RDF(2.99).frac()
0.9900000000000002
sage: RDF(2.50).frac()
0.5
sage: RDF(-2.79).frac()
-0.79

gamma()

Return the value of the Euler gamma function on self.

EXAMPLES:

sage: RDF(6).gamma()
120.0
sage: RDF(1.5).gamma()  # rel tol 1e-15
0.8862269254527584

hypot(other)

Computes the value $$\sqrt{s^2 + o^2}$$ where $$s$$ is self and $$o$$ is other in such a way as to avoid overflow.

EXAMPLES:

sage: x = RDF(4e300); y = RDF(3e300);
sage: x.hypot(y)
5e+300
sage: sqrt(x^2+y^2) # overflow
+infinity

imag()

Return the imaginary part of this number, which is zero.

EXAMPLES:

sage: a = RDF(3)
sage: a.imag()
0.0

integer_part()

If in decimal this number is written n.defg, returns n.

EXAMPLES:

sage: r = RDF('-1.6')
sage: a = r.integer_part(); a
-1
sage: type(a)
<type 'sage.rings.integer.Integer'>
sage: r = RDF(0.0/0.0)
sage: a = r.integer_part()
Traceback (most recent call last):
...
TypeError: Attempt to get integer part of NaN

is_NaN()

Check if self is NaN.

EXAMPLES:

sage: RDF(1).is_NaN()
False
sage: a = RDF(0)/RDF(0)
sage: a.is_NaN()
True

is_infinity()

Check if self is $$\infty$$.

EXAMPLES:

sage: a = RDF(2); b = RDF(0)
sage: (a/b).is_infinity()
True
sage: (b/a).is_infinity()
False

is_integer()

Return True if this number is a integer

EXAMPLES:

sage: RDF(3.5).is_integer()
False
sage: RDF(3).is_integer()
True

is_negative_infinity()

Check if self is $$-\infty$$.

EXAMPLES:

sage: a = RDF(2)/RDF(0)
sage: a.is_negative_infinity()
False
sage: a = RDF(-3)/RDF(0)
sage: a.is_negative_infinity()
True

is_positive_infinity()

Check if self is $$+\infty$$.

EXAMPLES:

sage: a = RDF(1)/RDF(0)
sage: a.is_positive_infinity()
True
sage: a = RDF(-1)/RDF(0)
sage: a.is_positive_infinity()
False

is_square()

Return whether or not this number is a square in this field. For the real numbers, this is True if and only if self is non-negative.

EXAMPLES:

sage: RDF(3.5).is_square()
True
sage: RDF(0).is_square()
True
sage: RDF(-4).is_square()
False

log(base=None)

Return the logarithm.

INPUT:

• base – integer or None (default). The base of the logarithm. If None is specified, the base is $$e$$ (the so-called natural logarithm).

OUTPUT:

The logarithm of self. If self is positive, a double floating point number. Infinity if self is zero. A imaginary complex floating point number if self is negative.

EXAMPLES:

sage: RDF(2).log()
0.6931471805599453
sage: RDF(2).log(2)
1.0
sage: RDF(2).log(pi)
0.6055115613982801
sage: RDF(2).log(10)
0.30102999566398114
sage: RDF(2).log(1.5)
1.7095112913514547
sage: RDF(0).log()
-infinity
sage: RDF(-1).log()
3.141592653589793*I
sage: RDF(-1).log(2)  # rel tol 1e-15
4.532360141827194*I


TESTS:

Make sure that we can take the log of small numbers accurately and the fix doesn’t break preexisting values (trac ticket #12557):

sage: R = RealField(128)
sage: def check_error(x):
....:   x = RDF(x)
....:   log_RDF = x.log()
....:   log_RR = R(x).log()
....:   diff = R(log_RDF) - log_RR
....:   if abs(diff) < log_RDF.ulp():
....:       return True
....:   print "logarithm check failed for %s (diff = %s ulp)"%             ....:       (x, diff/log_RDF.ulp())
....:   return False
sage: all( check_error(2^x) for x in range(-100,100) )
True
sage: all( check_error(x) for x in sxrange(0.01, 2.00, 0.01) )
True
sage: all( check_error(x) for x in sxrange(0.99, 1.01, 0.001) )
True
sage: RDF(1.000000001).log()
1.000000082240371e-09
sage: RDF(1e-17).log()
-39.14394658089878
sage: RDF(1e-50).log()
-115.12925464970229

log10()

Return log to the base 10 of self.

EXAMPLES:

sage: r = RDF('16.0'); r.log10()
1.2041199826559246
sage: r.log() / RDF(log(10))
1.2041199826559246
sage: r = RDF('39.9'); r.log10()
1.6009728956867482

log2()

Return log to the base 2 of self.

EXAMPLES:

sage: r = RDF(16.0)
sage: r.log2()
4.0

sage: r = RDF(31.9); r.log2()
4.995484518877507

logpi()

Return log to the base $$\pi$$ of self.

EXAMPLES:

sage: r = RDF(16); r.logpi()
2.4220462455931204
sage: r.log() / RDF(log(pi))
2.4220462455931204
sage: r = RDF('39.9'); r.logpi()
3.2203023346075152

multiplicative_order()

Returns $$n$$ such that self^n == 1.

Only $$\pm 1$$ have finite multiplicative order.

EXAMPLES:

sage: RDF(1).multiplicative_order()
1
sage: RDF(-1).multiplicative_order()
2
sage: RDF(3).multiplicative_order()
+Infinity

nan()

Return Not-a-Number NaN.

EXAMPLES:

sage: RDF.NaN()
NaN

nth_root(n)

Return the $$n^{th}$$ root of self.

INPUT:

• n – an integer

OUTPUT:

The output is a complex double if self is negative and $$n$$ is even, otherwise it is a real double.

EXAMPLES:

sage: r = RDF(-125.0); r.nth_root(3)
-5.000000000000001
sage: r.nth_root(5)
-2.6265278044037674
sage: RDF(-2).nth_root(5)^5  # rel tol 1e-15
-2.000000000000001
sage: RDF(-1).nth_root(5)^5
-1.0
sage: RDF(3).nth_root(10)^10
2.9999999999999982
sage: RDF(-1).nth_root(2)
6.123233995736757e-17 + 1.0*I
sage: RDF(-1).nth_root(4)
0.7071067811865476 + 0.7071067811865475*I

prec()

Return the precision of this number in bits.

Always returns 53.

EXAMPLES:

sage: RDF(0).prec()
53

real()

Return self - we are already real.

EXAMPLES:

sage: a = RDF(3)
sage: a.real()
3.0

restrict_angle()

Return a number congruent to self mod $$2\pi$$ that lies in the interval $$(-\pi, \pi]$$.

Specifically, it is the unique $$x \in (-\pi, \pi]$$ such that self $$= x + 2\pi n$$ for some $$n \in \ZZ$$.

EXAMPLES:

sage: RDF(pi).restrict_angle()
3.141592653589793
sage: RDF(pi + 1e-10).restrict_angle()
-3.1415926534897936
sage: RDF(1+10^10*pi).restrict_angle()
0.9999977606...

round()

Given real number $$x$$, rounds up if fractional part is greater than $$0.5$$, rounds down if fractional part is less than $$0.5$$.

EXAMPLES:

sage: RDF(0.49).round()
0
sage: a=RDF(0.51).round(); a
1

sech()

Return the hyperbolic secant of self.

EXAMPLES:

sage: RDF(pi).sech()
0.08626673833405443
sage: CDF(pi).sech()
0.08626673833405443

sign()

Returns -1,0, or 1 if self is negative, zero, or positive; respectively.

EXAMPLES:

sage: RDF(-1.5).sign()
-1
sage: RDF(0).sign()
0
sage: RDF(2.5).sign()
1

sign_mantissa_exponent()

Return the sign, mantissa, and exponent of self.

In Sage (as in MPFR), floating-point numbers of precision $$p$$ are of the form $$s m 2^{e-p}$$, where $$s \in \{-1, 1\}$$, $$2^{p-1} \leq m < 2^p$$, and $$-2^{30} + 1 \leq e \leq 2^{30} - 1$$; plus the special values +0, -0, +infinity, -infinity, and NaN (which stands for Not-a-Number).

This function returns $$s$$, $$m$$, and $$e-p$$. For the special values:

• +0 returns (1, 0, 0)
• -0 returns (-1, 0, 0)
• the return values for +infinity, -infinity, and NaN are not specified.

EXAMPLES:

sage: a = RDF(exp(1.0)); a
2.718281828459045
sage: sign,mantissa,exponent = RDF(exp(1.0)).sign_mantissa_exponent()
sage: sign,mantissa,exponent
(1, 6121026514868073, -51)
sage: sign*mantissa*(2**exponent) == a
True


The mantissa is always a nonnegative number:

sage: RDF(-1).sign_mantissa_exponent()
(-1, 4503599627370496, -52)


TESTS:

sage: RDF('+0').sign_mantissa_exponent()
(1, 0, 0)
sage: RDF('-0').sign_mantissa_exponent()
(-1, 0, 0)

sin()

Return the sine of self.

EXAMPLES:

sage: RDF(2).sin()
0.9092974268256817

sincos()

Return a pair consisting of the sine and cosine of self.

EXAMPLES:

sage: t = RDF.pi()/6
sage: t.sincos()
(0.49999999999999994, 0.8660254037844387)

sinh()

Return the hyperbolic sine of self.

EXAMPLES:

sage: q = RDF.pi()/12
sage: q.sinh()
0.26480022760227073

sqrt(extend=True, all=False)

The square root function.

INPUT:

• extend – bool (default: True); if True, return a square root in a complex field if necessary if self is negative; otherwise raise a ValueError.
• all – bool (default: False); if True, return a list of all square roots.

EXAMPLES:

sage: r = RDF(4.0)
sage: r.sqrt()
2.0
sage: r.sqrt()^2 == r
True

sage: r = RDF(4344)
sage: r.sqrt()
65.90902821313632
sage: r.sqrt()^2 - r
0.0

sage: r = RDF(-2.0)
sage: r.sqrt()
1.4142135623730951*I

sage: RDF(2).sqrt(all=True)
[1.4142135623730951, -1.4142135623730951]
sage: RDF(0).sqrt(all=True)
[0.0]
sage: RDF(-2).sqrt(all=True)
[1.4142135623730951*I, -1.4142135623730951*I]

str()

Return the informal string representation of self.

EXAMPLES:

sage: a = RDF('4.5'); a.str()
'4.5'
sage: a = RDF('49203480923840.2923904823048'); a.str()
'4.92034809238e+13'
sage: a = RDF(1)/RDF(0); a.str()
'+infinity'
sage: a = -RDF(1)/RDF(0); a.str()
'-infinity'
sage: a = RDF(0)/RDF(0); a.str()
'NaN'


We verify consistency with RR (mpfr reals):

sage: str(RR(RDF(1)/RDF(0))) == str(RDF(1)/RDF(0))
True
sage: str(RR(-RDF(1)/RDF(0))) == str(-RDF(1)/RDF(0))
True
sage: str(RR(RDF(0)/RDF(0))) == str(RDF(0)/RDF(0))
True

tan()

Return the tangent of self.

EXAMPLES:

sage: q = RDF.pi()/3
sage: q.tan()
1.7320508075688767
sage: q = RDF.pi()/6
sage: q.tan()
0.5773502691896256

tanh()

Return the hyperbolic tangent of self.

EXAMPLES:

sage: q = RDF.pi()/12
sage: q.tanh()
0.25597778924568454

trunc()

Truncates this number (returns integer part).

EXAMPLES:

sage: RDF(2.99).trunc()
2
sage: RDF(-2.00).trunc()
-2
sage: RDF(0.00).trunc()
0

ulp()

Returns the unit of least precision of self, which is the weight of the least significant bit of self. This is always a strictly positive number. It is also the gap between this number and the closest number with larger absolute value that can be represented.

EXAMPLES:

sage: a = RDF(pi)
sage: a.ulp()
4.440892098500626e-16
sage: b = a + a.ulp()


Adding or subtracting an ulp always gives a different number:

sage: a + a.ulp() == a
False
sage: a - a.ulp() == a
False
sage: b + b.ulp() == b
False
sage: b - b.ulp() == b
False


Since the default rounding mode is round-to-nearest, adding or subtracting something less than half an ulp always gives the same number, unless the result has a smaller ulp. The latter can only happen if the input number is (up to sign) exactly a power of 2:

sage: a - a.ulp()/3 == a
True
sage: a + a.ulp()/3 == a
True
sage: b - b.ulp()/3 == b
True
sage: b + b.ulp()/3 == b
True
sage: c = RDF(1)
sage: c - c.ulp()/3 == c
False
sage: c.ulp()
2.220446049250313e-16
sage: (c - c.ulp()).ulp()
1.1102230246251565e-16


The ulp is always positive:

sage: RDF(-1).ulp()
2.220446049250313e-16


The ulp of zero is the smallest positive number in RDF:

sage: RDF(0).ulp()
5e-324
sage: RDF(0).ulp()/2
0.0


Some special values:

sage: a = RDF(1)/RDF(0); a
+infinity
sage: a.ulp()
+infinity
sage: (-a).ulp()
+infinity
sage: a = RDF('nan')
sage: a.ulp() is a
True


The ulp method works correctly with small numbers:

sage: u = RDF(0).ulp()
sage: u.ulp() == u
True
sage: x = u * (2^52-1)  # largest denormal number
sage: x.ulp() == u
True
sage: x = u * 2^52  # smallest normal number
sage: x.ulp() == u
True

zeta()

Return the Riemann zeta function evaluated at this real number.

Note

PARI is vastly more efficient at computing the Riemann zeta function. See the example below for how to use it.

EXAMPLES:

sage: RDF(2).zeta()  # rel tol 1e-15
1.6449340668482269
sage: RDF.pi()^2/6
1.6449340668482264
sage: RDF(-2).zeta()
0.0
sage: RDF(1).zeta()
+infinity

sage.rings.real_double.RealDoubleField()

Return the unique instance of the real double field.

EXAMPLES:

sage: RealDoubleField() is RealDoubleField()
True

class sage.rings.real_double.RealDoubleField_class

Bases: sage.rings.ring.Field

An approximation to the field of real numbers using double precision floating point numbers. Answers derived from calculations in this approximation may differ from what they would be if those calculations were performed in the true field of real numbers. This is due to the rounding errors inherent to finite precision calculations.

EXAMPLES:

sage: RR == RDF
False
sage: RDF == RealDoubleField()    # RDF is the shorthand
True

sage: RDF(1)
1.0
sage: RDF(2/3)
0.6666666666666666


A TypeError is raised if the coercion doesn’t make sense:

sage: RDF(QQ['x'].0)
Traceback (most recent call last):
...
TypeError: cannot coerce nonconstant polynomial to float
sage: RDF(QQ['x'](3))
3.0


One can convert back and forth between double precision real numbers and higher-precision ones, though of course there may be loss of precision:

sage: a = RealField(200)(2).sqrt(); a
1.4142135623730950488016887242096980785696718753769480731767
sage: b = RDF(a); b
1.4142135623730951
sage: a.parent()(b)
1.4142135623730951454746218587388284504413604736328125000000
sage: a.parent()(b) == b
True
sage: b == RR(a)
True

NaN()

Return Not-a-Number NaN.

EXAMPLES:

sage: RDF.NaN()
NaN

algebraic_closure()

Return the algebraic closure of self, i.e., the complex double field.

EXAMPLES:

sage: RDF.algebraic_closure()
Complex Double Field

characteristic()

Returns 0, since the field of real numbers has characteristic 0.

EXAMPLES:

sage: RDF.characteristic()
0

complex_field()

Return the complex field with the same precision as self, i.e., the complex double field.

EXAMPLES:

sage: RDF.complex_field()
Complex Double Field

construction()

Returns the functorial construction of self, namely, completion of the rational numbers with respect to the prime at $$\infty$$.

Also preserves other information that makes this field unique (i.e. the Real Double Field).

EXAMPLES:

sage: c, S = RDF.construction(); S
Rational Field
sage: RDF == c(S)
True

euler_constant()

Return Euler’s gamma constant to double precision.

EXAMPLES:

sage: RDF.euler_constant()
0.5772156649015329

factorial(n)

Return the factorial of the integer $$n$$ as a real number.

EXAMPLES:

sage: RDF.factorial(100)
9.332621544394415e+157

gen(n=0)

Return the generator of the real double field.

EXAMPLES:

sage: RDF.0
1.0
sage: RDF.gens()
(1.0,)

is_exact()

Returns False, because doubles are not exact.

EXAMPLE:

sage: RDF.is_exact()
False

is_finite()

Return False, since the field of real numbers is not finite.

Technical note: There exists an upper bound on the double representation.

EXAMPLES:

sage: RDF.is_finite()
False

log2()

Return $$\log(2)$$ to the precision of this field.

EXAMPLES:

sage: RDF.log2()
0.6931471805599453
sage: RDF(2).log()
0.6931471805599453

name()

The name of self.

EXAMPLES:

sage: RDF.name()
'RealDoubleField'

nan()

Return Not-a-Number NaN.

EXAMPLES:

sage: RDF.NaN()
NaN

ngens()

Return the number of generators which is always 1.

EXAMPLES:

sage: RDF.ngens()
1

pi()

Returns $$\pi$$ to double-precision.

EXAMPLES:

sage: RDF.pi()
3.141592653589793
sage: RDF.pi().sqrt()/2
0.8862269254527579

prec()

Return the precision of this real double field in bits.

Always returns 53.

EXAMPLES:

sage: RDF.precision()
53

precision()

Return the precision of this real double field in bits.

Always returns 53.

EXAMPLES:

sage: RDF.precision()
53

random_element(min=-1, max=1)

Return a random element of this real double field in the interval [min, max].

EXAMPLES:

sage: RDF.random_element()
0.7369454235661859
sage: RDF.random_element(min=100, max=110)
102.8159473516245

to_prec(prec)

Return the real field to the specified precision. As doubles have fixed precision, this will only return a real double field if prec is exactly 53.

EXAMPLES:

sage: RDF.to_prec(52)
Real Field with 52 bits of precision
sage: RDF.to_prec(53)
Real Double Field

zeta(n=2)

Return an $$n$$-th root of unity in the real field, if one exists, or raise a ValueError otherwise.

EXAMPLES:

sage: RDF.zeta()
-1.0
sage: RDF.zeta(1)
1.0
sage: RDF.zeta(5)
Traceback (most recent call last):
...
ValueError: No 5th root of unity in self

class sage.rings.real_double.ToRDF

Fast morphism from anything with a __float__ method to an RDF element.

EXAMPLES:

sage: f = RDF.coerce_map_from(ZZ); f
Native morphism:
From: Integer Ring
To:   Real Double Field
sage: f(4)
4.0
sage: f = RDF.coerce_map_from(QQ); f
Native morphism:
From: Rational Field
To:   Real Double Field
sage: f(1/2)
0.5
sage: f = RDF.coerce_map_from(int); f
Native morphism:
From: Set of Python objects of type 'int'
To:   Real Double Field
sage: f(3r)
3.0
sage: f = RDF.coerce_map_from(float); f
Native morphism:
From: Set of Python objects of type 'float'
To:   Real Double Field
sage: f(3.5)
3.5

sage.rings.real_double.is_RealDoubleElement(x)

Check if x is an element of the real double field.

EXAMPLE:

sage: from sage.rings.real_double import is_RealDoubleElement
sage: is_RealDoubleElement(RDF(3))
True
sage: is_RealDoubleElement(RIF(3))
False

sage.rings.real_double.is_RealDoubleField(x)

Returns True if x is the field of real double precision numbers.

EXAMPLES:

sage: from sage.rings.real_double import is_RealDoubleField
sage: is_RealDoubleField(RDF)
True
sage: is_RealDoubleField(RealField(53))
False

sage.rings.real_double.pool_stats()

Statistics for the real double pool.

EXAMPLES:

We first pull all elements from the pool (making sure it is empty to illustrate how the pool works):

sage: from sage.rings.real_double import time_alloc_list, pool_stats
sage: L = time_alloc_list(50)
sage: pool_stats()
Used pool 0 / 0 times
Pool contains 0 / 50 items


During the operation (in this example, addition), we end up with two temporary elements. After completion of the operation, they are added to the pool:

sage: RDF(2.1) + RDF(2.2)
4.300000000000001
sage: pool_stats()
Used pool 0 / 0 times
Pool contains 2 / 50 items


Next when we call time_alloc_list(), the “created” elements are actually pulled from the pool:

sage: time_alloc_list(3)
[2.2, 2.1, 0.0]


Note that the number of objects left in the pool depends on the garbage collector:

sage: pool_stats()
Used pool 0 / 0 times
Pool contains 1 / 50 items

sage.rings.real_double.time_alloc(n)

Allocate n RealDoubleElement instances.

EXAMPLES:

Since this does not store anything in a python object, the created elements will not be sent to the garbage collector. Therefore they remain in the pool:

sage: from sage.rings.real_double import time_alloc, pool_stats
sage: pool_stats()
Used pool 0 / 0 times
Pool contains 7 / 50 items
sage: time_alloc(25)
sage: pool_stats()
Used pool 0 / 0 times
Pool contains 7 / 50 items

sage.rings.real_double.time_alloc_list(n)

Allocate a list of length n of RealDoubleElement instances.

EXAMPLES:

During the operation (in this example, addition), we end up with two temporary elements. After completion of the operation, they are added to the pool:

sage: from sage.rings.real_double import time_alloc_list
sage: RDF(2.1) + RDF(2.2)
4.300000000000001


Next when we call time_alloc_list(), the “created” elements are actually pulled from the pool:

sage: time_alloc_list(2)
[2.2, 2.1]
`

Previous topic

Fixed and Arbitrary Precision Numerical Fields

Next topic

Arbitrary Precision Real Numbers