Struct static_la::MatrixDxS

source · [−]

pub struct MatrixDxS<T, const COLUMNS: usize> { /* private fields */ }

Expand description

A dynamic x static matrix where the columns dimension is known at compile time.

let _ = static_la::MatrixDxS::from(vec![[1, 2, 3], [4, 5, 6]]);

Implementations

source

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

source

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

An iterator over all elements.

source

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

A mutable iterator over all elements.

source

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

An iterator over rows.

source

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

An iterator over columns.

source

impl<T, const COLUMNS: usize> MatrixDxS<T, COLUMNS>

source

pub fn len(&self) -> usize

Number of elements in matrix.

source

pub const fn columns(&self) -> usize

Number of columns.

source

pub fn rows(&self) -> usize

Number of rows.

source

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

source

pub fn sum(&self) -> T

Gets sum of all elements.

source

pub fn row_sum(&self) -> ColumnVectorD<T>

Gets the sum of each row.

source

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

Gets the sum of each column.

Trait Implementations

source

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

source

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

source

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

source

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.

source

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

Performs the + operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the + operator.

source

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

Performs the + operation. Read more

source

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.

source

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

Performs the + operation. Read more

source

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

source

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

Performs the += operation. Read more

source

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

source

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

Performs the += operation. Read more

source

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

source

fn add_assign(&mut self, other: Self)

Performs the += operation. Read more

source

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

source

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

Performs the += operation. Read more

source

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

source

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

Performs the += operation. Read more

source

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

source

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

Performs the += operation. Read more

source

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

source

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

Performs the += operation. Read more

source

impl<T: Clone + Default + Debug, const COLUMNS: usize> AddColumns<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxD<T>

source

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. Read more

source

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 }>

source

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. Read more

source

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

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

source

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. Read more

source

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

type Output = MatrixSxD<T, ROWS>

source

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

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

source

impl<T: Clone + Default + Copy + Debug, const COLUMNS: usize> AddColumns<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxD<T>

source

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

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

source

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

type Output = MatrixSxD<T, ROWS>

source

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. Read more

source

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 }>

source

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. Read more

source

impl<T: Clone + Debug, const COLUMNS: usize> AddRows<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxS<T, COLUMNS>

source

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. Read more

source

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>

source

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. Read more

source

impl<T: Clone, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxS<T, COLUMNS>

source

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. Read more

source

impl<T: Clone + Debug, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

type Output = MatrixDxS<T, COLUMNS>

source

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. Read more

source

impl<T: Clone + Debug, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

source

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. Read more

source

impl<T: Clone + Debug, const ROWS: usize, const COLUMNS: usize> AddRows<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxS<T, COLUMNS>

source

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

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

source

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>

source

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. Read more

source

impl<T: Clone, const COLUMNS: usize> Clone for MatrixDxS<T, COLUMNS>

source

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

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

source

impl<T: Debug, const COLUMNS: usize> Debug for MatrixDxS<T, COLUMNS>

source

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

Formats the value using the given formatter. Read more

source

impl<T: Debug, const COLUMNS: usize> Display for MatrixDxS<T, COLUMNS>

source

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

Formats the value using the given formatter. Read more

source

impl<T: DivAssign + Copy, const COLUMNS: usize> Div<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the / operator.

source

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

Performs the / operation. Read more

source

impl<T: Div<Output = T> + Copy, const COLUMNS: usize> Div<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

The resulting type after applying the / operator.

source

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

Performs the / operation. Read more

source

impl<T: DivAssign + Copy, const COLUMNS: usize> Div<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the / operator.

source

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

Performs the / operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the / operator.

source

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

Performs the / operation. Read more

source

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.

source

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

Performs the / operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the / operator.

source

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

Performs the / operation. Read more

source

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.

source

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

Performs the / operation. Read more

source

impl<T: DivAssign + Copy, const COLUMNS: usize> DivAssign<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

source

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

Performs the /= operation. Read more

source

impl<T: DivAssign + Copy, const COLUMNS: usize> DivAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

source

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

Performs the /= operation. Read more

source

impl<T: DivAssign + Copy, const COLUMNS: usize> DivAssign<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

source

fn div_assign(&mut self, other: Self)

Performs the /= operation. Read more

source

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

source

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

Performs the /= operation. Read more

source

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

source

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

Performs the /= operation. Read more

source

impl<T: DivAssign + Copy, const ROWS: usize, const COLUMNS: usize> DivAssign<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

source

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

Performs the /= operation. Read more

source

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

