Trait Dot 

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

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

Matrix Multiplication

For two-dimensional arrays, the dot method computes the matrix multiplication.

Required Associated Types

type Output

The result of the operation.

For two-dimensional arrays: a rectangular array.

Required Methods

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

Compute the dot product of two arrays.

Panics if the arrays’ shapes are not compatible.

Implementors

impl<A> Dot<ArrayRef<A, Dim<IxDynImpl>>> for ArrayRef<A, IxDyn>

where A: LinalgScalar,

Dot product for dynamic-dimensional arrays (ArrayD).

For one-dimensional arrays, computes the vector dot product, which is the sum of the elementwise products (no conjugation of complex operands). Both arrays must have the same length.

For two-dimensional arrays, performs matrix multiplication. The array shapes must be compatible in the following ways:

• If self is M × N, then rhs must be N × K for matrix-matrix multiplication
• If self is M × N and rhs is N, returns a vector of length M
• If self is M and rhs is M × N, returns a vector of length N
• If both arrays are one-dimensional of length N, returns a scalar

Panics if:

• The arrays have dimensions other than 1 or 2
• The array shapes are incompatible for the operation
• For vector dot product: the vectors have different lengths

type Output = ArrayBase<OwnedRepr<A>, Dim<IxDynImpl>>

impl<A> Dot<ArrayRef<A, Dim<[usize; 1]>>> for ArrayRef<A, Ix1>

where A: LinalgScalar,

type Output = A

impl<A> Dot<ArrayRef<A, Dim<[usize; 1]>>> for ArrayRef<A, Ix2>

where A: LinalgScalar,

Perform the matrix multiplication of the rectangular array self and column vector rhs.

The array shapes must agree in the way that if self is M × N, then rhs is N.

Return a result array with shape M.

Panics if shapes are incompatible.

type Output = ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>

impl<A> Dot<ArrayRef<A, Dim<[usize; 2]>>> for ArrayRef<A, Ix1>

where A: LinalgScalar,

type Output = ArrayBase<OwnedRepr<A>, Dim<[usize; 1]>>

impl<A> Dot<ArrayRef<A, Dim<[usize; 2]>>> for ArrayRef<A, Ix2>

where A: LinalgScalar,

type Output = ArrayBase<OwnedRepr<A>, Dim<[usize; 2]>>

impl<A, S> Dot<ArrayBase<S, Dim<[usize; 1]>>> for ArrayRef<A, Ix1>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S> Dot<ArrayBase<S, Dim<[usize; 1]>>> for ArrayRef<A, Ix2>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S> Dot<ArrayBase<S, Dim<[usize; 2]>>> for ArrayRef<A, Ix1>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output

impl<A, S> Dot<ArrayBase<S, Dim<[usize; 2]>>> for ArrayRef<A, Ix2>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output

impl<A, S> Dot<ArrayRef<A, Dim<[usize; 1]>>> for ArrayBase<S, Ix1>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S> Dot<ArrayRef<A, Dim<[usize; 1]>>> for ArrayBase<S, Ix2>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S> Dot<ArrayRef<A, Dim<[usize; 2]>>> for ArrayBase<S, Ix1>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output

impl<A, S> Dot<ArrayRef<A, Dim<[usize; 2]>>> for ArrayBase<S, Ix2>

where S: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output

impl<A, S, S2> Dot<ArrayBase<S2, Dim<[usize; 1]>>> for ArrayBase<S, Ix1>

where S: Data<Elem = A>, S2: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S, S2> Dot<ArrayBase<S2, Dim<[usize; 1]>>> for ArrayBase<S, Ix2>

where S: Data<Elem = A>, S2: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 1]>>>>::Output

impl<A, S, S2> Dot<ArrayBase<S2, Dim<[usize; 2]>>> for ArrayBase<S, Ix1>

where S: Data<Elem = A>, S2: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 1]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output

impl<A, S, S2> Dot<ArrayBase<S2, Dim<[usize; 2]>>> for ArrayBase<S, Ix2>

where S: Data<Elem = A>, S2: Data<Elem = A>, A: LinalgScalar,

type Output = <ArrayRef<A, Dim<[usize; 2]>> as Dot<ArrayRef<A, Dim<[usize; 2]>>>>::Output