Struct sized_matrix::Matrix

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

An M by N matrix of Ts.

Examples

Multiplying two matrices of different sizes:

use sized_matrix::Matrix;

let a: Matrix<i32, 3, 4> = Matrix::rows([
    [ 1,  2,  3,  4],
    [ 5,  6,  7,  8],
    [ 9, 10, 11, 12],
]);

let b: Matrix<i32, 4, 2> = Matrix::rows([
    [ 0,  1],
    [ 1,  2],
    [ 3,  5],
    [ 8, 13],
]);

let c: Matrix<i32, 3, 2> = a * b;

assert_eq!(c, Matrix::rows([
    [ 43,  72],
    [ 91, 156],
    [139, 240],
]));

Implementations

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

pub fn cols(cols: [[T; M]; N]) -> Self

Construct a matrix from an array of columns of values.

Examples

Constructing a matrix from columns:

use sized_matrix::Matrix;

let matrix = Matrix::cols([
    [1, 3],
    [2, 4],
]);

assert_eq!(matrix[[0, 0]], 1);
assert_eq!(matrix[[0, 1]], 2);
assert_eq!(matrix[[1, 0]], 3);
assert_eq!(matrix[[1, 1]], 4);

pub fn rows(rows: [[T; N]; M]) -> Self

Construct a matrix from an array of rows of values.

Examples

Constructing a matrix from rows:

use sized_matrix::Matrix;

let matrix = Matrix::rows([
    [1, 2],
    [3, 4],
]);

assert_eq!(matrix[[0, 0]], 1);
assert_eq!(matrix[[0, 1]], 2);
assert_eq!(matrix[[1, 0]], 3);
assert_eq!(matrix[[1, 1]], 4);

pub fn from_vectors(vectors: [Vector<T, M>; N]) -> Self

Construct a matrix from an array of column vectors.

Examples

Applying a transformation to the points of a square:

use sized_matrix::Matrix;

let points = [
	Matrix::vector([0.0, 0.0]),
	Matrix::vector([0.0, 1.0]),
	Matrix::vector([1.0, 1.0]),
	Matrix::vector([1.0, 0.0]),
];

let shear = Matrix::rows([
	[1.0, 0.3],
	[0.0, 1.0],
]);

let transformed = (shear * Matrix::from_vectors(points)).to_vectors();

assert_eq!(transformed, [
	Matrix::vector([0.0, 0.0]),
	Matrix::vector([0.3, 1.0]),
	Matrix::vector([1.3, 1.0]),
	Matrix::vector([1.0, 0.0]),
]);

pub fn to_vectors(self) -> [Vector<T, M>; N]

Retrieve an array of column vectors from a matrix.

Examples

Applying a transformation to the points of a square:

use sized_matrix::Matrix;

let points = [
	Matrix::vector([0.0, 0.0]),
	Matrix::vector([0.0, 1.0]),
	Matrix::vector([1.0, 1.0]),
	Matrix::vector([1.0, 0.0]),
];

let shear = Matrix::rows([
	[1.0, 0.3],
	[0.0, 1.0],
]);

let transformed = (shear * Matrix::from_vectors(points)).to_vectors();

assert_eq!(transformed, [
	Matrix::vector([0.0, 0.0]),
	Matrix::vector([0.3, 1.0]),
	Matrix::vector([1.3, 1.0]),
	Matrix::vector([1.0, 0.0]),
]);

pub fn swap_row(&mut self, i: usize, j: usize)

Swap two rows of a matrix.

pub fn swap_col(&mut self, i: usize, j: usize)

Swap two columns of a matrix.

pub fn div_left<TRhs>(self, rhs: Matrix<TRhs, M, M>) -> Self where
    Matrix<T, N, M>: Div<Matrix<TRhs, M, M>, Output = Matrix<T, N, M>>, 

Matrix-Matrix left-division.

This performs a generalised Gauss-Jordan elimination to calculate rhs^-1 * self.

See Div<Matrix<TRhs, N, N>>.

impl<T, const M: usize> Matrix<T, M, 1_usize>

pub fn vector(contents: [T; M]) -> Self

Construct a column vector from an array.

Examples

Constructing a Vector:

use sized_matrix::{Vector, Matrix};

let vector: Vector<i32, 3> = Vector::vector([1, 2, 3]);

assert_eq!(vector, Matrix::cols([[1, 2, 3]]));

