Struct const_matrix::matrix::SMatrix

pub struct SMatrix<T: Numeric<T>, const ROWS: usize, const COLS: usize> { /* fields omitted */ }

A matrix which is allocated on the stack. An SMatrix is itself Numeric, so that its elements can also be other stack-allocated matrices which theoretically could contain SMatrices themselves up to arbitrarily deep finite nesting levels..

Implementations

impl<'a, T: Numeric<T>, const ROWS: usize, const COLS: usize> SMatrix<T, ROWS, COLS>

pub fn new(array: [[T; COLS]; ROWS]) -> Self

Creates a new stack-allocated matrix from the given initial values.

pub fn trans(&self) -> SMatrix<T, COLS, ROWS>

Creates a stack-allocated transpose of this matrix.

pub fn to_heap(&self) -> HMatrix<T, ROWS, COLS>

Creates a heap-allocated copy of this stack-allocated matrix.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize> SMatrix<T, ROWS_LEFT, COLS_LEFT>

pub fn mul_val_to_heap<const COLS_RIGHT: usize>(
    &self,
    rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>
) -> HMatrix<T, ROWS_LEFT, COLS_RIGHT>

Multiply two stack matrices and allocate the result on the heap.

pub fn mul_ref_to_heap<const COLS_RIGHT: usize>(
    &self,
    rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>
) -> HMatrix<T, ROWS_LEFT, COLS_RIGHT>

Multiply two stack matrices and allocate the result on the heap.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize> SMatrix<T, ROWS_LEFT, COLS_LEFT>

pub fn mul_val_to_stack<const COLS_RIGHT: usize>(
    &self,
    rhs: HMatrix<T, COLS_LEFT, COLS_RIGHT>
) -> SMatrix<T, ROWS_LEFT, COLS_RIGHT>

Multiply a stack matrix with a heap matrix and allocate the result on the stack.

pub fn mul_ref_to_stack<const COLS_RIGHT: usize>(
    &self,
    rhs: &HMatrix<T, COLS_LEFT, COLS_RIGHT>
) -> SMatrix<T, ROWS_LEFT, COLS_RIGHT>

Multiply a stack matrix with a heap matrix and allocate the result on the stack.

Trait Implementations

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ HMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for &HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<&'_ mut SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<HMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for &HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Add<SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut Self)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Numeric<T>, const ROWS: usize> AddAssign<SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the += operation.

impl<T: Clone + Numeric<T>, const ROWS: usize, const COLS: usize> Clone for SMatrix<T, ROWS, COLS>

fn clone(&self) -> SMatrix<T, ROWS, COLS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Numeric<T>, const ROWS: usize, const COLS: usize> Debug for SMatrix<T, ROWS, COLS>

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

Formats the value using the given formatter.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Default for SMatrix<T, ROWS, COLS>

fn default() -> Self

Create a new matrix initialized with zeros on the stack.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Index<usize> for SMatrix<T, ROWS, COLS>

type Output = [T; COLS]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T: Numeric<T>, const ROWS: usize, const COLS: usize> Index<usize> for &'a SMatrix<T, ROWS, COLS>

type Output = [T; COLS]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, T: Numeric<T>, const ROWS: usize, const COLS: usize> Index<usize> for &'a mut SMatrix<T, ROWS, COLS>

type Output = [T; COLS]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> IndexMut<usize> for SMatrix<T, ROWS, COLS>

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

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

impl<'a, T: Numeric<T>, const ROWS: usize, const COLS: usize> IndexMut<usize> for &'a mut SMatrix<T, ROWS, COLS>

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

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

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ HMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ HMatrix<T, COLS_LEFT, COLS_RIGHT>> for &SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ HMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<f32, ROWS, COLS>> for f32

type Output = SMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<f32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<f64, ROWS, COLS>> for f64

type Output = SMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<f64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<i128, ROWS, COLS>> for i128

type Output = SMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<i128, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<i16, ROWS, COLS>> for i16

type Output = SMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<i16, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<i32, ROWS, COLS>> for i32

type Output = SMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<i32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<i64, ROWS, COLS>> for i64

type Output = SMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<i64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ SMatrix<i8, ROWS, COLS>> for i8

type Output = SMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &SMatrix<i8, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut HMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut HMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut SMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut SMatrix<T, COLS_LEFT, COLS_RIGHT>> for HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<&'_ mut SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<f32, ROWS, COLS>> for f32

type Output = SMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<f32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<f64, ROWS, COLS>> for f64

type Output = SMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<f64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<i128, ROWS, COLS>> for i128

type Output = SMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<i128, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<i16, ROWS, COLS>> for i16

type Output = SMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<i16, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<i32, ROWS, COLS>> for i32

type Output = SMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<i32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<i64, ROWS, COLS>> for i64

type Output = SMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<i64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<&'_ mut SMatrix<i8, ROWS, COLS>> for i8

type Output = SMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut SMatrix<i8, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<HMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<HMatrix<T, COLS_LEFT, COLS_RIGHT>> for &SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<HMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut SMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = SMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS_LEFT: usize, const COLS_LEFT: usize, const COLS_RIGHT: usize> Mul<SMatrix<T, COLS_LEFT, COLS_RIGHT>> for &mut HMatrix<T, ROWS_LEFT, COLS_LEFT>

type Output = HMatrix<T, ROWS_LEFT, COLS_RIGHT>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<f32, ROWS, COLS>> for f32

type Output = SMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<f32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<f64, ROWS, COLS>> for f64

type Output = SMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<f64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<i128, ROWS, COLS>> for i128

type Output = SMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<i128, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<i16, ROWS, COLS>> for i16

type Output = SMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<i16, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<i32, ROWS, COLS>> for i32

type Output = SMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<i32, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<i64, ROWS, COLS>> for i64

type Output = SMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<i64, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<SMatrix<i8, ROWS, COLS>> for i8

type Output = SMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: SMatrix<i8, ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut Self)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> MulAssign<T> for SMatrix<T, ROWS, COLS>

Inplace scalar multiplication for SMatrix implemented as MulAssign.

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> MulAssign<T> for &mut SMatrix<T, ROWS, COLS>

Inplace scalar multiplication for a &mut SMatrix implemented as MulAssign.

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Neg for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Neg for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Neg for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ HMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for &HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<&'_ mut SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: &mut SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<HMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<HMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<HMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: HMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for &SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for &mut SMatrix<T, ROWS, COLS>

type Output = SMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for &HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize, const COLS: usize> Sub<SMatrix<T, ROWS, COLS>> for &mut HMatrix<T, ROWS, COLS>

type Output = HMatrix<T, ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: SMatrix<T, ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut Self)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<&'_ mut SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: &mut SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<HMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<HMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: HMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<SMatrix<T, ROWS, ROWS>> for SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<SMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<SMatrix<T, ROWS, ROWS>> for &mut SMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Numeric<T>, const ROWS: usize> SubAssign<SMatrix<T, ROWS, ROWS>> for &mut HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: SMatrix<T, ROWS, ROWS>)

Performs the -= operation.

impl<T: Copy + Numeric<T>, const ROWS: usize, const COLS: usize> Copy for SMatrix<T, ROWS, COLS>