Struct static_la::MatrixDxD

pub struct MatrixDxD<T> { /* private fields */ }

A dynamic x dynamic matrix where neither dimension is known at compile time.

use std::convert::TryFrom;
let _ = static_la::MatrixDxD::try_from(vec![vec![1, 2, 3], vec![4, 5, 6]]).unwrap();

Implementations

impl<'a, T> MatrixDxD<T>

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 = RowVectorD<&'a T>>

An iterator over rows.

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

An iterator over columns.

impl<T> MatrixDxD<T>

pub fn len(&self) -> usize

Number of elements in matrix.

pub fn columns(&self) -> usize

Number of columns.

pub fn rows(&self) -> usize

Number of rows.

impl<T: Sum<T> + Clone> MatrixDxD<T>

pub fn sum(&self) -> T

Gets sum of all elements.

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

Gets the sum of each row.

pub fn column_sum(&self) -> RowVectorD<T>

Gets the sum of each column.

Trait Implementations

impl<T: AddAssign + Copy> Add<MatrixDxD<T>> for MatrixDxD<T>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: AddAssign + Copy, const COLUMNS: usize> Add<MatrixDxD<T>> for MatrixDxS<T, 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> Add<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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<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 COLUMNS: usize> Add<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

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> Add<MatrixSxD<T, ROWS>> for MatrixDxD<T>

type Output = MatrixSxD<T, ROWS>

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> AddAssign<MatrixDxD<T>> for MatrixDxD<T>

fn add_assign(&mut self, other: Self)

Performs the += operation.

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

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

Performs the += operation.

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

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

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 COLUMNS: usize> AddAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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

Performs the += operation.

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

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: 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 + Debug, const ROWS: usize> AddColumns<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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 + Debug, const COLUMNS: usize> AddColumns<MatrixDxD<T>> for MatrixDxS<T, COLUMNS>

type Output = MatrixDxD<T>

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 + Debug> AddColumns<MatrixDxD<T>> for MatrixDxD<T>

type Output = MatrixDxD<T>

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

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> AddColumns<MatrixSxD<T, ROWS>> for MatrixDxD<T>

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

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

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

type Output = MatrixDxD<T>

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 + Debug> AddRows<MatrixDxD<T>> for MatrixDxD<T>

type Output = MatrixDxD<T>

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 + Debug, const COLUMNS: usize> AddRows<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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 + Debug, const ROWS: usize> AddRows<MatrixSxD<T, ROWS>> for MatrixDxD<T>

type Output = MatrixDxD<T>

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.

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> Clone for MatrixDxD<T>

fn clone(&self) -> MatrixDxD<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for MatrixDxD<T>

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

Formats the value using the given formatter.

impl<T: Debug> Display for MatrixDxD<T>

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

Formats the value using the given formatter.

impl<T: DivAssign + Copy> Div<MatrixDxD<T>> for MatrixDxD<T>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: DivAssign + Copy, const COLUMNS: usize> Div<MatrixDxD<T>> for MatrixDxS<T, 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> Div<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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<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: 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.

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

Performs the / operation.

impl<T: Div<Output = T> + Copy, const ROWS: usize> Div<MatrixSxD<T, ROWS>> for MatrixDxD<T>

type Output = MatrixSxD<T, ROWS>

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: DivAssign + Copy> DivAssign<MatrixDxD<T>> for MatrixDxD<T>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

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

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

Performs the /= operation.

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

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

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 COLUMNS: usize> DivAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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

Performs the /= operation.

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

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: Copy> From<(usize, usize, T)> for MatrixDxD<T>

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

Performs the conversion.

impl<T> Index<(usize, usize)> for MatrixDxD<T>

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> IndexMut<(usize, usize)> for MatrixDxD<T>

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> Matmul<MatrixDxD<T>> for MatrixDxD<T>

type Output = MatrixDxD<T>

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

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

type Output = MatrixDxD<T>

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

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

type Output = MatrixSxD<T, L>

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

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 N: usize> Matmul<MatrixDxS<T, N>> for MatrixDxD<T>

type Output = MatrixDxS<T, N>

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

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

type Output = MatrixDxD<T>

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: MulAssign + Copy> Mul<MatrixDxD<T>> for MatrixDxD<T>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MulAssign + Copy, const COLUMNS: usize> Mul<MatrixDxD<T>> for MatrixDxS<T, 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> Mul<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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<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 COLUMNS: usize> Mul<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

type Output = MatrixDxS<T, COLUMNS>

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> Mul<MatrixSxD<T, ROWS>> for MatrixDxD<T>

type Output = MatrixSxD<T, ROWS>

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> MulAssign<MatrixDxD<T>> for MatrixDxD<T>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

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

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

Performs the *= operation.

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

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

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 COLUMNS: usize> MulAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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

Performs the *= operation.

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

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: PartialEq, const COLUMNS: usize> PartialEq<MatrixDxD<T>> for MatrixDxS<T, 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> PartialEq<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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<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> PartialEq<MatrixDxD<T>> for MatrixDxD<T>

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: &MatrixDxD<T>) -> bool

This method tests for !=.

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

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> PartialEq<MatrixSxD<T, ROWS>> for MatrixDxD<T>

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> SliceDxD<T> for MatrixDxD<T>

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> SliceDxS<T> for MatrixDxD<T>

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> SliceSxD<T> for MatrixDxD<T>

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> SliceSxS<T> for MatrixDxD<T>

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> Sub<MatrixDxD<T>> for MatrixDxD<T>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: SubAssign + Copy, const COLUMNS: usize> Sub<MatrixDxD<T>> for MatrixDxS<T, 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> Sub<MatrixDxD<T>> for MatrixSxD<T, ROWS>

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<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: 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.

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

Performs the - operation.

impl<T: Sub<Output = T> + Copy, const ROWS: usize> Sub<MatrixSxD<T, ROWS>> for MatrixDxD<T>

type Output = MatrixSxD<T, ROWS>

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: SubAssign + Copy> SubAssign<MatrixDxD<T>> for MatrixDxD<T>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

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

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

Performs the -= operation.

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

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

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 COLUMNS: usize> SubAssign<MatrixDxS<T, COLUMNS>> for MatrixDxD<T>

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

Performs the -= operation.

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

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: Clone> TryFrom<(usize, usize, &'_ [T])> for MatrixDxD<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T> TryFrom<(usize, usize, Vec<T, Global>)> for MatrixDxD<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T> TryFrom<Vec<Vec<T, Global>, Global>> for MatrixDxD<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T: Eq> Eq for MatrixDxD<T>

impl<T> StructuralEq for MatrixDxD<T>

impl<T> StructuralPartialEq for MatrixDxD<T>