Struct MatrixVectorMul

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

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, E2: VectorExpression> Add<Return> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Return, Plus>

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, VectorScalarAdd<E1>>

type Output = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Return, Plus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Return, Plus>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Plus>

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, VectorScalarAdd<E1>>

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Plus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Plus>

The resulting type after applying the + operator.

fn add(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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Divides>

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, VectorScalarAdd<E1>>

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Divides>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Divides>

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, E2: VectorExpression> Mul<Matrix> for MatrixVectorMul<E, VectorDiv<E1, E2>>

type Output = MatrixMul<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, 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, VectorBinaryOp<E1, E2, Minus>>, 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, VectorBinaryOp<E1, E2, Multiplies>>, 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, VectorBinaryOp<E1, E2, Plus>>, 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, VectorScalarBinaryOp<E1, Divides>>, 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, VectorScalarBinaryOp<E1, Minus>>, 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, VectorScalarBinaryOp<E1, Multiplies>>, 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, VectorScalarAdd<E1>>

type Output = MatrixMul<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, 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, VectorScalarBinaryOp<E1, RDivides>>, 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, VectorScalarBinaryOp<E1, RMinus>>, 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, V2: VectorExpression> Mul<VectorBinaryOp<E1, E2, Divides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

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

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, VectorBinaryOp<V1, V2, Minus>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorBinaryOp<E1, E2, Divides>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorBinaryOp<E1, E2, Divides>>

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, Minus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorBinaryOp<E1, E2, Minus>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorBinaryOp<E1, E2, Minus>>

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, Multiplies>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorBinaryOp<E1, E2, Multiplies>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorBinaryOp<E1, E2, Multiplies>>

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, Plus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorBinaryOp<E1, E2, Plus>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorBinaryOp<E1, E2, Plus>>

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, V2: VectorExpression> Mul<VectorScalarBinaryOp<E1, Divides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, Divides>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, Divides>>

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, Minus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, Minus>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, Minus>>

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, Multiplies>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, Multiplies>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, Multiplies>>

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, Plus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, Plus>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, Plus>>

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, RDivides>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, RDivides>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, RDivides>>

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, RMinus>> for MatrixVectorMul<E, VectorDiv<V1, V2>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorBinaryOp<V1, V2, Divides>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorBinaryOp<V1, V2, Minus>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorBinaryOp<V1, V2, Multiplies>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorBinaryOp<V1, V2, Plus>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarBinaryOp<V1, Divides>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarBinaryOp<V1, Minus>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarBinaryOp<V1, Multiplies>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarAdd<V1>>

type Output = MatrixVectorMul<MatrixVectorMul<E, VectorScalarBinaryOp<V1, Plus>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarBinaryOp<V1, RDivides>>, VectorScalarBinaryOp<E1, RMinus>>

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, VectorScalarBinaryOp<V1, RMinus>>, VectorScalarBinaryOp<E1, RMinus>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Multiplies>

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, VectorScalarAdd<E1>>

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Multiplies>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Multiplies>

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, VectorScalarAdd<E1>>

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Multiplies>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Multiplies>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type Output = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Return, Minus>

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, VectorScalarAdd<E1>>

type Output = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Return, Minus>

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 = MatrixBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Return, Minus>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Divides>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Minus>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Multiplies>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorBinaryOp<E1, E2, Plus>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Divides>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Minus>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Multiplies>>, Minus>

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, VectorScalarAdd<E1>>

type Output = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, Plus>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RDivides>>, Minus>

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 = MatrixScalarBinaryOp<MatrixVectorMul<E, VectorScalarBinaryOp<E1, RMinus>>, Minus>

The resulting type after applying the - operator.

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

Performs the - operation.