source

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

Performs the /= operation. Read more

source

impl<T: Copy, const COLUMNS: usize> From<(usize, T)> for MatrixDxS<T, COLUMNS>

source

fn from((rows, x): (usize, T)) -> Self

Performs the conversion.

source

impl<T, const COLUMNS: usize> From<Vec<[T; COLUMNS], Global>> for MatrixDxS<T, COLUMNS>

source

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

Performs the conversion.

source

impl<T, const COLUMNS: usize> Index<(usize, usize )> for MatrixDxS<T, COLUMNS>

type Output = T

The returned type after indexing.

source

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

Performs the indexing (container[index]) operation. Read more

source

impl<T, const COLUMNS: usize> IndexMut<(usize, usize )> for MatrixDxS<T, COLUMNS>

source

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

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

source

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T> + Debug, const M: usize> Matmul<MatrixDxD<T>> for MatrixDxS<T, M>

type Output = MatrixDxD<T>

source

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

source

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const N: usize> Matmul<MatrixDxS<T, N>> for MatrixDxD<T>

type Output = MatrixDxS<T, N>

source

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

source

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T>, const M: usize, const N: usize> Matmul<MatrixDxS<T, N>> for MatrixDxS<T, M>

type Output = MatrixDxS<T, N>

source

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

source

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

type Output = MatrixSxS<T, L, N>

source

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

source

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>

source

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

source

impl<T: Debug + Default + Copy + AddAssign + Mul<Output = T> + Debug, const M: usize> Matmul<MatrixSxD<T, M>> for MatrixDxS<T, M>

type Output = MatrixDxD<T>

source

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

source

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>

source

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

source

impl<T: MulAssign + Copy, const COLUMNS: usize> Mul<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

impl<T: MulAssign + Copy, const COLUMNS: usize> Mul<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

impl<T: MulAssign + Copy, const COLUMNS: usize> Mul<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

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.

source

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

Performs the * operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the * operator.

source

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

Performs the * operation. Read more

source

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.

source

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

Performs the * operation. Read more

source

impl<T: MulAssign + Copy, const COLUMNS: usize> MulAssign<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

source

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

Performs the *= operation. Read more

source

impl<T: MulAssign + Copy, const COLUMNS: usize> MulAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

source

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

Performs the *= operation. Read more

source

impl<T: MulAssign + Copy, const COLUMNS: usize> MulAssign<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

source

fn mul_assign(&mut self, other: Self)

Performs the *= operation. Read more

source

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

source

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

Performs the *= operation. Read more

source

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

source

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

Performs the *= operation. Read more

source

impl<T: MulAssign + Copy, const ROWS: usize, const COLUMNS: usize> MulAssign<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

source

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

Performs the *= operation. Read more

source

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

source

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

Performs the *= operation. Read more

source

impl<T: PartialEq, const COLUMNS: usize> PartialEq<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

source

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

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

1.0.0 · source

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

This method tests for !=.

source

impl<T: PartialEq, const COLUMNS: usize> PartialEq<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

source

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

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

1.0.0 · source

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

This method tests for !=.

source

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

source

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

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

1.0.0 · source

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

This method tests for !=.

source

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

source

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

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

1.0.0 · source

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

This method tests for !=.

source

impl<T: PartialEq, const COLUMNS: usize> PartialEq<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

source

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

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

source

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

This method tests for !=.

source

impl<T: PartialEq, const ROWS: usize, const COLUMNS: usize> PartialEq<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

source

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

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

1.0.0 · source

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

This method tests for !=.

source

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

source

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

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

1.0.0 · source

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

This method tests for !=.

source

impl<T, const C: usize> SliceDxD<T> for MatrixDxS<T, C>

source

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. Read more

source

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

source

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. Read more

source

impl<T: Debug, const C: usize> SliceSxD<T> for MatrixDxS<T, C>

source

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. Read more

source

impl<T: Debug, const C: usize> SliceSxS<T> for MatrixDxS<T, C>

source

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. Read more

source

impl<T: SubAssign + Copy, const COLUMNS: usize> Sub<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

source

impl<T: Sub<Output = T> + Copy, const COLUMNS: usize> Sub<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

source

impl<T: SubAssign + Copy, const COLUMNS: usize> Sub<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = Self

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

source

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.

source

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

Performs the - operation. Read more

source

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

The resulting type after applying the - operator.

source

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

Performs the - operation. Read more

source

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.

source

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

Performs the - operation. Read more

source

impl<T: SubAssign + Copy, const COLUMNS: usize> SubAssign<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

