Struct Exactly 

pub struct Exactly;

Exact comparison, as a tolerance of 0 gives, through plain IEEE comparisons and floor.

Trait Implementations

impl Clone for Exactly

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Exactly

impl Debug for Exactly

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Tolerant for Exactly

fn value(self) -> f64

The tolerance: 0 for Exactly.

fn close<F: Float>(self, _: F, _: F) -> bool

Whether x and y lie within the tolerance of each other: |x-y| is less than the tolerance times the larger of |x| and |y|. NaN and the infinities are close to nothing. less and less_equal read it without equal’s x == y, because x < y already implies x != y, and x <= y already holds where x == y.

fn floor_in<F: Float, O: Ops<F> + ?Sized>(self, o: &O, y: O::V) -> O::V

floor through o: the formula that the Floor, Ceil and Residue objects give compiled code (Facts::formula).

fn equal<F: Float>(self, x: F, y: F) -> bool

Whether x equals y: it is y, or close to it. NaN equals nothing, as in IEEE, and an infinity equals only itself.

fn floor<F: Float>(self, y: F) -> F

The floor of y: the whole number nearest to y, unless it lies above y and doesn’t equal it. Then the whole number below. A floor or ceiling that is zero is 0, never -0, as BPL’s numbers give it.

fn ceil<F: Float>(self, y: F) -> F

The ceiling of y: the whole number nearest to y, unless it lies below y and doesn’t equal it. Then the whole number above.

fn ceil_in<F: Float, O: Ops<F> + ?Sized>(self, o: &O, y: O::V) -> O::V

ceil through o.

fn matches<F: Float>(self, x: F, y: F) -> bool

Whether x and y match: they are equal, or both are NaN. A search that must find NaN compares with matches.

fn less<F: Float>(self, x: F, y: F) -> bool

Whether x is below y and doesn’t equal it. Comparisons with NaN are false.

fn less_equal<F: Float>(self, x: F, y: F) -> bool

Whether x is below y or equals it. Comparisons with NaN are false.

fn greater<F: Float>(self, x: F, y: F) -> bool

Whether x is above y and doesn’t equal it. Comparisons with NaN are false.

fn greater_equal<F: Float>(self, x: F, y: F) -> bool

Whether x is above y or equals it. Comparisons with NaN are false.

fn compare<F: Float>(self, x: F, y: F) -> Option<Ordering>

The order of x and y, which is Equal when they are equal. None when either is NaN.

fn residue<F: Float>(self, x: F, y: F) -> F

y modulo x, through recipe::residue: y - x·floor(y/x) from this tolerance’s floor of the quotient, rounded once where the target fuses multiply-add. At nonzero tolerance, a product equal to y within tolerance leaves no remainder. x = 0 gives y.

fn residue_in<F: Float, O: Ops<F> + ?Sized>( self, o: &O, x: O::V, y: O::V, ) -> O::V

residue through o.

fn nearest_whole<F: Float>(self, y: F) -> (F, bool)

The whole number nearest y, and whether y equals it within this tolerance.

fn nearest_whole_in<F: Float, O: Ops<F> + ?Sized>( self, o: &O, y: O::V, ) -> (O::V, O::B)

fn whole<F: Float>(self, y: F) -> Option<F>

The whole number equal to y, when there is one.

fn range<F: Float>(self, c: F) -> Option<(F, F)>

The floats equal to c, as (lo, hi): equal(x, c) holds exactly when lo <= x && x <= hi. Comparing many floats with c then takes two plain comparisons for each, in a loop that vectorizes. None when c is NaN, which equals nothing.

fn gcd<F: Float>(self, x: F, y: F) -> F

The greatest common divisor of x and y: the larger magnitude divided by the numerator of the first convergent of the ratio of the magnitudes that equals the ratio. It computes in f64 and rounds. NaN when either argument is NaN or infinite. Whole magnitudes whose product is below 1e14 take integer gcd, which gives the same result at any tolerance up to the default.