Struct libmat::mat::SMatrix

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

Statically sized matrix.

SMatrix is used almost just like Matrix, but its size is known at compile-time, so operations can be done without the & operator. The size of this matrix cannot be changed.

Example

let mut mat_a: SMatrix<i32, 3, 3> = SMatrix::one();
mat_a = mat_a * 2;
mat_a[1] = [1,2,3];
assert_eq!(mat_a, smatrix!{{2,0,0},{1,2,3},{0,0,2}});

Implementations

impl<T, const M: usize, const N: usize> SMatrix<T, M, N> where
    T: Copy, 

Methods for matrices with general dimensions.

pub fn new(init: T) -> SMatrix<T, M, N>

Creates new Matrix

Example

let mut mat_a: SMatrix<i32, 3, 3> = SMatrix::new(1_i32);
mat_a[1] = [1, 2, 3];
assert_eq!(mat_a[1], [1, 2, 3]);
assert_eq!(mat_a[1][1], 2);
let mat_b = smatrix!{1, 1, 1; 1, 1, 1; 1, 1, 1;};
let mat_c: SMatrix<u32, 3, 3> = SMatrix::new(1);
assert_eq!(mat_b, mat_c);

pub fn row_count(&self) -> usize

Get the number of rows

pub fn col_count(&self) -> usize

Get the number of columns

pub fn is_square(&self) -> bool

Returns true if the matrix is a square matrix, false otherwise.

pub fn transpose(&self) -> SMatrix<T, N, M> where
    T: Zero, 

Transpose a matrix.

This functions returns a new SMatrix with a different type.

Example

let mat_a: SMatrix<i32, 4, 3> = smatrix!{1, 2, 3;
                                         3, 2, 1;
                                         2, 3, 1;
                                         3, 1, 2};
assert_eq!(mat_a.transpose(), smatrix!{1,3,2,3;2,2,3,1;3,1,1,2});

impl<T, const N: usize> SMatrix<T, N, N> where
    T: Sub<Output = T> + Add<Output = T> + Mul<Output = T> + ToPrimitive, 

pub fn lupdecompose(&self) -> Option<(SMatrix<f64, N, N>, Vec<usize>)> where
    T: Signed, 

pub fn det(&self) -> f64 where
    T: Copy + Signed, 

pub fn diag(init: T) -> SMatrix<T, N, N> where
    T: Copy + One + Zero, 

Creates a diagonal matrix with every diagonal entry havong the value of init.

pub fn diag_with(entries: &[T]) -> SMatrix<T, N, N> where
    T: One + Copy + Zero, 

Creates a diagonal matrix with initial entries specified in entries.

Trait Implementations

impl<T, const M: usize, const N: usize> Add<SMatrix<T, M, N>> for SMatrix<T, M, N> where
    T: Add<Output = T> + Zero + Copy, 

type Output = SMatrix<T, M, N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const M: usize, const N: usize> AddAssign<SMatrix<T, M, N>> for SMatrix<T, M, N> where
    T: Add<Output = T> + Zero + Copy, 

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

Performs the += operation.

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

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

Returns a copy 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 SMatrix<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> Deref for SMatrix<T, M, N>

type Target = [[T; N]; M]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const M: usize, const N: usize> DerefMut for SMatrix<T, M, N>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, const M: usize, const N: usize> Display for SMatrix<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 SMatrix<T, M, N> where
    T: Mul<Output = T> + Div<Output = T> + One + Copy, 

type Output = Self

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 SMatrix<T, M, N> where
    T: Mul<Output = T> + Div<Output = T> + One + Copy, 

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

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

Performs the conversion.

impl<T, const N: usize> Inv for SMatrix<T, N, N> where
    T: Sub<Output = T> + Add<Output = T> + Mul<Output = T> + ToPrimitive + Signed, 

type Output = Option<SMatrix<f64, N, N>>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<T, const L: usize, const M: usize, const N: usize> Mul<SMatrix<T, M, N>> for SMatrix<T, L, M> where
    T: Add<Output = T> + Mul<Output = T> + One + Copy, 

type Output = SMatrix<T, L, N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const M: usize, const N: usize> Mul<T> for SMatrix<T, M, N> where
    T: Mul<Output = T> + One + Copy, 

type Output = SMatrix<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> MulAssign<T> for SMatrix<T, M, N> where
    T: Mul<Output = T> + One + Copy, 

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, const M: usize, const N: usize> Neg for SMatrix<T, M, N> where
    T: Neg<Output = T> + Zero + Copy, 

type Output = SMatrix<T, M, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const N: usize> One for SMatrix<T, N, N> where
    T: Add<Output = T> + Copy + Zero + One, 

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<Self>, 

Returns true if self is equal to the multiplicative identity.

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

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

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

fn ne(&self, other: &SMatrix<T, M, N>) -> bool

This method tests for !=.

impl<T, const M: usize, const N: usize> Sub<SMatrix<T, M, N>> for SMatrix<T, M, N> where
    T: Add<Output = T> + Sub<Output = T> + Neg<Output = T> + Zero + Copy, 

type Output = SMatrix<T, M, N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const M: usize, const N: usize> SubAssign<SMatrix<T, M, N>> for SMatrix<T, M, N> where
    T: Add<Output = T> + Sub<Output = T> + Neg<Output = T> + Zero + Copy, 

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

Performs the -= operation.

impl<T, const M: usize, const N: usize> Zero for SMatrix<T, M, N> where
    T: PartialEq + Copy + 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 SMatrix<T, M, N>

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