Trait Implementations

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize, const N: usize> Add<Matrix<TRhs, M, N>> for Matrix<TLhs, M, N> where
    TLhs: Add<TRhs, Output = TOutput>, 

type Output = Matrix<TOutput, M, N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> AddAssign<Matrix<TRhs, M, N>> for Matrix<TLhs, M, N> where
    Self: Add<Matrix<TRhs, M, N>, Output = Self>, 

fn add_assign(&mut self, rhs: Matrix<TRhs, 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 copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> Div<Matrix<TRhs, N, N>> for Matrix<TLhs, M, N> where
    TLhs: MulAdd<TRhs, TLhs, Output = TLhs> + DivAssign<TRhs>,
    TRhs: Zero + MulAdd<TRhs, TRhs, Output = TRhs> + DivAssign<TRhs> + Neg<Output = TRhs>, 

Matrix-Matrix right-division.

This performs a generalised Gauss-Jordan elimination to calculate self * rhs^-1.

This is slightly more efficient than calculating the inverse then multiplying, as the Gauss-Jordan method of finding an inverse involves multiplying the identity matrix by the inverse of the matrix, so you can replace this identity matrix with another matrix to get an extra multiplication ‘for free’. Inversion is then defined as A^-1 = 1 / A.

type Output = Matrix<TLhs, M, N>

The resulting type after applying the / operator.

fn div(self, rhs: Matrix<TRhs, N, N>) -> Self::Output

Performs the / operation.

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize, const N: usize> Div<TRhs> for Matrix<TLhs, M, N> where
    TLhs: Div<TRhs, Output = TOutput>,
    TRhs: Scalar, 

Matrix-Scalar division.

type Output = Matrix<TOutput, M, N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy, const M: usize, const N: usize> DivAssign<Matrix<T, N, N>> for Matrix<T, M, N> where
    Self: Div<Matrix<T, N, N>, Output = Self>, 

Matrix-Matrix division.

See Div<Matrix<TRhs, N, N>>

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

Performs the /= operation.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> DivAssign<TRhs> for Matrix<TLhs, M, N> where
    Self: Div<TRhs, Output = Matrix<TLhs, M, N>>,
    TRhs: Scalar, 

Matrix-Scalar division.

fn div_assign(&mut self, rhs: TRhs)

Performs the /= operation.

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize> Dot<Matrix<TRhs, M, 1_usize>> for Vector<TLhs, M> where
    TLhs: Mul<TRhs, Output = TOutput> + MulAdd<TRhs, TOutput, Output = TOutput>,
    TOutput: Zero, 

type Output = TOutput

fn dot(self, rhs: Vector<TRhs, M>) -> Self::Output

Returns self · rhs.

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

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, 

Feeds a slice of this type into the given Hasher.

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

type Output = T

The returned type after indexing.

fn index(&self, [row, col]: [usize; 2]) -> &T

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, [row, col]: [usize; 2]) -> &mut T

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

impl<T, const M: usize, const N: usize> Init<T, [usize; 2], ()> for Matrix<T, M, N>

fn init_with<F: FnMut([usize; 2]) -> T>(_: (), elem: F) -> Self

Initialise an instance of this type using value by applying elem to each ‘index’ of the type.

fn init<F>(elem: F) -> Self where
    F: FnMut(I) -> T,
    V: TypeEquals<()>, 

Initialise an instance of this type by applying elem to each ‘index’ of the type.

impl<T: Copy, const N: usize> Inv for Matrix<T, N, N> where
    Self: One + Div<Self, Output = Self>, 

type Output = Matrix<T, N, N>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

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

type TFrom = T

The type of values being mapped over.

type TOut<TTo> = Matrix<TTo, M, N>

The generic type of the result after mapping.

fn map<TTo, F: FnMut(Self::TFrom) -> TTo>(self, f: F) -> Self::TOut<TTo>

Apply a function to the inner values of this type.

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize, const K: usize, const N: usize> Mul<Matrix<TRhs, K, N>> for Matrix<TLhs, M, K> where
    TLhs: Mul<TRhs, Output = TOutput> + MulAdd<TRhs, TOutput, Output = TOutput>,
    TOutput: Zero, 

Matrix-Matrix multiplication.

type Output = Matrix<TOutput, M, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<TRhs, K, N>) -> Self::Output

