Struct Matrix 

pub struct Matrix<T, const M: usize, const N: usize> { /* private fields */ }

Implementations

impl<T, const M: usize, const N: usize> Matrix<T, M, N>

pub const fn new(cols: [Vector<T, M>; N]) -> Self

pub fn gen<F>(f: F) -> Self

where F: Fn(usize, usize) -> T,

pub fn submatrix<const P: usize, const Q: usize>( self, col_offset: usize, row_offset: usize, ) -> Matrix<T, P, Q>

where T: Clone,

pub fn transpose(self) -> Matrix<T, N, M>

where T: Clone,

pub fn map<F, U>(self, f: F) -> Matrix<U, M, N>

where F: Fn(T) -> U,

pub fn map_mut<F>(&mut self, f: F)

where F: Fn(&mut T),

pub fn map_column<F>(self, f: F, col_idx: usize) -> Self

where F: Fn(T) -> T, T: Debug,

pub fn map_column_mut<F>(&mut self, f: F, col_idx: usize)

where F: Fn(&mut T), T: Debug,

pub fn apply<F, U, V>(self, f: F, rhs: Matrix<U, M, N>) -> Matrix<V, M, N>

where F: Fn(T, U) -> V,

pub fn apply_mut<F, U>(&mut self, f: F, rhs: Matrix<U, M, N>)

where F: Fn(&mut T, U),

pub fn iter(&self) -> <&Self as IntoIterator>::IntoIter

pub fn into_iter(self) -> <Self as IntoIterator>::IntoIter

pub fn iter_mut(&mut self) -> <&mut Self as IntoIterator>::IntoIter

pub fn row_echelon_form(self) -> Self

where T: Float + Debug,

pub fn reduced_row_echelon_form(self) -> Self

where T: Float + Debug,

pub fn column_echelon_form(self) -> Self

where T: Float + Debug,

pub fn reduced_column_echelon_form(self) -> Self

where T: Float + Debug,

pub fn sort_columns_by_leading_coefficient_index(self) -> Self

where T: Zero + Clone + Debug,

pub fn swap_columns(&mut self, col1_idx: usize, col2_idx: usize)

impl<T, const N: usize> Matrix<T, N, 1>

pub fn new_column(col_data: [T; N]) -> Self

impl<T, const N: usize> Matrix<T, 1, N>

pub fn new_row(row_data: [T; N]) -> Self

Trait Implementations

impl<T, const M: usize, const N: usize> Add for Matrix<T, M, N>

where T: Add<T, Output = T>,

type Output = Matrix<T, M, N>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<T, M, N>) -> Self::Output

Performs the + operation.

impl<T, const M: usize, const N: usize> AddAssign for Matrix<T, M, N>

where T: AddAssign<T>,

fn add_assign(&mut self, rhs: Matrix<T, M, N>)

Performs the += operation.

impl<T: Clone, const M: usize, const N: usize> Clone for Matrix<T, M, N>

fn clone(&self) -> Matrix<T, M, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const M: usize, const N: usize> Debug for Matrix<T, M, N>

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

Formats the value using the given formatter.

impl<T, const M: usize, const N: usize> Display for Matrix<T, M, N>

where T: Display,

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

Formats the value using the given formatter.

impl<T, const M: usize, const N: usize> Div<T> for Matrix<T, M, N>

where T: Div<T, Output = T> + Clone,

type Output = Matrix<T, M, N>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T, const M: usize, const N: usize> DivAssign<T> for Matrix<T, M, N>

where T: DivAssign<T> + Clone,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T, const M: usize, const N: usize> From<[[T; M]; N]> for Matrix<T, M, N>

fn from(value: [[T; M]; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Matrix<T, N, 1>> for Vector<T, N>

fn from(value: Matrix<T, N, 1>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Vector<T, N>> for Matrix<T, N, 1>

fn from(value: Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T: Hash, const M: usize, const N: usize> Hash for Matrix<T, M, N>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const M: usize, const N: usize> Index<usize> for Matrix<T, M, N>

type Output = Vector<T, M>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const M: usize, const N: usize> IndexMut<usize> for Matrix<T, M, N>

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

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

impl<'a, T, const M: usize, const N: usize> IntoIterator for &'a Matrix<T, M, N>

type Item = &'a Vector<T, M>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Vector<T, M>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const M: usize, const N: usize> IntoIterator for &'a mut Matrix<T, M, N>

type Item = &'a mut Vector<T, M>

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Vector<T, M>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const M: usize, const N: usize> IntoIterator for Matrix<T, M, N>

type Item = Vector<T, M>

The type of the elements being iterated over.

type IntoIter = IntoIter<Vector<T, M>, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const M: usize, const N: usize, const P: usize> Mul<Matrix<T, N, P>> for Matrix<T, M, N>

where T: Clone + Mul<T, Output = T> + Sum,

type Output = Matrix<T, M, P>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T, N, P>) -> Self::Output

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<T> for Matrix<T, M, N>

where T: Mul<T, Output = T> + Clone,

type Output = Matrix<T, M, N>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<Vector<T, N>> for Matrix<T, M, N>

where T: Clone + Mul<T, Output = T> + Sum,

type Output = Vector<T, M>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, N>) -> Self::Output

Performs the * operation.

impl<T, const M: usize> One for Matrix<T, M, M>

where T: Clone + Mul<T, Output = T> + Sum + One + Zero,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: PartialEq, const M: usize, const N: usize> PartialEq for Matrix<T, M, N>

fn eq(&self, other: &Matrix<T, M, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, const M: usize, const N: usize> Sub for Matrix<T, M, N>

where T: Sub<T, Output = T>,

type Output = Matrix<T, M, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<T, M, N>) -> Self::Output

Performs the - operation.

impl<T, const M: usize, const N: usize> SubAssign for Matrix<T, M, N>

where T: SubAssign<T>,

fn sub_assign(&mut self, rhs: Matrix<T, M, N>)

Performs the -= operation.

impl<T, const M: usize, const N: usize> Zero for Matrix<T, M, N>

where T: Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy, const M: usize, const N: usize> Copy for Matrix<T, M, N>

impl<T: Eq, const M: usize, const N: usize> Eq for Matrix<T, M, N>

impl<T, const M: usize, const N: usize> StructuralPartialEq for Matrix<T, M, N>