Struct vox_geometry_rust::matrix_expression::MatrixVectorMul

pub struct MatrixVectorMul<ME: MatrixExpression, VE: VectorExpression> { /* fields omitted */ }

Vector expression for matrix-vector multiplication.

This vector expression represents a matrix-vector operation that takes one input matrix expression and one vector expression.

• tparam T Element value type.
• tparam ME Matrix expression.
• tparam VE Vector expression.

Implementations

impl<ME: MatrixExpression, VE: VectorExpression> MatrixVectorMul<ME, VE>

pub fn new(m: ME, v: VE) -> MatrixVectorMul<ME, VE>

pub fn eval(&self, i: usize) -> f64

Returns vector element at i.

pub fn size(&self) -> usize

Size of the vector.

Trait Implementations

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarAdd<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarSub<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarRSub<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarMul<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarDiv<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorScalarRDiv<E1>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorAdd<E1, E2>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorSub<E1, E2>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorMul<E1, E2>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixAdd<MatrixVectorMul<E, VectorDiv<E1, E2>>, Return>

The resulting type after applying the + operator.

fn add(self, rhs: Return) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarAdd<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarSub<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarRSub<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarMul<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarDiv<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorScalarRDiv<E1>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorAdd<E1, E2>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorSub<E1, E2>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorMul<E1, E2>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Add<f64> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixScalarAdd<MatrixVectorMul<E, VectorDiv<E1, E2>>>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Performs the + operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarAdd<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarSub<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarRSub<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarMul<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarDiv<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorScalarRDiv<E1>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorAdd<E1, E2>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorSub<E1, E2>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorMul<E1, E2>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Div<f64> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixScalarDiv<MatrixVectorMul<E, VectorDiv<E1, E2>>>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Performs the / operation.

impl<ME: MatrixExpression, VE: VectorExpression> MatrixExpression for MatrixVectorMul<ME, VE>

fn size(&self) -> USize2

Size of the matrix.

fn rows(&self) -> usize

Number of rows.

fn cols(&self) -> usize

Number of columns.

fn eval(&self, _x: usize, _y: usize) -> f64

Returns matrix element at (i, j).

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarAdd<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarSub<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarRSub<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarMul<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarDiv<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarRDiv<E1>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixMul<MatrixVectorMul<E, VectorAdd<E1, E2>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixMul<MatrixVectorMul<E, VectorSub<E1, E2>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixMul<MatrixVectorMul<E, VectorMul<E1, E2>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<Matrix: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixMul<MatrixVectorMul<E, VectorDiv<E1, E2>>, Matrix>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorDiv<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorDiv<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Minus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorSub<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorSub<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Multiplies>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorMul<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorMul<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E2: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Plus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorAdd<E1, E2>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorAdd<E1, E2>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Minus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Multiplies>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarMul<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarMul<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Plus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarAdd<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarAdd<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RDivides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarRDiv<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRDiv<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarAdd<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarSub<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarRSub<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRSub<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarMul<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarMul<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarDiv<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorScalarRDiv<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarRDiv<V1>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorAdd<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorAdd<V1, V2>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorSub<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorSub<V1, V2>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorMul<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorMul<V1, V2>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E1: VectorExpression, E: MatrixExpression, V1: VectorExpression, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, RMinus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorDiv<V1, V2>>, VectorScalarRSub<E1>>

The resulting type after applying the * operator.

fn mul(self, rhs: VectorScalarRSub<E1>) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarAdd<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarSub<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarRSub<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarMul<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarDiv<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarRDiv<E1>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorAdd<E1, E2>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorSub<E1, E2>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorMul<E1, E2>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Mul<f64> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorDiv<E1, E2>>>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarAdd<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarSub<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarRSub<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarMul<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarDiv<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression> Neg for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorScalarRDiv<E1>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Neg for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorAdd<E1, E2>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Neg for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorSub<E1, E2>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Neg for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorMul<E1, E2>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Neg for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixScalarMul<MatrixVectorMul<E, VectorDiv<E1, E2>>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarAdd<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarSub<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarRSub<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarMul<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarDiv<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixSub<MatrixVectorMul<E, VectorScalarRDiv<E1>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixSub<MatrixVectorMul<E, VectorAdd<E1, E2>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixSub<MatrixVectorMul<E, VectorSub<E1, E2>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixSub<MatrixVectorMul<E, VectorMul<E1, E2>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<Return: MatrixExpression, E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<Return> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixSub<MatrixVectorMul<E, VectorDiv<E1, E2>>, Return>

The resulting type after applying the - operator.

fn sub(self, rhs: Return) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarAdd<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarAdd<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarSub<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarSub<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarRSub<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarRSub<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarMul<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarMul<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarDiv<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarDiv<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorScalarRDiv<E1>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorScalarRDiv<E1>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorAdd<E1, E2>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorAdd<E1, E2>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorSub<E1, E2>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorSub<E1, E2>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorMul<E1, E2>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorMul<E1, E2>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.

impl<E: MatrixExpression, E1: VectorExpression, E2: VectorExpression> Sub<f64> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixScalarSub<MatrixVectorMul<E, VectorDiv<E1, E2>>>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Performs the - operation.