Trait Dot 

pub trait Dot<B: ?Sized> {
    type Output;

    // Required method
    fn dot(&self, other: &B) -> Self::Output;
}

Trait that defines a dot product

Required Associated Types

type Output

Required Methods

fn dot(&self, other: &B) -> Self::Output

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T> Dot<[T; 1]> for [T; 1]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 1]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 1]) -> Self::Output

impl<T> Dot<[T; 2]> for [T; 2]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 2]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 2]) -> Self::Output

impl<T> Dot<[T; 3]> for [T; 3]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 3]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 3]) -> Self::Output

impl<T> Dot<[T; 4]> for [T; 4]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 4]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 4]) -> Self::Output

impl<T> Dot<[T; 5]> for [T; 5]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 5]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 5]) -> Self::Output

impl<T> Dot<[T; 6]> for [T; 6]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 6]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 6]) -> Self::Output

impl<T> Dot<[T; 7]> for [T; 7]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 7]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 7]) -> Self::Output

impl<T> Dot<[T; 8]> for [T; 8]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 8]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 8]) -> Self::Output

impl<T> Dot<[T; 9]> for [T; 9]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 9]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 9]) -> Self::Output

impl<T> Dot<[T; 10]> for [T; 10]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 10]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 10]) -> Self::Output

impl<T> Dot<[T; 11]> for [T; 11]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 11]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 11]) -> Self::Output

impl<T> Dot<[T; 12]> for [T; 12]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 12]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 12]) -> Self::Output

impl<T> Dot<[T; 13]> for [T; 13]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 13]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 13]) -> Self::Output

impl<T> Dot<[T; 14]> for [T; 14]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 14]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 14]) -> Self::Output

impl<T> Dot<[T; 15]> for [T; 15]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 15]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 15]) -> Self::Output

impl<T> Dot<[T; 16]> for [T; 16]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 16]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 16]) -> Self::Output

impl<T> Dot<[T; 17]> for [T; 17]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 17]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 17]) -> Self::Output

impl<T> Dot<[T; 18]> for [T; 18]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 18]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 18]) -> Self::Output

impl<T> Dot<[T; 19]> for [T; 19]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 19]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 19]) -> Self::Output

impl<T> Dot<[T; 20]> for [T; 20]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 20]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 20]) -> Self::Output

impl<T> Dot<[T; 21]> for [T; 21]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 21]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 21]) -> Self::Output

impl<T> Dot<[T; 22]> for [T; 22]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 22]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 22]) -> Self::Output

impl<T> Dot<[T; 23]> for [T; 23]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 23]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 23]) -> Self::Output

impl<T> Dot<[T; 24]> for [T; 24]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 24]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 24]) -> Self::Output

impl<T> Dot<[T; 25]> for [T; 25]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 25]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 25]) -> Self::Output

impl<T> Dot<[T; 26]> for [T; 26]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 26]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 26]) -> Self::Output

impl<T> Dot<[T; 27]> for [T; 27]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 27]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 27]) -> Self::Output

impl<T> Dot<[T; 28]> for [T; 28]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 28]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 28]) -> Self::Output

impl<T> Dot<[T; 29]> for [T; 29]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 29]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 29]) -> Self::Output

impl<T> Dot<[T; 30]> for [T; 30]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 30]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 30]) -> Self::Output

impl<T> Dot<[T; 31]> for [T; 31]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 31]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 31]) -> Self::Output

impl<T> Dot<[T; 32]> for [T; 32]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &Self) -> Self::Output

impl<T> Dot<[T; 32]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T; 32]) -> Self::Output

impl<T> Dot<[T]> for Vec<T>

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 1]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 2]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 3]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 4]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 5]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 6]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 7]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 8]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 9]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 10]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 11]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 12]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 13]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 14]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 15]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 16]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 17]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 18]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 19]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 20]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 21]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 22]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 23]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 24]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 25]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 26]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 27]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 28]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 29]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 30]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 31]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T; 32]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

impl<T> Dot<[T]> for [T]

where T: Mul + Clone, T::Output: Sum,

type Output = <T as Mul>::Output

fn dot(&self, other: &[T]) -> Self::Output

Implementors