Struct Tolerance 

pub struct Tolerance(/* private fields */);

A relative tolerance, from 0 up to but not including 1. A tolerance of 0 compares exactly, as Exactly does, but with more work.

Implementations

impl Tolerance

pub const EXACT: Self

Exact comparison.

pub const DEFAULT: Self

Dyalog APL’s default comparison tolerance, 1e-14. It is about 45 units in the last place of an f64.

pub fn new(t: f64) -> Option<Self>

The tolerance t, when it lies from 0 up to but not including 1. None for any other t, including NaN.

pub fn is_exact(self) -> bool

Whether this tolerance is 0.

pub const fn value(self) -> f64

The tolerance, as a relative difference.

Trait Implementations

impl Clone for Tolerance

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 Tolerance

impl Debug for Tolerance

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

Formats the value using the given formatter.

impl PartialEq for Tolerance

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Tolerance

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Tolerance

impl Tolerant for Tolerance

fn value(self) -> f64

The tolerance: 0 for Exactly.

fn close<F: Float>(self, x: F, y: 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.