Expand description
A 64-bit floating point type (specifically, the “binary64” type defined in IEEE 754-2008).
This type is very similar to f32, but has increased
precision by using twice as many bits. Please see the documentation for
f32 or Wikipedia on double precision
values for more information.
Implementations
Number of significant digits in base 2.
Machine epsilon value for f64.
This is the difference between 1.0 and the next larger representable number.
Smallest positive normal f64 value.
One greater than the minimum possible normal power of 2 exponent.
Minimum possible normal power of 10 exponent.
Maximum possible power of 10 exponent.
Negative infinity (−∞).
Returns true if this value is NaN.
let nan = f64::NAN;
let f = 7.0_f64;
assert!(nan.is_nan());
assert!(!f.is_nan());Returns true if this value is positive infinity or negative infinity, and
false otherwise.
let f = 7.0f64;
let inf = f64::INFINITY;
let neg_inf = f64::NEG_INFINITY;
let nan = f64::NAN;
assert!(!f.is_infinite());
assert!(!nan.is_infinite());
assert!(inf.is_infinite());
assert!(neg_inf.is_infinite());Returns true if this number is neither infinite nor NaN.
let f = 7.0f64;
let inf: f64 = f64::INFINITY;
let neg_inf: f64 = f64::NEG_INFINITY;
let nan: f64 = f64::NAN;
assert!(f.is_finite());
assert!(!nan.is_finite());
assert!(!inf.is_finite());
assert!(!neg_inf.is_finite());Returns true if the number is subnormal.
let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308_f64
let max = f64::MAX;
let lower_than_min = 1.0e-308_f64;
let zero = 0.0_f64;
assert!(!min.is_subnormal());
assert!(!max.is_subnormal());
assert!(!zero.is_subnormal());
assert!(!f64::NAN.is_subnormal());
assert!(!f64::INFINITY.is_subnormal());
// Values between `0` and `min` are Subnormal.
assert!(lower_than_min.is_subnormal());Returns true if the number is neither zero, infinite,
subnormal, or NaN.
let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64
let max = f64::MAX;
let lower_than_min = 1.0e-308_f64;
let zero = 0.0f64;
assert!(min.is_normal());
assert!(max.is_normal());
assert!(!zero.is_normal());
assert!(!f64::NAN.is_normal());
assert!(!f64::INFINITY.is_normal());
// Values between `0` and `min` are Subnormal.
assert!(!lower_than_min.is_normal());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.
use std::num::FpCategory;
let num = 12.4_f64;
let inf = f64::INFINITY;
assert_eq!(num.classify(), FpCategory::Normal);
assert_eq!(inf.classify(), FpCategory::Infinite);Returns true if self has a positive sign, including +0.0, NaNs with
positive sign bit and positive infinity.
let f = 7.0_f64;
let g = -7.0_f64;
assert!(f.is_sign_positive());
assert!(!g.is_sign_positive());Returns true if self has a negative sign, including -0.0, NaNs with
negative sign bit and negative infinity.
let f = 7.0_f64;
let g = -7.0_f64;
assert!(!f.is_sign_negative());
assert!(g.is_sign_negative());Takes the reciprocal (inverse) of a number, 1/x.
let x = 2.0_f64;
let abs_difference = (x.recip() - (1.0 / x)).abs();
assert!(abs_difference < 1e-10);Converts radians to degrees.
let angle = std::f64::consts::PI;
let abs_difference = (angle.to_degrees() - 180.0).abs();
assert!(abs_difference < 1e-10);Converts degrees to radians.
let angle = 180.0_f64;
let abs_difference = (angle.to_radians() - std::f64::consts::PI).abs();
assert!(abs_difference < 1e-10);Returns the maximum of the two numbers.
Follows the IEEE-754 2008 semantics for maxNum, except for handling of signaling NaNs. This matches the behavior of libm’s fmax.
let x = 1.0_f64;
let y = 2.0_f64;
assert_eq!(x.max(y), y);If one of the arguments is NaN, then the other argument is returned.
Returns the minimum of the two numbers.
Follows the IEEE-754 2008 semantics for minNum, except for handling of signaling NaNs. This matches the behavior of libm’s fmin.
let x = 1.0_f64;
let y = 2.0_f64;
assert_eq!(x.min(y), x);If one of the arguments is NaN, then the other argument is returned.
Returns the maximum of the two numbers, propagating NaNs.
This returns NaN when either argument is NaN, as opposed to
f64::max which only returns NaN when both arguments are NaN.
#![feature(float_minimum_maximum)]
let x = 1.0_f64;
let y = 2.0_f64;
assert_eq!(x.maximum(y), y);
assert!(x.maximum(f64::NAN).is_nan());If one of the arguments is NaN, then NaN is returned. Otherwise this returns the greater of the two numbers. For this operation, -0.0 is considered to be less than +0.0. Note that this follows the semantics specified in IEEE 754-2019.
Returns the minimum of the two numbers, propagating NaNs.
This returns NaN when either argument is NaN, as opposed to
f64::min which only returns NaN when both arguments are NaN.
#![feature(float_minimum_maximum)]
let x = 1.0_f64;
let y = 2.0_f64;
assert_eq!(x.minimum(y), x);
assert!(x.minimum(f64::NAN).is_nan());If one of the arguments is NaN, then NaN is returned. Otherwise this returns the lesser of the two numbers. For this operation, -0.0 is considered to be less than +0.0. Note that this follows the semantics specified in IEEE 754-2019.
Rounds toward zero and converts to any primitive integer type, assuming that the value is finite and fits in that type.
let value = 4.6_f64;
let rounded = unsafe { value.to_int_unchecked::<u16>() };
assert_eq!(rounded, 4);
let value = -128.9_f64;
let rounded = unsafe { value.to_int_unchecked::<i8>() };
assert_eq!(rounded, i8::MIN);Safety
The value must:
- Not be
NaN - Not be infinite
- Be representable in the return type
Int, after truncating off its fractional part
Raw transmutation to u64.
This is currently identical to transmute::<f64, u64>(self) on all platforms.
See from_bits for some discussion of the
portability of this operation (there are almost no issues).
Note that this function is distinct from as casting, which attempts to
preserve the numeric value, and not the bitwise value.
Examples
assert!((1f64).to_bits() != 1f64 as u64); // to_bits() is not casting!
assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
Raw transmutation from u64.
This is currently identical to transmute::<u64, f64>(v) on all platforms.
It turns out this is incredibly portable, for two reasons:
- Floats and Ints have the same endianness on all supported platforms.
- IEEE-754 very precisely specifies the bit layout of floats.
However there is one caveat: prior to the 2008 version of IEEE-754, how to interpret the NaN signaling bit wasn’t actually specified. Most platforms (notably x86 and ARM) picked the interpretation that was ultimately standardized in 2008, but some didn’t (notably MIPS). As a result, all signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.
Rather than trying to preserve signaling-ness cross-platform, this implementation favors preserving the exact bits. This means that any payloads encoded in NaNs will be preserved even if the result of this method is sent over the network from an x86 machine to a MIPS one.
If the results of this method are only manipulated by the same architecture that produced them, then there is no portability concern.
If the input isn’t NaN, then there is no portability concern.
If you don’t care about signaling-ness (very likely), then there is no portability concern.
Note that this function is distinct from as casting, which attempts to
preserve the numeric value, and not the bitwise value.
Examples
let v = f64::from_bits(0x4029000000000000);
assert_eq!(v, 12.5);Return the memory representation of this floating point number as a byte array in native byte order.
As the target platform’s native endianness is used, portable code
should use to_be_bytes or to_le_bytes, as appropriate, instead.
Examples
let bytes = 12.5f64.to_ne_bytes();
assert_eq!(
bytes,
if cfg!(target_endian = "big") {
[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
} else {
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
}
);Create a floating point value from its representation as a byte array in native endian.
As the target platform’s native endianness is used, portable code
likely wants to use from_be_bytes or from_le_bytes, as
appropriate instead.
Examples
let value = f64::from_ne_bytes(if cfg!(target_endian = "big") {
[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
} else {
[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40]
});
assert_eq!(value, 12.5);Return the ordering between self and other.
Unlike the standard partial comparison between floating point numbers,
this comparison always produces an ordering in accordance to
the totalOrder predicate as defined in the IEEE 754 (2008 revision)
floating point standard. The values are ordered in the following sequence:
- negative quiet NaN
- negative signaling NaN
- negative infinity
- negative numbers
- negative subnormal numbers
- negative zero
- positive zero
- positive subnormal numbers
- positive numbers
- positive infinity
- positive signaling NaN
- positive quiet NaN.
The ordering established by this function does not always agree with the
PartialOrd and PartialEq implementations of f64. For example,
they consider negative and positive zero equal, while total_cmp
doesn’t.
The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.
Example
#![feature(total_cmp)]
struct GoodBoy {
name: String,
weight: f64,
}
let mut bois = vec![
GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },
GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },
GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];
bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));Restrict a value to a certain interval unless it is NaN.
Returns max if self is greater than max, and min if self is
less than min. Otherwise this returns self.
Note that this function returns NaN if the initial value was NaN as well.
Panics
Panics if min > max, min is NaN, or max is NaN.
Examples
assert!((-3.0f64).clamp(-2.0, 1.0) == -2.0);
assert!((0.0f64).clamp(-2.0, 1.0) == 0.0);
assert!((2.0f64).clamp(-2.0, 1.0) == 1.0);
assert!((f64::NAN).clamp(-2.0, 1.0).is_nan());Trait Implementations
Performs the += operation. Read more
Performs the += operation. Read more
Performs the /= operation. Read more
Performs the /= operation. Read more
Converts a string in base 10 to a float. Accepts an optional decimal exponent.
This function accepts strings such as
- ‘3.14’
- ‘-3.14’
- ‘2.5E10’, or equivalently, ‘2.5e10’
- ‘2.5E-10’
- ‘5.’
- ‘.5’, or, equivalently, ‘0.5’
- ‘inf’, ‘-inf’, ‘NaN’
Leading and trailing whitespace represent an error.
Grammar
All strings that adhere to the following EBNF grammar
will result in an Ok being returned:
Float ::= Sign? ( 'inf' | 'NaN' | Number )
Number ::= ( Digit+ |
Digit+ '.' Digit* |
Digit* '.' Digit+ ) Exp?
Exp ::= [eE] Sign? Digit+
Sign ::= [+-]
Digit ::= [0-9]Arguments
- src - A string
Return value
Err(ParseFloatError) if the string did not represent a valid
number. Otherwise, Ok(n) where n is the floating-point
number represented by src.
type Err = ParseFloatError
type Err = ParseFloatError
The associated error which can be returned from parsing.
Performs the *= operation. Read more
Performs the *= operation. Read more
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than or equal to (for self and other) and is used by the >=
operator. Read more
The remainder from the division of two floats.
The remainder has the same sign as the dividend and is computed as:
x - (x / y).trunc() * y.
Examples
let x: f32 = 50.50;
let y: f32 = 8.125;
let remainder = x - (x / y).trunc() * y;
// The answer to both operations is 1.75
assert_eq!(x % y, remainder);Performs the %= operation. Read more
Performs the %= operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more