Trait nearly_eq::NearlyEq

pub trait NearlyEq<Rhs: ?Sized = Self, Diff: ?Sized = Self> {
    fn eps() -> Diff;
    fn eq(&self, other: &Rhs, eps: &Diff) -> bool;

    fn ne(&self, other: &Rhs, eps: &Diff) -> bool { ... }
}

Trait for nearly(approximately) equality comparisons.

Required Methods

fn eps() -> Diff

fn eq(&self, other: &Rhs, eps: &Diff) -> bool

This method tests for self and other values to be nearly(approximately) equal.

Provided Methods

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

This method tests for not nearly(approximately) equal.

Implementations on Foreign Types

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Complex<A>, B> for Complex<C>

fn eps() -> B

fn eq(&self, other: &Complex<A>, eps: &B) -> bool

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

impl<A: Integer + Clone> NearlyEq<Ratio<A>, Ratio<A>> for Ratio<A>

fn eps() -> Ratio<A>

fn eq(&self, other: &Ratio<A>, eps: &Ratio<A>) -> bool

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

impl<A: Data, B, C: Data, D: Dimension> NearlyEq<ArrayBase<A, D>, B> for ArrayBase<C, D> where
    C::Elem: NearlyEq<A::Elem, B> + Sized, 

fn eps() -> B

fn eq(&self, other: &ArrayBase<A, D>, eps: &B) -> bool

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

impl<FRAC> NearlyEq<Q<i8, FRAC>, Q<i8, FRAC>> for Q<i8, FRAC> where
    FRAC: Cmp<U0, Output = Greater> + Cmp<U8, Output = Less> + Unsigned,
    Self: PartialOrd + Clone + Sub<Self, Output = Self>, 

fn eps() -> Self

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

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

impl<FRAC> NearlyEq<Q<i16, FRAC>, Q<i16, FRAC>> for Q<i16, FRAC> where
    FRAC: Cmp<U0, Output = Greater> + Cmp<U16, Output = Less> + Unsigned,
    Self: PartialOrd + Clone + Sub<Self, Output = Self>, 

fn eps() -> Self

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

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

impl<FRAC> NearlyEq<Q<i32, FRAC>, Q<i32, FRAC>> for Q<i32, FRAC> where
    FRAC: Cmp<U0, Output = Greater> + Cmp<U32, Output = Less> + Unsigned,
    Self: PartialOrd + Clone + Sub<Self, Output = Self>, 

fn eps() -> Self

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

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

impl NearlyEq for f32

fn eps() -> f32

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

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

impl NearlyEq for f64

fn eps() -> f64

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

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

impl NearlyEq for i8

fn eps() -> i8

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

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

impl NearlyEq for i16

fn eps() -> i16

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

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

impl NearlyEq for i32

fn eps() -> i32

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

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

impl NearlyEq for i64

fn eps() -> i64

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

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

impl NearlyEq for i128

fn eps() -> i128

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

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

impl NearlyEq for u8

fn eps() -> u8

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

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

impl NearlyEq for u16

fn eps() -> u16

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

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

impl NearlyEq for u32

fn eps() -> u32

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

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

impl NearlyEq for u64

fn eps() -> u64

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

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

impl NearlyEq for u128

fn eps() -> u128

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

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A], B> for [C]

fn eps() -> B