Performs the * operation.

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize, const N: usize> Mul<TRhs> for Matrix<TLhs, M, N> where
    TLhs: Mul<TRhs, Output = TOutput>,
    TRhs: Scalar, 

Matrix-Scalar multiplication.

type Output = Matrix<TOutput, M, N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<TLhs: Copy, TA: Copy, TB: Copy, const M: usize, const K: usize, const N: usize> MulAdd<Matrix<TA, K, N>, Matrix<TB, M, N>> for Matrix<TLhs, M, K> where
    TLhs: MulAdd<TA, TB, Output = TB>, 

type Output = Matrix<TB, M, N>

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: Matrix<TA, K, N>, b: Matrix<TB, M, N>) -> Self::Output

Performs the fused multiply-add operation.

impl<TLhs: Copy, TA: Copy, TB: Copy, const M: usize, const N: usize> MulAddAssign<Matrix<TA, N, N>, Matrix<TB, M, N>> for Matrix<TLhs, M, N> where
    Self: MulAdd<Matrix<TA, N, N>, Matrix<TB, M, N>, Output = Self>, 

fn mul_add_assign(&mut self, a: Matrix<TA, N, N>, b: Matrix<TB, M, N>)

Performs the fused multiply-add operation.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> MulAssign<Matrix<TRhs, N, N>> for Matrix<TLhs, M, N> where
    Self: Mul<Matrix<TRhs, N, N>, Output = Self>, 

Matrix-Matrix multiplication.

fn mul_assign(&mut self, rhs: Matrix<TRhs, N, N>)

Performs the *= operation.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> MulAssign<TRhs> for Matrix<TLhs, M, N> where
    Self: Mul<TRhs, Output = Matrix<TLhs, M, N>>,
    TRhs: Scalar, 

Matrix-Scalar multiplication.

fn mul_assign(&mut self, rhs: TRhs)

Performs the *= operation.

impl<T: Copy, TOutput, const M: usize, const N: usize> Neg for Matrix<T, M, N> where
    T: Neg<Output = TOutput>, 

type Output = Matrix<TOutput, M, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

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, const M: usize, const N: usize> PartialEq<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: PartialEq, 

fn eq(&self, rhs: &Matrix<T, M, N>) -> 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: Copy, TRhs, const N: usize> Pow<TRhs> for Matrix<T, N, N> where
    Self: Inv<Output = Self> + One + MulAssign<Self>,
    TRhs: PrimInt, 

type Output = Matrix<T, N, N>

The result after applying the operator.

fn pow(self, rhs: TRhs) -> Self::Output

Returns self to the power rhs.

impl<T: Copy, const M: usize, const N: usize, const M_OUT: usize, const N_OUT: usize> Section<[usize; 2], Matrix<T, M_OUT, N_OUT>> for Matrix<T, M, N>

fn section(
    &self,
    [row_offset, col_offset]: [usize; 2]
) -> Matrix<T, M_OUT, N_OUT>

Get a section of type TOut starting at offset offset.

impl<T: Copy, const M: usize, const M_OUT: usize> Section<usize, Matrix<T, M_OUT, 1_usize>> for Vector<T, M>

fn section(&self, offset: usize) -> Vector<T, M_OUT>

Get a section of type TOut starting at offset offset.

impl<TLhs: Copy, TRhs: Copy, TOutput, const M: usize, const N: usize> Sub<Matrix<TRhs, M, N>> for Matrix<TLhs, M, N> where
    TLhs: Sub<TRhs, Output = TOutput>, 

type Output = Matrix<TOutput, M, N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<TLhs: Copy, TRhs: Copy, const M: usize, const N: usize> SubAssign<Matrix<TRhs, M, N>> for Matrix<TLhs, M, N> where
    Self: Sub<Matrix<TRhs, M, N>, Output = Self>, 

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

Performs the -= operation.

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

type Output = Matrix<T, N, M>

fn transpose(self) -> Self::Output

Returns the transpose of self.

impl<T: Copy, 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<TLhs, const M: usize, const N: usize> Zip for Matrix<TLhs, M, N>

type TLhs = TLhs

The type parameter of Self.

type TSelf<T> = Matrix<T, M, N>

The generic type of Self.

fn zip_with<TRhs, TTo, F: FnMut(Self::TLhs, TRhs) -> TTo>(
    self,
    rhs: Self::TSelf<TRhs>,
    f: F
) -> Self::TSelf<TTo>

Apply f to each pair of elements in self and rhs and return the results.

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

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

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