pub struct Double(/* private fields */);Implementations§
Source§impl Double
impl Double
pub const NEG_INFINITY: Self
pub const INFINITY: Self
pub const MIN: Self
pub const MAX: Self
pub const NAN: Self
pub fn new(f: f64) -> Self
Sourcepub fn is_infinite(&self) -> bool
pub fn is_infinite(&self) -> bool
Returns true if this value is positive infinity or negative infinity, and false otherwise.
Sourcepub fn is_positive(&self) -> bool
pub fn is_positive(&self) -> bool
Returns true if self has a positive sign, including +0.0, NaNs with
positive sign bit and positive infinity.
Note that IEEE 754 doesn’t assign any meaning to the sign bit in case
of a NaN, and as Rust doesn’t guarantee that the bit pattern of NaNs
are conserved over arithmetic operations, the result of
is_positive on a NaN might produce an unexpected result in some
cases.
See explanation of NaN as a special value
for more info.
Sourcepub fn is_negative(&self) -> bool
pub fn is_negative(&self) -> bool
Returns false if self has a negative sign, including -0.0, NaNs with
negative sign bit and negative infinity.
Note that IEEE 754 doesn’t assign any meaning to the sign bit in case
of a NaN, and as Rust doesn’t guarantee that the bit pattern of NaNs
are conserved over arithmetic operations, the result of
is_negative on a NaN might produce an unexpected result in some
cases.
See explanation of NaN as a special value
for more info.
Methods from Deref<Target = f64>§
pub const RADIX: u32 = 2u32
pub const MANTISSA_DIGITS: u32 = 53u32
pub const DIGITS: u32 = 15u32
pub const EPSILON: f64 = 2.2204460492503131E-16f64
pub const MIN: f64 = -1.7976931348623157E+308f64
pub const MIN_POSITIVE: f64 = 2.2250738585072014E-308f64
pub const MAX: f64 = 1.7976931348623157E+308f64
pub const MIN_EXP: i32 = -1_021i32
pub const MAX_EXP: i32 = 1_024i32
pub const MIN_10_EXP: i32 = -307i32
pub const MAX_10_EXP: i32 = 308i32
pub const NAN: f64 = NaN_f64
pub const INFINITY: f64 = +Inf_f64
pub const NEG_INFINITY: f64 = -Inf_f64
1.62.0 · Sourcepub fn total_cmp(&self, other: &f64) -> Ordering
pub fn total_cmp(&self, other: &f64) -> Ordering
Returns 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
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));
// `f64::NAN` could be positive or negative, which will affect the sort order.
if f64::NAN.is_sign_negative() {
assert!(bois.into_iter().map(|b| b.weight)
.zip([f64::NAN, -5.0, 0.1, 10.0, 99.0, f64::INFINITY].iter())
.all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
assert!(bois.into_iter().map(|b| b.weight)
.zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())
.all(|(a, b)| a.to_bits() == b.to_bits()))
}