Trait Distance 

pub trait Distance<D> {
    type Output: Num;

    // Required method
    fn distance(&self, other: &Self, desc: D) -> Self::Output;
}

The abstract notion of the distance between two values.

This can be used to calculate the distance between two arbitrary values without storing their difference as an intermediate result.

Required Associated Types

type Output: Num

The resulting type of the distance function.

Mathematically, a distance metric is a mapping from 2-tuples of vectors of a vector space V into the non-negative real numbers, so Output will usually be a floating point type or in some cases an unsigned integer type.

Required Methods

fn distance(&self, other: &Self, desc: D) -> Self::Output

Calculates the distance between self and other.

Panics

An implementation of distance may panic if the operands do not fit together, e.g. have different sizes etc.

Example

use num_complex::Complex;

use norman::Distance;
use norman::desc::Abs;

assert_eq!(Complex::new(2.0, 5.0).distance(&Complex::new(-1.0, 1.0), Abs::new()), 5.0);

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Distance<Abs> for f32

type Output = f32

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for f64

type Output = f64

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for i8

type Output = u8

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for i16

type Output = u16

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for i32

type Output = u32

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for i64

type Output = u64

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for i128

type Output = u128

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for isize

type Output = usize

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for u8

type Output = u8

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for u16

type Output = u16

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for u32

type Output = u32

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for u64

type Output = u64

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for u128

type Output = u128

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl Distance<Abs> for usize

type Output = usize

fn distance(&self, other: &Self, _desc: Abs) -> <Self as Distance<Abs>>::Output

impl<F: Float, C: FloatChecker<F>> Distance<Abs> for NoisyFloat<F, C>

type Output = NoisyFloat<F, C>

fn distance(&self, other: &Self, _desc: Abs) -> Self

impl<S, D, T, R> Distance<PNorm> for ArrayBase<S, D>

where S: Data<Elem = T>, D: Dimension, T: Distance<Abs, Output = R>, R: Float + From<f32>,

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, desc: PNorm) -> <Self as Distance<Sup>>::Output

impl<S, D, T, R> Distance<PNormReal> for ArrayBase<S, D>

where S: Data<Elem = T>, D: Dimension, T: Distance<Abs, Output = R> + Debug, R: Float + From<f32>,

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<Sup>>::Output

impl<S, D, T, R> Distance<Sup> for ArrayBase<S, D>

where S: Data<Elem = T>, D: Dimension, T: Distance<Abs, Output = R>, R: Num + PartialOrd,

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Float> Distance<Abs> for Complex<T>

fn distance(&self, other: &Self, _desc: Abs) -> T

Calculates the usual euclidean norm of the complex number.

type Output = T

impl<T: Float> Distance<Sup> for Complex<T>

fn distance(&self, other: &Self, _desc: Sup) -> T

Calculates the supremum norm of the complex number, i.e. the maximum of the absolute values of real and imaginary part.

type Output = T

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 0]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 1]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 2]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 3]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 4]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 5]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 6]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 7]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 8]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 9]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 10]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 11]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 12]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 13]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 14]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 15]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 16]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 17]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 18]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 19]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 20]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 21]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 22]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 23]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 24]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 25]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 26]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 27]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 28]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 29]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 30]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 31]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for [T; 32]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for VecDeque<T>

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNorm> for Vec<T>

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNorm, ) -> <Self as Distance<PNorm>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 0]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 1]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 2]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 3]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 4]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 5]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 6]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 7]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 8]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 9]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 10]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 11]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 12]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 13]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 14]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 15]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 16]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 17]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 18]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 19]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 20]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 21]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 22]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 23]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 24]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 25]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 26]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 27]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 28]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 29]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 30]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 31]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for [T; 32]

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for VecDeque<T>

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Float + From<f32>> Distance<PNormReal> for Vec<T>

type Output = <T as Distance<Abs>>::Output

fn distance( &self, other: &Self, desc: PNormReal, ) -> <Self as Distance<PNormReal>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 0]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 1]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 2]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 3]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 4]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 5]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 6]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 7]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 8]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 9]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 10]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 11]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 12]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 13]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 14]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 15]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 16]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 17]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 18]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 19]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 20]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 21]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 22]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 23]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 24]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 25]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 26]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 27]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 28]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 29]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 30]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 31]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for [T; 32]

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for VecDeque<T>

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

impl<T: Distance<Abs, Output = R>, R: Num + PartialOrd> Distance<Sup> for Vec<T>

type Output = <T as Distance<Abs>>::Output

fn distance(&self, other: &Self, _desc: Sup) -> <Self as Distance<Sup>>::Output

Implementors