AbsDiff in approx - Rust
Description: The requisite parameters for testing for approximate equality using a absolute difference based comparison.
Keywords: rust, rustlang, rust-lang, AbsDiff

# Struct approx::AbsDiff

source ·

    pub struct AbsDiff<A, B = A>where
        A: AbsDiffEq<B> + ?Sized,
        B: ?Sized,{
        pub epsilon: A::Epsilon,
    }

Expand description

The requisite parameters for testing for approximate equality using a absolute difference based comparison.

This is not normally used directly, rather via the `assert_abs_diff_{eq|ne}!` and `abs_diff_{eq|ne}!` macros.

## Example

    use std::f64;
    use approx::AbsDiff;

    AbsDiff::default().eq(&1.0, &1.0);
    AbsDiff::default().epsilon(f64::EPSILON).eq(&1.0, &1.0);

## Fields§

§`epsilon: A::Epsilon`

The tolerance to use when testing values that are close together.

## Implementations§

source§

### impl<A, B> AbsDiff<A, B>where
A: AbsDiffEq<B> + ?Sized,
B: ?Sized,

source

#### pub fn epsilon(self, epsilon: A::Epsilon) -> AbsDiff<A, B>

Replace the epsilon value with the one specified.

source

#### pub fn eq(self, lhs: &A, rhs: &B) -> bool

Peform the equality comparison

source

#### pub fn ne(self, lhs: &A, rhs: &B) -> bool

Peform the inequality comparison

## Trait Implementations§

source§

### impl<A, B> Default for AbsDiff<A, B>where
A: AbsDiffEq<B> + ?Sized,
B: ?Sized,

source§

#### fn default() -> AbsDiff<A, B>

Returns the “default value” for a type. Read more

## Auto Trait Implementations§

§

### impl<A: ?Sized, B: ?Sized> RefUnwindSafe for AbsDiff<A, B>where
<A as AbsDiffEq<B>>::Epsilon: RefUnwindSafe,

§

### impl<A: ?Sized, B: ?Sized> Send for AbsDiff<A, B>where
<A as AbsDiffEq<B>>::Epsilon: Send,

§

### impl<A: ?Sized, B: ?Sized> Sync for AbsDiff<A, B>where
<A as AbsDiffEq<B>>::Epsilon: Sync,

§

### impl<A: ?Sized, B: ?Sized> Unpin for AbsDiff<A, B>where
<A as AbsDiffEq<B>>::Epsilon: Unpin,

§

### impl<A: ?Sized, B: ?Sized> UnwindSafe for AbsDiff<A, B>where
<A as AbsDiffEq<B>>::Epsilon: UnwindSafe,

## Blanket Implementations§

source§

### impl<T> Any for Twhere
T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

const: unstable · source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.