fn eq(&self, other: &[A], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Vec<A>, B> for Vec<C>

fn eps() -> B

fn eq(&self, other: &Vec<A>, eps: &B) -> bool

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

impl<'a, A: ?Sized, B, C: NearlyEq<A, B> + ?Sized> NearlyEq<A, B> for &'a C

fn eps() -> B

fn eq(&self, other: &A, eps: &B) -> bool

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

impl<'a, A: ?Sized, B, C: NearlyEq<A, B> + ?Sized> NearlyEq<A, B> for &'a mut C

fn eps() -> B

fn eq(&self, other: &A, eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 0], B> for [C; 0]

fn eps() -> B

fn eq(&self, other: &[A; 0], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 1], B> for [C; 1]

fn eps() -> B

fn eq(&self, other: &[A; 1], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 2], B> for [C; 2]

fn eps() -> B

fn eq(&self, other: &[A; 2], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 3], B> for [C; 3]

fn eps() -> B

fn eq(&self, other: &[A; 3], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 4], B> for [C; 4]

fn eps() -> B

fn eq(&self, other: &[A; 4], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 5], B> for [C; 5]

fn eps() -> B

fn eq(&self, other: &[A; 5], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 6], B> for [C; 6]

fn eps() -> B

fn eq(&self, other: &[A; 6], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 7], B> for [C; 7]

fn eps() -> B

fn eq(&self, other: &[A; 7], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 8], B> for [C; 8]

fn eps() -> B

fn eq(&self, other: &[A; 8], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 9], B> for [C; 9]

fn eps() -> B

fn eq(&self, other: &[A; 9], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 10], B> for [C; 10]

fn eps() -> B

fn eq(&self, other: &[A; 10], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 11], B> for [C; 11]

fn eps() -> B

fn eq(&self, other: &[A; 11], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 12], B> for [C; 12]

fn eps() -> B

fn eq(&self, other: &[A; 12], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 13], B> for [C; 13]

fn eps() -> B

fn eq(&self, other: &[A; 13], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 14], B> for [C; 14]

fn eps() -> B

fn eq(&self, other: &[A; 14], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 15], B> for [C; 15]

fn eps() -> B

fn eq(&self, other: &[A; 15], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 16], B> for [C; 16]

fn eps() -> B

fn eq(&self, other: &[A; 16], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 17], B> for [C; 17]

fn eps() -> B

fn eq(&self, other: &[A; 17], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 18], B> for [C; 18]

fn eps() -> B

fn eq(&self, other: &[A; 18], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 19], B> for [C; 19]

fn eps() -> B

fn eq(&self, other: &[A; 19], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 20], B> for [C; 20]

fn eps() -> B

fn eq(&self, other: &[A; 20], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 21], B> for [C; 21]

fn eps() -> B

fn eq(&self, other: &[A; 21], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 22], B> for [C; 22]

fn eps() -> B

fn eq(&self, other: &[A; 22], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 23], B> for [C; 23]

fn eps() -> B

fn eq(&self, other: &[A; 23], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 24], B> for [C; 24]

fn eps() -> B

fn eq(&self, other: &[A; 24], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 25], B> for [C; 25]

fn eps() -> B

fn eq(&self, other: &[A; 25], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 26], B> for [C; 26]

fn eps() -> B

fn eq(&self, other: &[A; 26], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 27], B> for [C; 27]

fn eps() -> B

fn eq(&self, other: &[A; 27], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 28], B> for [C; 28]

fn eps() -> B

fn eq(&self, other: &[A; 28], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 29], B> for [C; 29]

fn eps() -> B

fn eq(&self, other: &[A; 29], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 30], B> for [C; 30]

fn eps() -> B

fn eq(&self, other: &[A; 30], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 31], B> for [C; 31]

fn eps() -> B

fn eq(&self, other: &[A; 31], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<[A; 32], B> for [C; 32]

fn eps() -> B

fn eq(&self, other: &[A; 32], eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Option<A>, B> for Option<C>

fn eps() -> B

fn eq(&self, other: &Option<A>, eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Rc<A>, B> for Rc<C>

fn eps() -> B

fn eq(&self, other: &Rc<A>, eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Arc<A>, B> for Arc<C>

fn eps() -> B

fn eq(&self, other: &Arc<A>, eps: &B) -> bool

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

impl<A, B, C: NearlyEq<A, B>> NearlyEq<Weak<A>, B> for Weak<C>

fn eps() -> B

fn eq(&self, other: &Weak<A>, eps: &B) -> bool

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

impl<A: Copy + ?Sized, B, C: NearlyEq<A, B> + Copy + ?Sized> NearlyEq<Cell<A>, B> for Cell<C>

fn eps() -> B

fn eq(&self, other: &Cell<A>, eps: &B) -> bool

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

impl<A: ?Sized, B, C: NearlyEq<A, B> + ?Sized> NearlyEq<RefCell<A>, B> for RefCell<C>

fn eps() -> B

fn eq(&self, other: &RefCell<A>, eps: &B) -> bool

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

Implementors