Struct static_la::MatrixSxS

pub struct MatrixSxS<T, const ROWS: usize, const COLUMNS: usize> where
    [(); ROWS * COLUMNS]: ,  { /* private fields */ }

A static x static matrix where both dimensions are known at compile time.

let _ = static_la::MatrixSxS::<i32,2,3>::from([[1, 2, 3], [4, 5, 6]]);

Implementations

impl<'a, T: Debug, const ROWS: usize, const COLUMNS: usize> MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); 1 * COLUMNS]: ,
    [(); ROWS * 1]: , 

pub fn iter(&'a self) -> impl Iterator<Item = &'a T>

An iterator over all elements.

pub fn iter_mut(&'a mut self) -> impl Iterator<Item = &'a mut T>

A mutable iterator over all elements.

pub fn rows_iter(&'a self) -> impl Iterator<Item = RowVectorS<&'a T, COLUMNS>>

An iterator over rows.

pub fn columns_iter(
    &'a self
) -> impl Iterator<Item = ColumnVectorS<&'a T, ROWS>>

An iterator over columns.

impl<T, const ROWS: usize, const COLUMNS: usize> MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

pub const fn len(&self) -> usize

Number of elements in matrix.

pub const fn rows(&self) -> usize

Number of rows.

pub const fn columns(&self) -> usize

Number of columns.

impl<T: Sum<T> + Copy + Default + Debug, const ROWS: usize, const COLUMNS: usize> MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); ROWS * 1]: ,
    [(); 1 * COLUMNS]: , 

pub fn sum(&self) -> T

Gets sum of all elements.

pub fn row_sum(&self) -> ColumnVectorS<T, ROWS>

Gets the sum of each row.

pub fn column_sum(&self) -> RowVectorS<T, COLUMNS>

Gets the sum of each column.

Trait Implementations

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: MatrixDxD<T>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: MatrixDxS<T, COLUMNS>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: MatrixSxD<T, ROWS>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the + operator.

fn add(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the + operator.

fn add(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the + operator.

fn add(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> Add<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixDxD<T>)

Performs the += operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixDxS<T, COLUMNS>)

Performs the += operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixSxD<T, ROWS>)

Performs the += operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the += operation.

impl<T: AddAssign + Copy + Default, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the += operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the += operation.

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Clone + Default + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxD<T, ROWS>

fn add_columns(self, columns: MatrixDxD<T>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize, const C: usize> AddColumns<MatrixDxS<T, C>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); ROWS * { COLUMNS + C }]: , 

type Output = MatrixSxS<T, ROWS, { COLUMNS + C }>

fn add_columns(self, columns: MatrixDxS<T, C>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxD<T, ROWS>

fn add_columns(self, columns: MatrixSxD<T, ROWS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize, const C: usize> AddColumns<MatrixSxS<T, ROWS, C>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); ROWS * C]: ,
    [(); ROWS * { COLUMNS + C }]: , 

type Output = MatrixSxS<T, ROWS, { COLUMNS + C }>

fn add_columns(self, columns: MatrixSxS<T, ROWS, C>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize, const C: usize> AddColumns<MatrixSxS<T, ROWS, C>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * { COLUMNS + C }]: ,
    [(); ROWS * C]: , 

type Output = MatrixSxS<T, ROWS, { COLUMNS + C }>

