Trait appro_eq::AbsError

pub trait AbsError<Rhs: ?Sized = Self, Diff = Self> {
    fn abs_error(&self, expected: &Rhs) -> Result<Option<Diff>, ApproEqError>;
}

Required methods

fn abs_error(&self, expected: &Rhs) -> Result<Option<Diff>, ApproEqError>

This method tests for self(actual value) and expected values to be absolute error.

Loading content...

Implementations on Foreign Types

impl<A, D: Float, B: AbsError<A, D>> AbsError<Complex<A>, D> for Complex<B>

fn abs_error(&self, expected: &Complex<A>) -> Result<Option<D>, ApproEqError>

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

fn abs_error(
    &self,
    expected: &Ratio<A>
) -> Result<Option<Ratio<A>>, ApproEqError>

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

fn abs_error(
    &self,
    expected: &ArrayBase<A, D>
) -> Result<Option<B>, ApproEqError>

impl AbsError<f32, f32> for f32

fn abs_error(&self, expected: &f32) -> Result<Option<f32>, ApproEqError>

impl AbsError<f64, f64> for f64

fn abs_error(&self, expected: &f64) -> Result<Option<f64>, ApproEqError>

impl AbsError<f64, f32> for f32

fn abs_error(&self, expected: &f64) -> Result<Option<f32>, ApproEqError>

impl AbsError<f32, f32> for f64

fn abs_error(&self, expected: &f32) -> Result<Option<f32>, ApproEqError>

impl AbsError<i8, i8> for i8

fn abs_error(&self, expected: &i8) -> Result<Option<i8>, ApproEqError>

impl AbsError<i16, i16> for i16

fn abs_error(&self, expected: &i16) -> Result<Option<i16>, ApproEqError>

impl AbsError<i32, i32> for i32

fn abs_error(&self, expected: &i32) -> Result<Option<i32>, ApproEqError>

impl AbsError<i64, i64> for i64

fn abs_error(&self, expected: &i64) -> Result<Option<i64>, ApproEqError>

impl AbsError<i128, i128> for i128

fn abs_error(&self, expected: &i128) -> Result<Option<i128>, ApproEqError>

impl AbsError<u8, u8> for u8

fn abs_error(&self, expected: &u8) -> Result<Option<u8>, ApproEqError>

impl AbsError<u16, u16> for u16

fn abs_error(&self, expected: &u16) -> Result<Option<u16>, ApproEqError>

impl AbsError<u32, u32> for u32

fn abs_error(&self, expected: &u32) -> Result<Option<u32>, ApproEqError>

impl AbsError<u64, u64> for u64

fn abs_error(&self, expected: &u64) -> Result<Option<u64>, ApproEqError>

impl AbsError<u128, u128> for u128

fn abs_error(&self, expected: &u128) -> Result<Option<u128>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A], D> for [B]

fn abs_error(&self, expected: &[A]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<Vec<A>, D> for Vec<B>

fn abs_error(&self, expected: &Vec<A>) -> Result<Option<D>, ApproEqError>

impl<'a, A: ?Sized, D: PartialOrd, B: AbsError<A, D> + ?Sized> AbsError<&'a A, D> for &'a B

fn abs_error(&self, expected: &&A) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 0], D> for [B; 0]

fn abs_error(&self, expected: &[A; 0]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 1], D> for [B; 1]

fn abs_error(&self, expected: &[A; 1]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 2], D> for [B; 2]

fn abs_error(&self, expected: &[A; 2]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 3], D> for [B; 3]

fn abs_error(&self, expected: &[A; 3]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 4], D> for [B; 4]

fn abs_error(&self, expected: &[A; 4]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 5], D> for [B; 5]

fn abs_error(&self, expected: &[A; 5]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 6], D> for [B; 6]

fn abs_error(&self, expected: &[A; 6]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 7], D> for [B; 7]

fn abs_error(&self, expected: &[A; 7]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 8], D> for [B; 8]

fn abs_error(&self, expected: &[A; 8]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 9], D> for [B; 9]

fn abs_error(&self, expected: &[A; 9]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 10], D> for [B; 10]