source

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

Performs the -= operation. Read more

source

impl<T: SubAssign + Copy, const COLUMNS: usize> SubAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

source

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

Performs the -= operation. Read more

source

impl<T: SubAssign + Copy, const COLUMNS: usize> SubAssign<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

source

fn sub_assign(&mut self, other: Self)

Performs the -= operation. Read more

source

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

source

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

Performs the -= operation. Read more

source

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

source

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

Performs the -= operation. Read more

source

impl<T: SubAssign + Copy, const ROWS: usize, const COLUMNS: usize> SubAssign<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

source

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

Performs the -= operation. Read more

source

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

source

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

Performs the -= operation. Read more

source

impl<T: Clone, const COLUMNS: usize> TryFrom<(usize, &'_ [T])> for MatrixDxS<T, COLUMNS>

type Error = &'static str

The type returned in the event of a conversion error.

source

fn try_from((rows, data): (usize, &[T])) -> Result<Self, Self::Error>

Performs the conversion.

source

impl<T, const COLUMNS: usize> TryFrom<(usize, Vec<T, Global>)> for MatrixDxS<T, COLUMNS>

type Error = &'static str

The type returned in the event of a conversion error.

source

fn try_from((rows, data): (usize, Vec<T>)) -> Result<Self, Self::Error>

Performs the conversion.

source

impl<T: Eq, const COLUMNS: usize> Eq for MatrixDxS<T, COLUMNS>

source

impl<T, const COLUMNS: usize> StructuralEq for MatrixDxS<T, COLUMNS>

source

impl<T, const COLUMNS: usize> StructuralPartialEq for MatrixDxS<T, COLUMNS>

Auto Trait Implementations

impl<T, const COLUMNS: usize> RefUnwindSafe for MatrixDxS<T, COLUMNS> where
T: RefUnwindSafe,

impl<T, const COLUMNS: usize> Send for MatrixDxS<T, COLUMNS> where
T: Send,

impl<T, const COLUMNS: usize> Sync for MatrixDxS<T, COLUMNS> where
T: Sync,

impl<T, const COLUMNS: usize> Unpin for MatrixDxS<T, COLUMNS> where
T: Unpin,

impl<T, const COLUMNS: usize> UnwindSafe for MatrixDxS<T, COLUMNS> where
T: UnwindSafe,

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

pub fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

pub fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T> ToString for T where
T: Display + ?Sized,

source

pub default fn to_string(&self) -> String

Converts the given value to a String. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

pub fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct static_la::MatrixDxS

Implementations

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

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

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

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

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

impl<T, const COLUMNS: usize> MatrixDxS<T, COLUMNS>

pub fn len(&self) -> usize

pub const fn columns(&self) -> usize

pub fn rows(&self) -> usize

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

pub fn sum(&self) -> T

pub fn row_sum(&self) -> ColumnVectorD<T>

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

Trait Implementations

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = Self

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

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

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

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = Self

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

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

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

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

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

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

type Output = MatrixSxS<T, ROWS, COLUMNS>

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

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>

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

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

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

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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

impl<T: AddAssign + Copy, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

fn add_assign(&mut self, other: Self)

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

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

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>)

impl<T: AddAssign + Copy, const ROWS: usize, const COLUMNS: usize> AddAssign<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

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

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>)

impl<T: Clone + Default + Debug, const COLUMNS: usize> AddColumns<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxD<T>

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

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

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

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

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

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixDxS<T, COLUMNS>> for MatrixSxD<T, ROWS>

type Output = MatrixSxD<T, ROWS>

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

impl<T: Clone + Default + Copy + Debug, const COLUMNS: usize> AddColumns<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxD<T>

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

impl<T: Clone + Default + Copy + Debug, const ROWS: usize, const COLUMNS: usize> AddColumns<MatrixSxD<T, ROWS>> for MatrixDxS<T, COLUMNS>

type Output = MatrixSxD<T, ROWS>

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

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

impl<T: Clone + Debug, const COLUMNS: usize> AddRows<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxS<T, COLUMNS>

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

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

impl<T: Clone, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxS<T, COLUMNS>

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

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

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

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

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

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

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

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

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 }]: ,

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

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]: ,

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

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

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

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

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

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

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

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

impl<T, const COLUMNS: usize> Index<(usize, usize )> for MatrixDxS<T, COLUMNS>

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

impl<T, const COLUMNS: usize> IndexMut<(usize, usize )> for MatrixDxS<T, COLUMNS>