Primitive Type f64

Operations and constants for 64-bits floats (f64 type)

Trait Implementations

`impl Float for f64`

`fn nan() -> f64`

`fn infinity() -> f64`

`fn neg_infinity() -> f64`

`fn neg_zero() -> f64`

`fn is_nan(self) -> bool`

Returns true if the number is NaN

`fn is_infinite(self) -> bool`

Returns true if the number is infinite

`fn is_finite(self) -> bool`

Returns true if the number is neither infinite or NaN

`fn is_normal(self) -> bool`

Returns true if the number is neither zero, infinite, subnormal or NaN

`fn classify(self) -> FPCategory`

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

`fn mantissa_digits(_: Option<f64>) -> uint`

`fn digits(_: Option<f64>) -> uint`

`fn epsilon() -> f64`

`fn min_exp(_: Option<f64>) -> int`

`fn max_exp(_: Option<f64>) -> int`

`fn min_10_exp(_: Option<f64>) -> int`

`fn max_10_exp(_: Option<f64>) -> int`

`fn min_pos_value(_: Option<f64>) -> f64`

`fn integer_decode(self) -> (u64, i16, i8)`

Returns the mantissa, exponent and sign as integers.

`fn floor(self) -> f64`

Round half-way cases toward NEG_INFINITY

`fn ceil(self) -> f64`

Round half-way cases toward INFINITY

`fn round(self) -> f64`

Round half-way cases away from 0.0

`fn trunc(self) -> f64`

The integer part of the number (rounds towards 0.0)

`fn fract(self) -> f64`

The fractional part of the number, satisfying:

fn main() { let x = 1.65f64; assert!(x == x.trunc() + x.fract()) }

let x = 1.65f64;
assert!(x == x.trunc() + x.fract())

`fn mul_add(self, a: f64, b: f64) -> f64`

Fused multiply-add. Computes (self * a) + b with only one rounding error. This produces a more accurate result with better performance than a separate multiplication operation followed by an add.

`fn recip(self) -> f64`

The reciprocal (multiplicative inverse) of the number

`fn powf(self, n: f64) -> f64`

`fn powi(self, n: i32) -> f64`

`fn sqrt2() -> f64`

sqrt(2.0)

`fn frac_1_sqrt2() -> f64`

1.0 / sqrt(2.0)

`fn sqrt(self) -> f64`

`fn rsqrt(self) -> f64`

`fn pi() -> f64`

Archimedes' constant

`fn two_pi() -> f64`

2.0 * pi

`fn frac_pi_2() -> f64`

pi / 2.0

`fn frac_pi_3() -> f64`

pi / 3.0

`fn frac_pi_4() -> f64`

pi / 4.0

`fn frac_pi_6() -> f64`

pi / 6.0

`fn frac_pi_8() -> f64`

pi / 8.0

`fn frac_1_pi() -> f64`

1.0 / pi

`fn frac_2_pi() -> f64`

2.0 / pi

`fn frac_2_sqrtpi() -> f64`

2.0 / sqrt(pi)

`fn e() -> f64`

Euler's number

`fn log2_e() -> f64`

log2(e)

`fn log10_e() -> f64`

log10(e)

`fn ln_2() -> f64`

ln(2.0)

`fn ln_10() -> f64`

ln(10.0)

`fn exp(self) -> f64`

Returns the exponential of the number

`fn exp2(self) -> f64`

Returns 2 raised to the power of the number

`fn ln(self) -> f64`

Returns the natural logarithm of the number

`fn log(self, base: f64) -> f64`

Returns the logarithm of the number with respect to an arbitrary base

`fn log2(self) -> f64`

Returns the base 2 logarithm of the number

`fn log10(self) -> f64`

Returns the base 10 logarithm of the number

`fn to_degrees(self) -> f64`

Converts to degrees, assuming the number is in radians

`fn to_radians(self) -> f64`

Converts to radians, assuming the number is in degrees

`impl Num for f64`

`impl Zero for f64`

`fn zero() -> f64`

`fn is_zero(&self) -> bool`

`impl One for f64`

`fn one() -> f64`

`impl Signed for f64`

`fn abs(&self) -> f64`

Computes the absolute value. Returns NAN if the number is NAN.

`fn abs_sub(&self, other: &f64) -> f64`

The positive difference of two numbers. Returns 0.0 if the number is less than or equal to other, otherwise the difference betweenself and other is returned.

`fn signum(&self) -> f64`

Returns

1.0 if the number is positive, +0.0 or INFINITY
-1.0 if the number is negative, -0.0 or NEG_INFINITY
NAN if the number is NaN

`fn is_positive(&self) -> bool`

Returns true if the number is positive, including +0.0 and INFINITY

`fn is_negative(&self) -> bool`

Returns true if the number is negative, including -0.0 and NEG_INFINITY

`impl Bounded for f64`

`fn min_value() -> f64`

`fn max_value() -> f64`

`impl Primitive for f64`

