Struct aljabar::Matrix

pub struct Matrix<T, const N: usize, const M: usize>(_);

An N-by-M Column Major matrix.

Matrices can be created from arrays of Vectors of any size and scalar type. As with Vectors there are convenience constructor functions for square matrices of the most common sizes.

All operations performed on matrices produce fixed-size outputs. For example, taking the transpose of a non-square matrix will produce a matrix with the width and height swapped:

Methods

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

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

Returns the transpose of the matrix.

Trait Implementations

impl<T, const N: usize, const M: usize> Zero for Matrix<T, { N }, { M }> where
    T: Zero,
    Vector<T, { N }>: Zero, 

fn zero() -> Self

Returns the additive identity of Self.

fn is_zero(&self) -> bool

Returns true if the value is the additive identity.

impl<T, const N: usize> One for Matrix<T, { N }, { N }> where
    T: Zero + One + Clone,
    Self: PartialEq<Self> + SquareMatrix<T, { N }>, 

Constructs a unit matrix.

fn one() -> Self

Returns the multiplicative identity for Self.

fn is_one(&self) -> bool

Returns true if the value is the multiplicative identity.

impl<Scalar, const N: usize> SquareMatrix<Scalar, N> for Matrix<Scalar, { N }, { N }> where
    Scalar: Clone,
    Self: Add<Self>,
    Self: Sub<Self>,
    Self: Mul<Self>,
    Self: Mul<Vector<Scalar, { N }>, Output = Vector<Scalar, { N }>>, 

fn invert(self) -> Option<Self>

Attempt to invert the matrix.

fn diagonal(&self) -> Vector<Scalar, { N }>

Return the diagonal of the matrix.

impl<A, B, RHS, const N: usize, const M: usize> PartialEq<RHS> for Matrix<A, { N }, { M }> where
    RHS: Deref<Target = [Vector<B, { N }>; {M}]>,
    A: PartialEq<B>, 

fn eq(&self, other: &RHS) -> bool

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

fn from(array: [Vector<T, { N }>; {M}]) -> Self

Performs the conversion.

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize, const M: usize> Deref for Matrix<T, { N }, { M }>

type Target = [Vector<T, { N }>; {M}]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, const N: usize, const M: usize> DerefMut for Matrix<T, { N }, { M }>

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

Mutably dereferences the value.

impl<A, B, const N: usize, const M: usize> Add<Matrix<B, N, M>> for Matrix<A, { N }, { M }> where
    A: Add<B>, 

Element-wise addition of two equal sized matrices.

type Output = Matrix<<A as Add<B>>::Output, { N }, { M }>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A, B, const N: usize, const M: usize> Sub<Matrix<B, N, M>> for Matrix<A, { N }, { M }> where
    A: Sub<B>, 

Element-wise subtraction of two equal sized matrices.

type Output = Matrix<<A as Sub<B>>::Output, { N }, { M }>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const N: usize, const M: usize, const P: usize> Mul<Matrix<T, M, P>> for Matrix<T, { N }, { M }> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Clone,
    Vector<T, { M }>: InnerSpace, 

type Output = Matrix<<Vector<T, { M }> as VectorSpace>::Scalar, { N }, { P }>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: usize, const M: usize> Mul<Vector<T, M>> for Matrix<T, { N }, { M }> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Clone,
    Vector<T, { M }>: InnerSpace, 

type Output = Vector<<Vector<T, { M }> as VectorSpace>::Scalar, { N }>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, { M }>) -> Self::Output

Performs the * operation.

impl<T, const N: usize, const M: usize> Mul<T> for Matrix<T, { N }, { M }> where
    T: Mul<T, Output = T> + Clone, 

Scalar multiply

type Output = Matrix<T, { N }, { M }>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, const N: usize, const M: usize> Neg for Matrix<T, { N }, { M }> where
    T: Neg, 

type Output = Matrix<<T as Neg>::Output, { N }, { M }>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B, const N: usize, const M: usize> AddAssign<Matrix<B, N, M>> for Matrix<A, { N }, { M }> where
    A: AddAssign<B>, 

fn add_assign(&mut self, rhs: Matrix<B, { N }, { M }>)

Performs the += operation.

impl<A, B, const N: usize, const M: usize> SubAssign<Matrix<B, N, M>> for Matrix<A, { N }, { M }> where
    A: SubAssign<B>, 

fn sub_assign(&mut self, rhs: Matrix<B, { N }, { M }>)

Performs the -= operation.

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

I'm not quite sure how to format the debug output for a matrix.

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

Formats the value using the given formatter.