Trait appro_eq::RelError

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

Required methods

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

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

Loading content...

Implementations on Foreign Types

impl<A: Float, D: Float + Div<A, Output = D>, B: Sub<A, Output = D> + Copy> RelError<Complex<A>, D> for Complex<B>

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

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

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

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

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

impl RelError<f32, f32> for f32

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

impl RelError<f64, f64> for f64

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

impl RelError<f64, f32> for f32

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

impl RelError<f32, f32> for f64

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

impl RelError<i8, i8> for i8

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

impl RelError<i16, i16> for i16

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

impl RelError<i32, i32> for i32

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

impl RelError<i64, i64> for i64

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

impl RelError<i128, i128> for i128

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

impl RelError<u8, u8> for u8

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

impl RelError<u16, u16> for u16

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

impl RelError<u32, u32> for u32

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

impl RelError<u64, u64> for u64

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

impl RelError<u128, u128> for u128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl RelError<Duration, Duration> for Duration

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

Loading content...

Implementors

Loading content...