Trait float_eq::FloatEqDebug

pub trait FloatEqDebug<Rhs: ?Sized = Self>: FloatEq<Rhs> {
    type DebugEpsilon: Debug;
    type DebugUlpsEpsilon: Debug;
    fn debug_abs_epsilon(
        &self, 
        other: &Rhs, 
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon;
    fn debug_rel_epsilon(
        &self, 
        other: &Rhs, 
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon;
    fn debug_ulps_epsilon(
        &self, 
        other: &Rhs, 
        max_diff: &Self::UlpsEpsilon
    ) -> Self::DebugUlpsEpsilon;
}

Debug context for when an assert using FloatEq fails.

This is used internally by the assert_float_eq! family of macros to provide debug context information to the user when abs, rel or ulps checks fail.

How can I implement FloatEqDebug?

You should first implement FloatEq and FloatDiff. Most types will have implemented a custom ULPs type that mirrors their field structure, which can then be used for FloatEqDebug. Implementation is then usually a matter of simply calling through to an underlying FloatEqDebugmethod for each field in turn. If not, you will need to take a close look at the descriptions of the algorithms on a method by method basis:

#[derive(Debug, Clone, Copy, PartialEq)]
struct MyComplex32 {
    re: f32,
    im: f32,
}

#[derive(Debug, Clone, Copy, PartialEq)]
struct MyComplex32Ulps {
    re: <f32 as FloatDiff>::UlpsDiff,
    im: <f32 as FloatDiff>::UlpsDiff,
}

impl FloatEq for MyComplex32 {
    type Epsilon = MyComplex32;
    type UlpsEpsilon = MyComplex32Ulps;

    fn eq_abs(&self, other: &Self, max_diff: &MyComplex32) -> bool {
        self.re.eq_abs(&other.re, &max_diff.re) && self.im.eq_abs(&other.im, &max_diff.im)
    }

    fn eq_rel(&self, other: &Self, max_diff: &MyComplex32) -> bool {
        self.re.eq_rel(&other.re, &max_diff.re) && self.im.eq_rel(&other.im, &max_diff.im)
    }

    fn eq_ulps(&self, other: &Self, max_diff: &MyComplex32Ulps) -> bool {
        self.re.eq_ulps(&other.re, &max_diff.re) && self.im.eq_ulps(&other.im, &max_diff.im)
    }
}

impl FloatEqDebug for MyComplex32 {
    type DebugEpsilon = MyComplex32;
    type DebugUlpsEpsilon = MyComplex32Ulps;

    fn debug_abs_epsilon(
        &self,
        other: &Self,
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon {
        MyComplex32 {
            re: self.re.debug_abs_epsilon(&other.re, &max_diff.re),
            im: self.im.debug_abs_epsilon(&other.im, &max_diff.im),
        }
    }

    fn debug_rel_epsilon(
        &self,
        other: &Self,
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon {
        MyComplex32 {
            re: self.re.debug_rel_epsilon(&other.re, &max_diff.re),
            im: self.im.debug_rel_epsilon(&other.im, &max_diff.im),
        }
    }

    fn debug_ulps_epsilon(
        &self,
        other: &Self,
        max_diff: &Self::UlpsEpsilon,
    ) -> Self::DebugUlpsEpsilon {
        MyComplex32Ulps {
            re: self.re.debug_ulps_epsilon(&other.re, &max_diff.re),
            im: self.im.debug_ulps_epsilon(&other.im, &max_diff.im),
        }
    }
}

let a = MyComplex32 { re: 1.0, im: 200.0 };
let b = MyComplex32 { re: 50.0, im: 1.0 };

assert_eq!(
    a.debug_abs_epsilon(&b, &MyComplex32 { re: 0.1, im: 0.2 }),
    MyComplex32 { re: 0.1, im: 0.2 }
);
assert_eq!(
    a.debug_rel_epsilon(&b, &MyComplex32 { re: 0.1, im: 0.2 }),
    MyComplex32 { re: 5.0, im: 40.0 }
);
assert_eq!(
    a.debug_ulps_epsilon(&b, &MyComplex32Ulps { re: 4, im: 8 }),
    MyComplex32Ulps { re: 4, im: 8 }
);

How can I compare two different types?

The type to be compared with is controlled by FloatEqDebug's parameter. Following on from our previous example, if we wanted to treat f32 as a complex number with an imaginary component of 0.0:

impl FloatEq<f32> for MyComplex32 {
    type Epsilon = MyComplex32;
    type UlpsEpsilon = MyComplex32Ulps;

    fn eq_abs(&self, other: &f32, max_diff: &MyComplex32) -> bool {
        self.re.eq_abs(other, &max_diff.re) && self.im.eq_abs(&0.0, &max_diff.im)
    }

    fn eq_rel(&self, other: &f32, max_diff: &MyComplex32) -> bool {
        self.re.eq_rel(other, &max_diff.re) && self.im.eq_rel(&0.0, &max_diff.im)
    }

    fn eq_ulps(&self, other: &f32, max_diff: &MyComplex32Ulps) -> bool {
        self.re.eq_ulps(other, &max_diff.re) && self.im.eq_ulps(&0.0, &max_diff.im)
    }
}

impl FloatEqDebug<f32> for MyComplex32 {
    type DebugEpsilon = MyComplex32;
    type DebugUlpsEpsilon = MyComplex32Ulps;

    fn debug_abs_epsilon(
        &self,
        other: &f32,
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon {
        MyComplex32 {
            re: self.re.debug_abs_epsilon(other, &max_diff.re),
            im: self.im.debug_abs_epsilon(&0.0, &max_diff.im),
        }
    }

    fn debug_rel_epsilon(
        &self,
        other: &f32,
        max_diff: &Self::Epsilon
    ) -> Self::DebugEpsilon {
        MyComplex32 {
            re: self.re.debug_rel_epsilon(other, &max_diff.re),
            im: self.im.debug_rel_epsilon(&0.0, &max_diff.im),
        }
    }

    fn debug_ulps_epsilon(
        &self,
        other: &f32,
        max_diff: &Self::UlpsEpsilon,
    ) -> Self::DebugUlpsEpsilon {
        MyComplex32Ulps {
            re: self.re.debug_ulps_epsilon(other, &max_diff.re),
            im: self.im.debug_ulps_epsilon(&0.0, &max_diff.im),
        }
    }
}

let a = MyComplex32 { re: 1.0, im: 200.0 };
let b = 9000.0_f32;

assert_eq!(
    a.debug_abs_epsilon(&b, &MyComplex32 { re: 0.1, im: 0.2 }),
    MyComplex32 { re: 0.1, im: 0.2 }
);
assert_eq!(
    a.debug_rel_epsilon(&b, &MyComplex32 { re: 0.1, im: 0.2 }),
    MyComplex32 { re: 900.0, im: 40.0 }
);
assert_eq!(
    a.debug_ulps_epsilon(&b, &MyComplex32Ulps { re: 4, im: 8 }),
    MyComplex32Ulps { re: 4, im: 8 }
);

Associated Types

type DebugEpsilon: Debug

Displayed to the user when an assert fails, using fmt::Debug.

This should match Self::Epsilon.

type DebugUlpsEpsilon: Debug

Displayed to the user when an assert fails, using fmt::Debug.

This should match Self::UlpsEpsilon.

Loading content...

Required methods

fn debug_abs_epsilon(
    &self,
    other: &Rhs,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

The epsilon used by an abs absolute epsilon comparison, displayed when an assert fails.

fn debug_rel_epsilon(
    &self,
    other: &Rhs,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

The epsilon used by a rel relative epsilon comparison, displayed when an assert fails.

This should take into account the fact that the epsilon values are scaled based on the size of their inputs.

fn debug_ulps_epsilon(
    &self,
    other: &Rhs,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

The epsilon used by an ulps ULPs comparison, displayed when an assert fails.

Loading content...

Implementations on Foreign Types

impl<T: FloatEqDebug> FloatEqDebug<[T; 0]> for [T; 0]

type DebugEpsilon = [T::DebugEpsilon; 0]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 0]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 1]> for [T; 1]

type DebugEpsilon = [T::DebugEpsilon; 1]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 1]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 2]> for [T; 2]

type DebugEpsilon = [T::DebugEpsilon; 2]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 2]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 3]> for [T; 3]

type DebugEpsilon = [T::DebugEpsilon; 3]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 3]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 4]> for [T; 4]

