Struct opensrdk_linear_algebra::matrix::Matrix

pub struct Matrix<T = Standard, U = f64> where
    T: Type,
    U: Number,  { /* fields omitted */ }

Matrix

Implementations

impl Matrix<Standard, c64>

pub fn adjoint(&self) -> Matrix<Standard, c64>

Transpose

impl Matrix<Square, c64>

pub fn adjoint(&self) -> Matrix<Square, c64>

Transpose

impl Matrix<UpperTriangle, c64>

pub fn adjoint(&self) -> Matrix<LowerTriangle, c64>

Transpose

impl Matrix<LowerTriangle, c64>

pub fn adjoint(&self) -> Matrix<UpperTriangle, c64>

Transpose

impl Matrix<Diagonal, c64>

pub fn adjoint(&self) -> Matrix<Diagonal, c64>

Transpose

impl Matrix<PositiveDefinite, c64>

pub fn adjoint(&self) -> Matrix<Square, c64>

Transpose

impl Matrix<PositiveSemiDefinite, c64>

pub fn adjoint(&self) -> Matrix<Square, c64>

Transpose

impl Matrix<PositiveDefinite>

pub fn cholesky_d(self) -> Result<Matrix<LowerTriangle>, String>

Cholesky decomposition

for f64

https://en.wikipedia.org/wiki/Cholesky_decomposition

A = L * L^T

impl<T> Matrix<T, c64> where
    T: Type, 

pub fn lud(self) -> Result<LUDecomposed<T, c64>, String>

LU decomposition

for f64

impl<T> Matrix<T> where
    T: Type, 

pub fn lud(self) -> Result<LUDecomposed<T>, String>

LU decomposition

for f64

impl Matrix<PositiveSemiDefinite>

pub fn svd(
    &self
) -> Result<(Matrix<Square>, Matrix<Diagonal>, Matrix<Square>), String>

Singular Value Decomposition

https://en.wikipedia.org/wiki/Singular_value_decomposition

M = U * Sigma * V^T

impl<U> Matrix<UpperTriangle, U> where
    U: Number, 

pub fn det(&self) -> U

Determinant

for $t Matrix

impl<U> Matrix<LowerTriangle, U> where
    U: Number, 

pub fn det(&self) -> U

Determinant

for $t Matrix

impl<U> Matrix<Diagonal, U> where
    U: Number, 

pub fn det(&self) -> U

Determinant

for $t Matrix

impl Matrix<Diagonal, f64>

pub fn inv(self) -> Self

Inverse

for Diagonal Matrix

impl Matrix<Diagonal, c64>

pub fn inv(self) -> Self

Inverse

for Diagonal Matrix

impl Matrix<PositiveDefinite>

pub fn inv(self) -> Result<Matrix<PositiveDefinite>, String>

Inverse

for PositiveDefinite Matrix

impl Matrix<Square>

pub fn inv(self) -> Result<Matrix, String>

Inverse

for Square Matrix

impl Matrix<Square, c64>

pub fn inv(self) -> Result<Matrix<Standard, c64>, String>

Inverse

for Square Matrix

impl<T, U> Matrix<T, U> where
    T: Type,
    U: Number, 

pub fn linear_prod<V: Type>(&self, rhs: &Matrix<V, U>) -> U

Linear product

pub fn hadamard_prod<V: Type>(self, rhs: &Matrix<V, U>) -> Matrix<Standard, U>

Hamadard product

pub fn kronecker_prod<V: Type>(&self, rhs: &Matrix<V, U>) -> Matrix<Standard, U>

Kronecker product

impl Matrix<PositiveDefinite>

pub fn solve_eqs_cgm(self, constants: Matrix) -> Result<Matrix, String>

Solve equations Conjugate Gradient Method

for PositiveDefinite Matrix

impl Matrix<Square>

pub fn solve_eqs(self, constants: Matrix) -> Result<Matrix, String>

Solve equations

for Square Matrix

impl<U> Matrix<Standard, U> where
    U: Number, 

pub fn t(&self) -> Matrix<Standard, U>

Transpose

impl<U> Matrix<Square, U> where
    U: Number, 

pub fn t(&self) -> Matrix<Square, U>

Transpose

impl<U> Matrix<UpperTriangle, U> where
    U: Number, 

pub fn t(&self) -> Matrix<LowerTriangle, U>

Transpose

impl<U> Matrix<LowerTriangle, U> where
    U: Number, 

pub fn t(&self) -> Matrix<UpperTriangle, U>

Transpose

impl<U> Matrix<Diagonal, U> where
    U: Number, 

pub fn t(&self) -> Matrix<Diagonal, U>

impl<U> Matrix<PositiveDefinite, U> where
    U: Number, 

pub fn t(&self) -> Matrix<PositiveDefinite, U>

impl<U> Matrix<PositiveSemiDefinite, U> where
    U: Number, 

pub fn t(&self) -> Matrix<PositiveSemiDefinite, U>

impl<U: Number> Matrix<Square, U>

pub fn trace(&self) -> U

Trace

impl<U: Number> Matrix<UpperTriangle, U>

pub fn trace(&self) -> U

Trace

impl<U: Number> Matrix<LowerTriangle, U>

pub fn trace(&self) -> U

Trace

impl<U: Number> Matrix<Diagonal, U>

pub fn trace(&self) -> U

Trace

impl<U: Number> Matrix<PositiveDefinite, U>

pub fn trace(&self) -> U

Trace

impl<U: Number> Matrix<PositiveSemiDefinite, U>

pub fn trace(&self) -> U

Trace

