Struct const_matrix::matrix::HMatrix

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

A matrix which is allocated on the heap.

Implementations

impl<'a, T: Numeric<T>, const ROWS: usize, const COLS: usize> HMatrix<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) -> HMatrix<T, COLS, ROWS>

Creates a heap-allocated transpose of this matrix.

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

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

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

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

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

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

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

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

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

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

Multiply a heap matrix with a stack 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<&'_ HMatrix<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: &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 &HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<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 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 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 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<HMatrix<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: 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 &HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 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 HMatrix<T, ROWS, ROWS>

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

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<&'_ HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 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 HMatrix<T, ROWS, ROWS>

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

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 HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 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 HMatrix<T, ROWS, ROWS>

fn add_assign(&mut self, rhs: Self)

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<HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 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 HMatrix<T, ROWS, COLS>

fn clone(&self) -> HMatrix<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 HMatrix<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 HMatrix<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 HMatrix<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 HMatrix<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 HMatrix<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 HMatrix<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 HMatrix<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 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: &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 &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: &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<&'_ HMatrix<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: &HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

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

type Output = HMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &HMatrix<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<&'_ 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 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<&'_ 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 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 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 HMatrix<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 HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

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

type Output = HMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &mut HMatrix<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 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 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<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 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: 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 &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: 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<HMatrix<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: HMatrix<T, COLS_LEFT, COLS_RIGHT>) -> Self::Output

Performs the * operation.

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

type Output = HMatrix<f32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<f64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i128, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i16, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i32, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i64, ROWS, COLS>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = HMatrix<i8, ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: HMatrix<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<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 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: 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<&'_ HMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

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

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 HMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

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

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<&'_ mut HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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<HMatrix<T, ROWS, ROWS>> for HMatrix<T, ROWS, ROWS>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Numeric<T>, const ROWS: usize> MulAssign<HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 HMatrix<T, ROWS, COLS>

Inplace scalar multiplication for HMatrix 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 HMatrix<T, ROWS, COLS>

Inplace scalar multiplication for a &mut HMatrix 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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 &HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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<&'_ HMatrix<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: &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 &HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<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 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 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 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<HMatrix<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: 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 &HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 HMatrix<T, ROWS, COLS>

type Output = HMatrix<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 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 HMatrix<T, ROWS, ROWS>

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

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<&'_ HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 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 HMatrix<T, ROWS, ROWS>

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

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 HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 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 HMatrix<T, ROWS, ROWS>

fn sub_assign(&mut self, rhs: Self)

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<HMatrix<T, ROWS, ROWS>> for &mut HMatrix<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 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 HMatrix<T, ROWS, ROWS>

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

Performs the -= operation.