type DebugEpsilon = [T::DebugEpsilon; 4]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 4]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 5]> for [T; 5]

type DebugEpsilon = [T::DebugEpsilon; 5]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 5]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 6]> for [T; 6]

type DebugEpsilon = [T::DebugEpsilon; 6]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 6]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 7]> for [T; 7]

type DebugEpsilon = [T::DebugEpsilon; 7]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 7]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 8]> for [T; 8]

type DebugEpsilon = [T::DebugEpsilon; 8]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 8]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 9]> for [T; 9]

type DebugEpsilon = [T::DebugEpsilon; 9]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 9]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 10]> for [T; 10]

type DebugEpsilon = [T::DebugEpsilon; 10]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 10]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 11]> for [T; 11]

type DebugEpsilon = [T::DebugEpsilon; 11]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 11]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 12]> for [T; 12]

type DebugEpsilon = [T::DebugEpsilon; 12]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 12]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 13]> for [T; 13]

type DebugEpsilon = [T::DebugEpsilon; 13]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 13]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 14]> for [T; 14]

type DebugEpsilon = [T::DebugEpsilon; 14]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 14]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 15]> for [T; 15]

type DebugEpsilon = [T::DebugEpsilon; 15]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 15]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 16]> for [T; 16]

type DebugEpsilon = [T::DebugEpsilon; 16]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 16]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 17]> for [T; 17]

