Builtin type std::prelude::f64

Double precision floating point type

Methods

• fn parse(s: &[u8]) -> Option<f64>

  source

  Parses a floating point number from a string.

  Returns Option::none() if the string does not represent a valid floating point number.

  Example

  assert_eq!(f64::parse("3.1415"), Option::some(3.1415));
  assert_eq!(f64::parse("inf"), Option::some(f64::infinity()));
  Run this example

• fn is_sign_negative(self: f64) -> bool

  source

  Returns true if the number has a negative sign, false otherwise.

• fn max_value() -> f64

  source

  Returns the maximum value of f64

• fn min_value() -> f64

  source

  Returns the minimum value of f64

• fn min_positive() -> f64

  source

  Returns the smallest positive value of f64.

• fn epsilon() -> f64

  source

  Returns the machine epsilon for f64.

• fn from_bits(bits: u64) -> f64

  source

  Create f64 from raw bits

  Example

  let f = f64::from_bits(0x400921fb54442d18);
  assert_eq!(f, std::math::PI);
  Run this example

• fn to_bits(self: f64) -> u64

  source

  Returns the raw bits of self

  Example

  let x = 1.0f64;
  assert_eq!(x.to_bits(), 0x3ff0000000000000u64);
  Run this example

• fn next_up(self: f64) -> f64

  source

  Returns the smallest floating point number strictly greater than self.

  If self is NaN or positive infinity, it returns self unchanged.

  Example

  assert_eq!(0.0.next_up(), 5.0e-324);
  assert_eq!(1.0.next_up(), 1.0000000000000002);
  assert_eq!((-1.0).next_up(), -0.9999999999999999);
  assert_eq!(f64::neg_infinity().next_up(), -1.7976931348623157e308);
  assert_eq!(f64::infinity().next_up(), f64::infinity());
  assert!(f64::nan().next_up().is_nan());
  Run this example

• fn next_down(self: f64) -> f64

  source

  Returns the largest floating point number strictly less than self.

  If self is NaN or negative infinity, it returns self unchanged.

  Example

  assert_eq!(0.0.next_down(), -5.0e-324);
  assert_eq!(1.0.next_down(), 0.9999999999999999);
  assert_eq!((-1.0).next_down(), -1.0000000000000002);
  assert_eq!(f64::neg_infinity().next_down(), f64::neg_infinity());
  assert_eq!(f64::infinity().next_down(), 1.7976931348623157e308);
  assert!(f64::nan().next_down().is_nan());
  Run this example

• fn acos(self: f64) -> f64

  source

  Inverse cosine

• fn asin(self: f64) -> f64

  source

  Inverse sine

• fn atan(self: f64) -> f64

  source

  Inverse tangent

• fn atan2(self: f64, other: f64) -> f64

  source

  Four-quadrant inverse tangent

• fn atanh(self: f64) -> f64

  source

  Inverse hyperbolic cosine

• fn cbrt(self: f64) -> f64

  source

  Cube root

• fn ceil(self: f64) -> f64

  source

  Ceiling of number

• fn cos(self: f64) -> f64

  source

  Cosine

• fn cosh(self: f64) -> f64

  source

  Hyperbolic cosine

• fn erf(self: f64) -> f64

  source

  Gauss error function

• fn erfc(self: f64) -> f64

  source

  Complementary error function (1 - erf(self))

• fn exp(self: f64) -> f64

  source

  Exponential function (e^self)

• fn floor(self: f64) -> f64

  source

  Floor of number

• fn frexp(self: f64) -> (f64, i32)

  source

  Decomposes self into a normalized fractional part and an integral power of two.

  Inverse of ldexp.

• fn ldexp(self: f64, exp: i32) -> f64

  source

  Multiplies self by 2 raised to the power of exp.

  Inverse of frexp.

• fn log(self: f64) -> f64

  source

  Natural logarithm

• fn log2(self: f64) -> f64

  source

  Base 2 logarithm

• fn log10(self: f64) -> f64

  source

  Base 10 logarithm

• fn modf(self: f64) -> (f64, f64)

  source

  Decompose self into a whole and fractional part

• fn pow(self: f64, other: f64) -> f64

  source

  Power function

• fn round(self: f64) -> f64

  source

  Rounds self to the closest integer.

  If the number is halfway between two integers, it is rounded away from zero.

• fn sin(self: f64) -> f64

  source

  Sine function

• fn sinh(self: f64) -> f64

  source

  Hyperbolic sine function

• fn sqrt(self: f64) -> f64

  source

  Square root

• fn tan(self: f64) -> f64

  source

  Tangent function

• fn tanh(self: f64) -> f64

  source

  Hyperbolic tangent function

• fn trunc(self: f64) -> f64

  source

  Returns the integer part of self (round towards zero).

Mixins

• mixin BuiltinComparable<f64>

• fn equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if arguments are equal, false otherwise

  See Equatable for details.

• fn not_equals(lhs: &Self, rhs: &Self) -> bool

  source

  Returns false if arguments are equal, true otherwise

• fn compare(lhs: &Self, rhs: &Self) -> Ordering

  source

  Compare the value

  See Comparable for details.

• fn less_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is strictly less than rhs, false otherwise

• fn less_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs is less or equal to rhs, false otherwise

• fn greater_than(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs strictly greater than rhs, false otherwise

• fn greater_than_or_equal(lhs: &Self, rhs: &Self) -> bool

  source

  Returns true if lhs greater than or equal rhs, false otherwise

• mixin<F> FloatFormattable<f64, F>

  F: Formatter<F>

• fn fmt(self: &Self, formatter: &mut F) -> Result<(), Error>

  source

  Write the object into a given formatter.

  See Formattable for details.

• mixin FloatOps<f64>

• fn nan() -> Self

  source

  Returns NaN.

• fn infinity() -> Self

  source

  Returns a positive infinity.

• fn neg_infinity() -> Self

  source

  Returns a negative infinity.

• fn is_nan(self: Self) -> bool

  source

  Returns true if the number is NaN, false otherwise.

• fn is_infinite(self: Self) -> bool

  source

  Returns true if the number is infinite, false otherwise.

• fn is_finite(self: Self) -> bool

  source

  Returns true if the number is neither infinite nor NaN, false otherwise.