`impl ToPrimitive for f64`

`fn to_int(&self) -> Option<int>`

`fn to_i8(&self) -> Option<i8>`

`fn to_i16(&self) -> Option<i16>`

`fn to_i32(&self) -> Option<i32>`

`fn to_i64(&self) -> Option<i64>`

`fn to_uint(&self) -> Option<uint>`

`fn to_u8(&self) -> Option<u8>`

`fn to_u16(&self) -> Option<u16>`

`fn to_u32(&self) -> Option<u32>`

`fn to_u64(&self) -> Option<u64>`

`fn to_f32(&self) -> Option<f32>`

`fn to_f64(&self) -> Option<f64>`

`impl FromPrimitive for f64`

`fn from_int(n: int) -> Option<f64>`

`fn from_i8(n: i8) -> Option<f64>`

`fn from_i16(n: i16) -> Option<f64>`

`fn from_i32(n: i32) -> Option<f64>`

`fn from_i64(n: i64) -> Option<f64>`

`fn from_uint(n: uint) -> Option<f64>`

`fn from_u8(n: u8) -> Option<f64>`

`fn from_u16(n: u16) -> Option<f64>`

`fn from_u32(n: u32) -> Option<f64>`

`fn from_u64(n: u64) -> Option<f64>`

`fn from_f32(n: f32) -> Option<f64>`

`fn from_f64(n: f64) -> Option<f64>`

`impl NumCast for f64`

`fn from<N: ToPrimitive>(n: N) -> Option<f64>`

`impl Add<f64, f64> for f64`

`fn add(&self, other: &f64) -> f64`

`impl Sub<f64, f64> for f64`

`fn sub(&self, other: &f64) -> f64`

`impl Mul<f64, f64> for f64`

`fn mul(&self, other: &f64) -> f64`

`impl Div<f64, f64> for f64`

`fn div(&self, other: &f64) -> f64`

`impl Rem<f64, f64> for f64`

`fn rem(&self, other: &f64) -> f64`

`impl Neg<f64> for f64`

`fn neg(&self) -> f64`

`impl PartialEq for f64`

`fn eq(&self, other: &f64) -> bool`

`fn ne(&self, other: &f64) -> bool`

`impl PartialOrd for f64`

`fn lt(&self, other: &f64) -> bool`

`fn le(&self, other: &f64) -> bool`

`fn ge(&self, other: &f64) -> bool`

`fn gt(&self, other: &f64) -> bool`

`impl Clone for f64`

`fn clone(&self) -> f64`

Return a deep copy of the value.

Modules

Primitive Type f64

Trait Implementations

impl Float for f64

fn nan() -> f64

fn infinity() -> f64

fn neg_infinity() -> f64

fn neg_zero() -> f64

fn is_nan(self) -> bool

fn is_infinite(self) -> bool

fn is_finite(self) -> bool

fn is_normal(self) -> bool

fn classify(self) -> FPCategory

fn mantissa_digits(_: Option<f64>) -> uint

fn digits(_: Option<f64>) -> uint

fn epsilon() -> f64

fn min_exp(_: Option<f64>) -> int

fn max_exp(_: Option<f64>) -> int

fn min_10_exp(_: Option<f64>) -> int

fn max_10_exp(_: Option<f64>) -> int

fn min_pos_value(_: Option<f64>) -> f64

fn integer_decode(self) -> (u64, i16, i8)

fn floor(self) -> f64

fn ceil(self) -> f64

fn round(self) -> f64

fn trunc(self) -> f64

fn fract(self) -> f64

fn mul_add(self, a: f64, b: f64) -> f64

fn recip(self) -> f64

fn powf(self, n: f64) -> f64

fn powi(self, n: i32) -> f64

fn sqrt2() -> f64

fn frac_1_sqrt2() -> f64

fn sqrt(self) -> f64

fn rsqrt(self) -> f64

fn pi() -> f64

fn two_pi() -> f64

fn frac_pi_2() -> f64

fn frac_pi_3() -> f64

fn frac_pi_4() -> f64

fn frac_pi_6() -> f64

fn frac_pi_8() -> f64

fn frac_1_pi() -> f64

fn frac_2_pi() -> f64

fn frac_2_sqrtpi() -> f64

fn e() -> f64

fn log2_e() -> f64

fn log10_e() -> f64

fn ln_2() -> f64

fn ln_10() -> f64

fn exp(self) -> f64

fn exp2(self) -> f64

fn ln(self) -> f64

fn log(self, base: f64) -> f64

fn log2(self) -> f64

fn log10(self) -> f64

fn to_degrees(self) -> f64

fn to_radians(self) -> f64

impl Num for f64

impl Zero for f64

fn zero() -> f64

fn is_zero(&self) -> bool

impl One for f64

fn one() -> f64

impl Signed for f64

fn abs(&self) -> f64

fn abs_sub(&self, other: &f64) -> f64

fn signum(&self) -> f64