type DebugEpsilon = [T::DebugEpsilon; 17]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 17]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 18]> for [T; 18]

type DebugEpsilon = [T::DebugEpsilon; 18]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 18]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 19]> for [T; 19]

type DebugEpsilon = [T::DebugEpsilon; 19]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 19]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 20]> for [T; 20]

type DebugEpsilon = [T::DebugEpsilon; 20]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 20]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 21]> for [T; 21]

type DebugEpsilon = [T::DebugEpsilon; 21]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 21]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 22]> for [T; 22]

type DebugEpsilon = [T::DebugEpsilon; 22]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 22]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 23]> for [T; 23]

type DebugEpsilon = [T::DebugEpsilon; 23]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 23]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 24]> for [T; 24]

type DebugEpsilon = [T::DebugEpsilon; 24]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 24]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 25]> for [T; 25]

type DebugEpsilon = [T::DebugEpsilon; 25]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 25]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 26]> for [T; 26]

type DebugEpsilon = [T::DebugEpsilon; 26]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 26]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 27]> for [T; 27]

type DebugEpsilon = [T::DebugEpsilon; 27]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 27]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 28]> for [T; 28]

type DebugEpsilon = [T::DebugEpsilon; 28]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 28]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 29]> for [T; 29]

type DebugEpsilon = [T::DebugEpsilon; 29]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 29]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 30]> for [T; 30]

type DebugEpsilon = [T::DebugEpsilon; 30]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 30]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 31]> for [T; 31]

type DebugEpsilon = [T::DebugEpsilon; 31]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 31]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T: FloatEqDebug> FloatEqDebug<[T; 32]> for [T; 32]

type DebugEpsilon = [T::DebugEpsilon; 32]

type DebugUlpsEpsilon = [T::DebugUlpsEpsilon; 32]

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl FloatEqDebug<f32> for f32

type DebugEpsilon = Self::Epsilon

type DebugUlpsEpsilon = Self::UlpsEpsilon

