pub trait NextAfter {
// Required method
fn next_after(self, y: Self) -> Self;
}Expand description
Returns the next representable float value in the direction of y
This function is strict and will step to the very next representable floating point, even if that value is subnormal.
Base assumptions:
self == y -> return y
self >= positive infinity -> return positive infinity
self <= negative infinity -> return negative infinity
self == NaN -> return NaN
self == -0.0 and y == 0.0 -> return positive 0.0
self == -0.0 and y == positive infinity -> 5e-324
§Examples
use float_next_after::NextAfter;
// Large numbers
let big_num = 16237485966.00000437586943_f64;
let next = big_num.next_after(std::f64::INFINITY);
assert_eq!(next, 16237485966.000006_f64);
// Expected handling of 1.0
let one = 1_f64;
let next = one.next_after(std::f64::INFINITY);
assert_eq!(next, 1_f64 + std::f64::EPSILON);
// Tiny (negative) numbers
let zero = 0_f32;
let next = zero.next_after(std::f32::NEG_INFINITY);
assert_eq!(next, -0.000000000000000000000000000000000000000000001_f32);
// Equal source/dest (even -0 == 0)
let zero = 0_f64;
let next = zero.next_after(-0_f64);
assert_eq!(next, -0_f64);§Safety
This trait uses the ToBits and FromBits functions from f32 and f64. Those both use unsafe { mem::transmute(self) } / unsafe { mem::transmute(v) } to convert a f32/f64 to u32/u64. The docs for those functions claim they are safe and that “the safety issues with sNaN were overblown!”
Required Methods§
fn next_after(self, y: Self) -> Self
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.