impl<U> Matrix<Standard, U> where
    U: Number, 

pub fn zeros(rows: usize, columns: usize) -> Self

impl<U> Matrix<Square, U> where
    U: Number, 

pub fn zeros(dim: usize) -> Self

impl<T, U> Matrix<T, U> where
    T: Type,
    U: Number, 

pub fn new(rows: usize, columns: usize, elements: Vec<U>) -> Self

pub fn is_same_size<V: Type>(&self, rhs: &Matrix<V, U>) -> bool

pub fn get_rows(&self) -> usize

pub fn get_columns(&self) -> usize

pub fn get_elements(&mut self) -> &mut [U]

impl<T> Matrix<T, f64> where
    T: Type, 

pub fn to_complex(&self) -> Matrix<T, c64>

impl<T> Matrix<T, c64> where
    T: Type, 

pub fn to_real(&self) -> Matrix<T, f64>

impl<T, U> Matrix<T, U> where
    T: Type,
    U: Number, 

pub fn transmute<V: Type>(self) -> Matrix<V, U>

pub fn transmute_ref<V: Type>(&self) -> &Matrix<V, U>

Trait Implementations

impl<U: Number> Add<Matrix<Diagonal, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Diagonal, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Diagonal, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Diagonal, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Diagonal, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<Diagonal, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<LowerTriangle, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveDefinite, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<PositiveSemiDefinite, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Square, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<Square, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<Diagonal, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<Standard, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<Diagonal, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<U: Number> Add<Matrix<UpperTriangle, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the + operation.

impl<T: Clone, U: Clone> Clone for Matrix<T, U> where
    T: Type,
    U: Number, 

fn clone(&self) -> Matrix<T, U>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, U: Debug> Debug for Matrix<T, U> where
    T: Type,
    U: Number, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, U: Default> Default for Matrix<T, U> where
    T: Type,
    U: Number, 

fn default() -> Matrix<T, U>

Returns the "default value" for a type.

impl<T: Hash, U: Hash> Hash for Matrix<T, U> where
    T: Type,
    U: Number, 

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T, U> Index<usize> for Matrix<T, U> where
    T: Type,
    U: Number, 

type Output = [U]

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, U> IndexMut<usize> for Matrix<T, U> where
    T: Type,
    U: Number, 

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Diagonal, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Diagonal, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Diagonal, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Diagonal, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Diagonal, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Diagonal, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Diagonal, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<LowerTriangle, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<LowerTriangle, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<LowerTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveDefinite, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveDefinite, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<PositiveSemiDefinite, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Square, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Square, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Square, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<Square, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<Standard, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<Standard, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<Standard, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, c64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_> Mul<&'_ Matrix<UpperTriangle, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl<'_, '_> Mul<&'_ Matrix<UpperTriangle, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<UpperTriangle, f64>) -> Self::Output

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Diagonal, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Diagonal, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Diagonal, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Diagonal, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Diagonal, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Diagonal, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<LowerTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<LowerTriangle, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<LowerTriangle, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<LowerTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveDefinite, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveDefinite, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<PositiveSemiDefinite, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<PositiveSemiDefinite, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Square, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Square, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<Square, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<Standard, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<Standard, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Matrix<T, Complex<f64>>> for c64 where
    T: Type, 

type Output = Matrix<T, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Matrix<T, f64>> for f64 where
    T: Type, 

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Standard, c64>

type Output = Matrix<Standard, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<PositiveDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<PositiveSemiDefinite, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Square, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<UpperTriangle, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<LowerTriangle, c64>

type Output = Matrix<Square, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, Complex<f64>>> for Matrix<Diagonal, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, Complex<f64>>> for &'_ Matrix<Diagonal, c64>

type Output = Matrix<UpperTriangle, c64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<Standard, f64>

type Output = Matrix<Standard, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<PositiveDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<PositiveSemiDefinite, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<Square, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<UpperTriangle, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<LowerTriangle, f64>

type Output = Matrix<Square, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix<UpperTriangle, f64>> for Matrix<Diagonal, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'_> Mul<Matrix<UpperTriangle, f64>> for &'_ Matrix<Diagonal, f64>

type Output = Matrix<UpperTriangle, f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, U> Mul<U> for Matrix<T, U> where
    T: Type,
    U: Number, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<U: Number> Sub<Matrix<Diagonal, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Diagonal, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Diagonal, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Diagonal, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Diagonal, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Diagonal, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<Diagonal, U>

type Output = Matrix<LowerTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<LowerTriangle, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<LowerTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveDefinite, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<PositiveSemiDefinite, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<PositiveSemiDefinite, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<Diagonal, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Square, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Square, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<Square, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<Diagonal, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<Standard, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<Standard, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<Standard, U>

type Output = Matrix<Standard, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<Square, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<UpperTriangle, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<LowerTriangle, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<Diagonal, U>

type Output = Matrix<UpperTriangle, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<PositiveDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<U: Number> Sub<Matrix<UpperTriangle, U>> for Matrix<PositiveSemiDefinite, U>

type Output = Matrix<Square, U>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<UpperTriangle, U>) -> Self::Output

Performs the - operation.

impl<T, U> SubMatrix<U> for Matrix<T, U> where
    T: Type,
    U: Number, 

fn size(&self) -> (usize, usize)

fn index(&self, i: usize, j: usize) -> U

impl<T, U, '_> SubMatrix<U> for &'_ Matrix<T, U> where
    T: Type,
    U: Number, 

fn size(&self) -> (usize, usize)

fn index(&self, i: usize, j: usize) -> U