fn debug_abs_epsilon(
    &self,
    _other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    _other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl FloatEqDebug<f64> for f64

type DebugEpsilon = Self::Epsilon

type DebugUlpsEpsilon = Self::UlpsEpsilon

fn debug_abs_epsilon(
    &self,
    _other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    _other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl FloatEqDebug<()> for ()

type DebugEpsilon = ()

type DebugUlpsEpsilon = ()

fn debug_abs_epsilon(
    &self,
    _other: &(),
    _max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    _other: &(),
    _max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    _other: &(),
    _max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A> FloatEqDebug<(A,)> for (A,) where
    A: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon,)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon,)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B> FloatEqDebug<(A, B)> for (A, B) where
    B: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C> FloatEqDebug<(A, B, C)> for (A, B, C) where
    C: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D> FloatEqDebug<(A, B, C, D)> for (A, B, C, D) where
    D: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E> FloatEqDebug<(A, B, C, D, E)> for (A, B, C, D, E) where
    E: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F> FloatEqDebug<(A, B, C, D, E, F)> for (A, B, C, D, E, F) where
    F: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G> FloatEqDebug<(A, B, C, D, E, F, G)> for (A, B, C, D, E, F, G) where
    G: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G: FloatEqDebug + Debug, H> FloatEqDebug<(A, B, C, D, E, F, G, H)> for (A, B, C, D, E, F, G, H) where
    H: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon, H::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon, H::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G: FloatEqDebug + Debug, H: FloatEqDebug + Debug, I> FloatEqDebug<(A, B, C, D, E, F, G, H, I)> for (A, B, C, D, E, F, G, H, I) where
    I: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon, H::DebugEpsilon, I::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon, H::DebugUlpsEpsilon, I::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G: FloatEqDebug + Debug, H: FloatEqDebug + Debug, I: FloatEqDebug + Debug, J> FloatEqDebug<(A, B, C, D, E, F, G, H, I, J)> for (A, B, C, D, E, F, G, H, I, J) where
    J: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon, H::DebugEpsilon, I::DebugEpsilon, J::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon, H::DebugUlpsEpsilon, I::DebugUlpsEpsilon, J::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G: FloatEqDebug + Debug, H: FloatEqDebug + Debug, I: FloatEqDebug + Debug, J: FloatEqDebug + Debug, K> FloatEqDebug<(A, B, C, D, E, F, G, H, I, J, K)> for (A, B, C, D, E, F, G, H, I, J, K) where
    K: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon, H::DebugEpsilon, I::DebugEpsilon, J::DebugEpsilon, K::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon, H::DebugUlpsEpsilon, I::DebugUlpsEpsilon, J::DebugUlpsEpsilon, K::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<A: FloatEqDebug + Debug, B: FloatEqDebug + Debug, C: FloatEqDebug + Debug, D: FloatEqDebug + Debug, E: FloatEqDebug + Debug, F: FloatEqDebug + Debug, G: FloatEqDebug + Debug, H: FloatEqDebug + Debug, I: FloatEqDebug + Debug, J: FloatEqDebug + Debug, K: FloatEqDebug + Debug, L> FloatEqDebug<(A, B, C, D, E, F, G, H, I, J, K, L)> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    L: FloatEqDebug + Debug + ?Sized, 

type DebugEpsilon = (A::DebugEpsilon, B::DebugEpsilon, C::DebugEpsilon, D::DebugEpsilon, E::DebugEpsilon, F::DebugEpsilon, G::DebugEpsilon, H::DebugEpsilon, I::DebugEpsilon, J::DebugEpsilon, K::DebugEpsilon, L::DebugEpsilon)

type DebugUlpsEpsilon = (A::DebugUlpsEpsilon, B::DebugUlpsEpsilon, C::DebugUlpsEpsilon, D::DebugUlpsEpsilon, E::DebugUlpsEpsilon, F::DebugUlpsEpsilon, G::DebugUlpsEpsilon, H::DebugUlpsEpsilon, I::DebugUlpsEpsilon, J::DebugUlpsEpsilon, K::DebugUlpsEpsilon, L::DebugUlpsEpsilon)

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

impl<T> FloatEqDebug<Complex<T>> for Complex<T> where
    T: FloatEqDebug, 

type DebugEpsilon = Complex<T::DebugEpsilon>

type DebugUlpsEpsilon = ComplexUlps<T::DebugUlpsEpsilon>

fn debug_abs_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_rel_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::Epsilon
) -> Self::DebugEpsilon

fn debug_ulps_epsilon(
    &self,
    other: &Self,
    max_diff: &Self::UlpsEpsilon
) -> Self::DebugUlpsEpsilon

Loading content...

Implementors

Loading content...