### Navigation

- index
- modules |
- next |
- previous |
- Fixed and Arbitrary Precision Numerical Fields »

# Double Precision Real Numbers

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`

  Bases: `sage.structure.element.FieldElement`

  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

  `parent`()

    Return the real double field, which is the parent of `self`.

    EXAMPLES:

        sage: a = RDF(2.3)
        sage: a.parent()
        Real Double Field
        sage: parent(a)
        Real Double Field

  `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`

  Bases: `sage.categories.morphism.Morphism`

  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]

### Navigation

- index
- modules |
- next |
- previous |
- Fixed and Arbitrary Precision Numerical Fields »