fn abs_error(&self, expected: &[A; 10]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 11], D> for [B; 11]

fn abs_error(&self, expected: &[A; 11]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 12], D> for [B; 12]

fn abs_error(&self, expected: &[A; 12]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 13], D> for [B; 13]

fn abs_error(&self, expected: &[A; 13]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 14], D> for [B; 14]

fn abs_error(&self, expected: &[A; 14]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 15], D> for [B; 15]

fn abs_error(&self, expected: &[A; 15]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 16], D> for [B; 16]

fn abs_error(&self, expected: &[A; 16]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 17], D> for [B; 17]

fn abs_error(&self, expected: &[A; 17]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 18], D> for [B; 18]

fn abs_error(&self, expected: &[A; 18]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 19], D> for [B; 19]

fn abs_error(&self, expected: &[A; 19]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 20], D> for [B; 20]

fn abs_error(&self, expected: &[A; 20]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 21], D> for [B; 21]

fn abs_error(&self, expected: &[A; 21]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 22], D> for [B; 22]

fn abs_error(&self, expected: &[A; 22]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 23], D> for [B; 23]

fn abs_error(&self, expected: &[A; 23]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 24], D> for [B; 24]

fn abs_error(&self, expected: &[A; 24]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 25], D> for [B; 25]

fn abs_error(&self, expected: &[A; 25]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 26], D> for [B; 26]

fn abs_error(&self, expected: &[A; 26]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 27], D> for [B; 27]

fn abs_error(&self, expected: &[A; 27]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 28], D> for [B; 28]

fn abs_error(&self, expected: &[A; 28]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 29], D> for [B; 29]

fn abs_error(&self, expected: &[A; 29]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 30], D> for [B; 30]

fn abs_error(&self, expected: &[A; 30]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 31], D> for [B; 31]

fn abs_error(&self, expected: &[A; 31]) -> Result<Option<D>, ApproEqError>

impl<A, D: PartialOrd, B: AbsError<A, D>> AbsError<[A; 32], D> for [B; 32]

fn abs_error(&self, expected: &[A; 32]) -> Result<Option<D>, ApproEqError>

impl<A, D, B: AbsError<A, D>> AbsError<Option<A>, D> for Option<B>

fn abs_error(&self, expected: &Option<A>) -> Result<Option<D>, ApproEqError>

impl<A: ?Sized, D: PartialOrd, B: AbsError<A, D> + ?Sized> AbsError<Rc<A>, D> for Rc<B>

fn abs_error(&self, expected: &Rc<A>) -> Result<Option<D>, ApproEqError>

impl<A: ?Sized, D: PartialOrd, B: AbsError<A, D> + ?Sized> AbsError<Arc<A>, D> for Arc<B>

fn abs_error(&self, expected: &Arc<A>) -> Result<Option<D>, ApproEqError>

impl<A: ?Sized, D: PartialOrd, B: AbsError<A, D> + ?Sized> AbsError<Weak<A>, D> for Weak<B>

fn abs_error(&self, expected: &Weak<A>) -> Result<Option<D>, ApproEqError>

impl<A: Copy + ?Sized, D: PartialOrd, B: AbsError<A, D> + Copy + ?Sized> AbsError<Cell<A>, D> for Cell<B>

fn abs_error(&self, expected: &Cell<A>) -> Result<Option<D>, ApproEqError>

impl<A: ?Sized, D: PartialOrd, B: AbsError<A, D> + ?Sized> AbsError<RefCell<A>, D> for RefCell<B>

fn abs_error(&self, expected: &RefCell<A>) -> Result<Option<D>, ApproEqError>

impl AbsError<Instant, Duration> for Instant

fn abs_error(
    &self,
    expected: &Instant
) -> Result<Option<Duration>, ApproEqError>

impl AbsError<SystemTime, Duration> for SystemTime

fn abs_error(
    &self,
    expected: &SystemTime
) -> Result<Option<Duration>, ApproEqError>

impl AbsError<Duration, Duration> for Duration

fn abs_error(
    &self,
    expected: &Duration
) -> Result<Option<Duration>, ApproEqError>

Loading content...

Implementors

Loading content...