fn add_columns(self, columns: MatrixSxS<T, ROWS, C>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxD<T, ROWS>

fn add_columns(self, columns: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxD<T, ROWS>

fn add_columns(self, columns: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Debug, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixDxS<T, COLUMNS>

fn add_rows(self, rows: MatrixDxD<T>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixDxS<T, COLUMNS>

fn add_rows(self, rows: MatrixDxS<T, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize, const R: usize> AddRows<MatrixSxD<T, R>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); { ROWS + R } * COLUMNS]: , 

type Output = MatrixSxS<T, { ROWS + R }, COLUMNS>

fn add_rows(self, rows: MatrixSxD<T, R>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize, const R: usize> AddRows<MatrixSxS<T, R, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,
    [(); R * COLUMNS]: ,
    [(); { ROWS + R } * COLUMNS]: , 

type Output = MatrixSxS<T, { ROWS + R }, COLUMNS>

fn add_rows(self, rows: MatrixSxS<T, R, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize, const R: usize> AddRows<MatrixSxS<T, R, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); R * COLUMNS]: ,
    [(); { ROWS + R } * COLUMNS]: , 

type Output = MatrixSxS<T, { ROWS + R }, COLUMNS>

fn add_rows(self, rows: MatrixSxS<T, R, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Default + Copy, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixDxS<T, COLUMNS>

fn add_rows(self, rows: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone + Debug, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixDxS<T, COLUMNS>

fn add_rows(self, rows: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

This is somewhat inefficient, it will often not be as efficient as std::vec::Vec::push.

impl<T: Clone, const ROWS: usize, const COLUMNS: usize> Clone for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn clone(&self) -> MatrixSxS<T, ROWS, COLUMNS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const ROWS: usize, const COLUMNS: usize> Debug for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

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

Formats the value using the given formatter.

impl<T: Debug, const ROWS: usize, const COLUMNS: usize> Display for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

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

Formats the value using the given formatter.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: MatrixDxD<T>) -> Self::Output

Performs the / operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: MatrixDxS<T, COLUMNS>) -> Self::Output

Performs the / operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: MatrixSxD<T, ROWS>) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the / operator.

fn div(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the / operator.

fn div(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the / operator.

fn div(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the / operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> Div<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixDxD<T>)

Performs the /= operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixDxS<T, COLUMNS>)

Performs the /= operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixSxD<T, ROWS>)

Performs the /= operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the /= operation.

impl<T: DivAssign + Copy + Default, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the /= operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the /= operation.

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: Clone, const ROWS: usize, const COLUMNS: usize> From<&'_ [T; ROWS * COLUMNS]> for MatrixSxS<T, ROWS, COLUMNS>

fn from(data: &[T; ROWS * COLUMNS]) -> Self

Performs the conversion.

impl<T: Clone + Debug, const ROWS: usize, const COLUMNS: usize> From<[[T; COLUMNS]; ROWS]> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn from(data: [[T; COLUMNS]; ROWS]) -> Self

Performs the conversion.

impl<T, const ROWS: usize, const COLUMNS: usize> From<[T; ROWS * COLUMNS]> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn from(data: [T; ROWS * COLUMNS]) -> Self

Performs the conversion.

impl<T: Copy, const ROWS: usize, const COLUMNS: usize> From<T> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn from(x: T) -> Self

Performs the conversion.

impl<T, const ROWS: usize, const COLUMNS: usize> Index<(usize, usize)> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = T

The returned type after indexing.

fn index<'a>(&'a self, (row, column): (usize, usize)) -> &'a Self::Output

Performs the indexing (container[index]) operation.

impl<T, const ROWS: usize, const COLUMNS: usize> IndexMut<(usize, usize)> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn index_mut<'a>(&'a mut self, (row, column): (usize, usize)) -> &'a mut T

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

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T> + Debug, const L: usize, const M: usize> Matmul<MatrixDxD<T>> for MatrixSxS<T, L, M> where
    [(); L * M]: , 

type Output = MatrixSxD<T, L>

fn matmul(&self, other: &MatrixDxD<T>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const L: usize, const M: usize, const N: usize> Matmul<MatrixDxS<T, N>> for MatrixSxS<T, L, M> where
    [(); L * M]: ,
    [(); L * N]: , 

type Output = MatrixSxS<T, L, N>

fn matmul(&self, other: &MatrixDxS<T, N>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T> + Debug, const L: usize, const M: usize> Matmul<MatrixSxD<T, M>> for MatrixSxS<T, L, M> where
    [(); L * M]: , 

type Output = MatrixSxD<T, L>

fn matmul(&self, other: &MatrixSxD<T, M>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const M: usize, const N: usize> Matmul<MatrixSxS<T, M, N>> for MatrixDxD<T> where
    [(); M * N]: , 

type Output = MatrixDxS<T, N>

fn matmul(&self, other: &MatrixSxS<T, M, N>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const M: usize, const N: usize> Matmul<MatrixSxS<T, M, N>> for MatrixDxS<T, M> where
    [(); M * N]: , 

type Output = MatrixDxS<T, N>

fn matmul(&self, other: &MatrixSxS<T, M, N>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const L: usize, const M: usize, const N: usize> Matmul<MatrixSxS<T, M, N>> for MatrixSxD<T, L> where
    [(); L * N]: ,
    [(); M * N]: , 

type Output = MatrixSxS<T, L, N>

fn matmul(&self, other: &MatrixSxS<T, M, N>) -> Self::Output

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const L: usize, const M: usize, const N: usize> Matmul<MatrixSxS<T, M, N>> for MatrixSxS<T, L, M> where
    [(); L * M]: ,
    [(); M * N]: ,
    [(); L * N]: , 

type Output = MatrixSxS<T, L, N>

fn matmul(&self, other: &MatrixSxS<T, M, N>) -> Self::Output

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: MatrixDxD<T>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: MatrixDxS<T, COLUMNS>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: MatrixSxD<T, ROWS>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the * operator.

fn mul(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the * operator.

fn mul(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the * operator.

fn mul(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> Mul<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixDxD<T>)

Performs the *= operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixDxS<T, COLUMNS>)

Performs the *= operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixSxD<T, ROWS>)

Performs the *= operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the *= operation.

impl<T: MulAssign + Copy + Default, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the *= operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the *= operation.

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixDxD<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixDxS<T, COLUMNS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixSxD<T, ROWS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixSxS<T, ROWS, COLUMNS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixSxS<T, ROWS, COLUMNS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixSxS<T, ROWS, COLUMNS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn eq(&self, other: &MatrixSxS<T, ROWS, COLUMNS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &MatrixSxS<T, ROWS, COLUMNS>) -> bool

This method tests for !=.

impl<T, const R: usize, const C: usize> SliceDxD<T> for MatrixSxS<T, R, C> where
    [(); R * C]: , 

fn slice_dxd(
    &self,
    (rows, columns): (Range<usize>, Range<usize>)
) -> MatrixDxD<&T>

Given a range of rows and a range of columns returns a MatrixDxD holding references to the value within the ranges.

impl<T: Debug, const R: usize, const C: usize> SliceDxS<T> for MatrixSxS<T, R, C> where
    [(); R * C]: , 

fn slice_dxs<const COLUMNS: Range<usize>>(
    &self,
    rows: Range<usize>
) -> MatrixDxS<&T, { range_len(COLUMNS) }> where
    [(); range_len(COLUMNS)]: , 

Given a range of rows and a constant range of columns returns a MatrixDxS holding references to the value within the ranges.

impl<T: Debug, const R: usize, const C: usize> SliceSxD<T> for MatrixSxS<T, R, C> where
    [(); R * C]: , 

fn slice_sxd<const ROWS: Range<usize>>(
    &self,
    columns: Range<usize>
) -> MatrixSxD<&T, { range_len(ROWS) }> where
    [(); range_len(ROWS)]: , 

Given a constant range of rows and a range of columns returns a MatrixSxD holding references to the value within the ranges.

impl<T: Debug, const R: usize, const C: usize> SliceSxS<T> for MatrixSxS<T, R, C> where
    [(); R * C]: , 

fn slice_sxs<const ROWS: Range<usize>, const COLUMNS: Range<usize>>(
    &self
) -> MatrixSxS<&T, { range_len(ROWS) }, { range_len(COLUMNS) }> where
    [(); { range_len(ROWS) } * { range_len(COLUMNS) }]: , 

Given a constant range of rows and a constant range of columns returns a MatrixSxS holding references to the value within the ranges.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: MatrixDxD<T>) -> Self::Output

Performs the - operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: MatrixDxS<T, COLUMNS>) -> Self::Output

Performs the - operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: MatrixSxD<T, ROWS>) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the - operator.

fn sub(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the - operator.

fn sub(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the - operator.

fn sub(self, other: MatrixSxS<T, ROWS, COLUMNS>) -> Self::Output

Performs the - operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> Sub<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixDxD<T>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixDxD<T>)

Performs the -= operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixDxS<T, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixDxS<T, COLUMNS>)

Performs the -= operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxD<T, ROWS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixSxD<T, ROWS>)

Performs the -= operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxD<T> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the -= operation.

impl<T: SubAssign + Copy + Default, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixDxS<T, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the -= operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxD<T, ROWS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: MatrixSxS<T, ROWS, COLUMNS>)

Performs the -= operation.

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxS<T, ROWS, COLUMNS>> for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Eq, const ROWS: usize, const COLUMNS: usize> Eq for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

impl<T, const ROWS: usize, const COLUMNS: usize> StructuralEq for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: , 

impl<T, const ROWS: usize, const COLUMNS: usize> StructuralPartialEq for MatrixSxS<T, ROWS, COLUMNS> where
    [(); ROWS * COLUMNS]: ,