Struct quick_maths::Matrix

pub struct Matrix<T = DefaultFloat, const M: usize, const N: usize>(pub [Vector<T, M>; N])
 where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32;

A matrix, where each vector represents a column

Implementations

impl<T: Float, const M: usize, const N: usize> Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

pub fn dot(&self, vec: &Vector<T, N>) -> Vector<T, M>

pub fn t(&self) -> Matrix<T, N, M> where
    [Vector<T, N>; M]: LengthAtMost32, 

pub fn matmul<const P: usize>(&self, o: Matrix<T, N, P>) -> Matrix<T, M, P> where
    [Vector<T, N>; P]: LengthAtMost32,
    [Vector<T, M>; P]: LengthAtMost32,
    [T; P]: LengthAtMost32, 

Performs naive matrix multiplication

pub fn swap_rows(&mut self, cols: Range<usize>, a: usize, b: usize)

pub fn swap_cols(&mut self, a: usize, b: usize)

pub fn apply_fn<F, S>(&self, f: F) -> Matrix<S, M, N> where
    F: FnMut(T) -> S + Copy,
    S: Float,
    [S; M]: LengthAtMost32,
    [S; N]: LengthAtMost32,
    [Vector<S, M>; N]: LengthAtMost32, 

pub fn zxtend<const I: usize, const J: usize>(&self) -> Matrix<T, I, J> where
    [T; I]: LengthAtMost32,
    [T; J]: LengthAtMost32,
    [Vector<T, I>; J]: LengthAtMost32, 

Zero extend this matrix to a larger size

pub fn reduce<const I: usize, const J: usize>(&self) -> Matrix<T, I, J> where
    [T; I]: LengthAtMost32,
    [T; J]: LengthAtMost32,
    [Vector<T, I>; J]: LengthAtMost32, 

Take some subset of this matrix(only takes from the topt left)

pub fn frobenius(&self) -> T

impl<T: Float, const M: usize> Matrix<T, M, M> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; M]: LengthAtMost32, 

pub fn diag(&self) -> impl Iterator<Item = T> + '_

Returns elements on the diagonal from top left to bottom right

pub fn off_diag(&self) -> impl Iterator<Item = T> + '_

Returns elements not on the diagonal in no specific order

pub fn trace(&self) -> T

pub fn lup(&self) -> (Self, Self, Self)

LUP decomposes self into lower triangular, upper triangular and pivot matrix

pub fn usolve(&self, b: &Vector<T, M>) -> Vector<T, M>

Given an upper triangular matrix and a vector, compute the solution to the system of equations

pub fn lsolve(&self, b: &Vector<T, M>) -> Vector<T, M>

Given a lower triangular matrix and a vector, compute the solution to the system of equations

pub fn solve((l, u, p): &(Self, Self, Self), b: &Vector<T, M>) -> Vector<T, M>

Solves for x in the linear system Ax = b;

impl<T: Float> Matrix<T, 3usize, 3usize>

pub fn new(c0: Vec3<T>, c1: Vec3<T>, c2: Vec3<T>) -> Self

pub fn det(&self) -> T

Computes the determinant of this matrix

pub fn inv(&self) -> Self

Inverts this matrix, does not handle non-invertible matrices

pub fn rot(around: &Vec3<T>, cos_t: T) -> Self

pub fn scale(by: &Vec3<T>) -> Self

pub fn translate(by: &Vec2<T>) -> Self

Translation operator for 2 space

pub fn project(normal: &Vec3<T>) -> Self

pub fn from_quat(q: Quat<T>) -> Self

https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation Converts a quaternion into an equivalent matrix

impl<T: Float> Matrix<T, 2usize, 2usize>

pub fn det(&self) -> T

Computes the determinant of this matrix

pub fn inv(&self) -> Self

Inverts this matrix, does not handle non-invertible matrices

pub fn rot(theta: T) -> Self

Returns the rotation matrix given a theta in the counterclockwise direction

pub fn scale(sx: T, sy: T) -> Self

Returns the scale matrix given scale in each direction

impl<T: Float> Matrix<T, 4usize, 4usize>

pub fn new(c0: Vec4<T>, c1: Vec4<T>, c2: Vec4<T>, c3: Vec4<T>) -> Self

pub fn translate(t: Vec3<T>) -> Self

Returns a translation matrix by t

pub fn inv(&self) -> Self

Computes the inverse of this matrix if it exists

impl<T: Float, const M: usize, const N: usize> Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

pub fn cos(&self) -> Self

Element-wise cos .

pub fn sin(&self) -> Self

Element-wise sin .

pub fn tan(&self) -> Self

Element-wise tan .

pub fn acos(&self) -> Self

Element-wise acos .

pub fn asin(&self) -> Self

Element-wise asin .

pub fn atan(&self) -> Self

Element-wise atan .

pub fn acosh(&self) -> Self

Element-wise acosh .

pub fn asinh(&self) -> Self

Element-wise asinh .

pub fn atanh(&self) -> Self

Element-wise atanh .

pub fn atan2(&self, v: T) -> Self

Element-wise atan2 .

pub fn hypot(&self, v: T) -> Self

Element-wise hypot .

pub fn ceil(&self) -> Self

Element-wise ceil .

pub fn floor(&self) -> Self

Element-wise floor .

pub fn round(&self) -> Self

Element-wise round .

pub fn fract(&self) -> Self

Element-wise fract .

pub fn trunc(&self) -> Self

Element-wise trunc .

pub fn abs(&self) -> Self

Element-wise abs .

pub fn abs_sub(&self, v: T) -> Self

Element-wise abs_sub .

pub fn signum(&self) -> Self

Element-wise signum .

pub fn recip(&self) -> Self

Element-wise recip .

pub fn log2(&self) -> Self

Element-wise log2 .

pub fn log10(&self) -> Self

Element-wise log10 .

pub fn ln(&self) -> Self

Element-wise ln .

pub fn ln_1p(&self) -> Self

Element-wise ln_1p .

pub fn exp(&self) -> Self

Element-wise exp .

pub fn exp2(&self) -> Self

Element-wise exp2 .

pub fn exp_m1(&self) -> Self

Element-wise exp_m1 .

pub fn sqrt(&self) -> Self

Element-wise sqrt .

pub fn cbrt(&self) -> Self

Element-wise cbrt .

pub fn powf(&self, v: T) -> Self

Element-wise powf .

pub fn powi(&self, v: i32) -> Self

pub fn log(&self, v: T) -> Self

Element-wise log .

pub fn max(&self, v: T) -> Self

Element-wise max .

pub fn min(&self, v: T) -> Self

Element-wise min .

pub fn to_degrees(&self) -> Self

Element-wise to_degrees .

pub fn to_radians(&self) -> Self

Element-wise to_radians .

Trait Implementations

impl<T: Float, const M: usize, const N: usize> Add<Matrix<T, M, N>> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Float, const M: usize, const N: usize> Add<T> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, o: T) -> Self

Performs the + operation.

impl<T: Clone, const M: usize, const N: usize> Clone for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

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: Copy, const M: usize, const N: usize> Copy for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

impl<T: Debug, const M: usize, const N: usize> Debug for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

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

Formats the value using the given formatter.

impl<T: Float, const M: usize, const N: usize> Div<Matrix<T, M, N>> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Float, const M: usize, const N: usize> Div<T> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, o: T) -> Self

Performs the / operation.

impl<T: Eq, const M: usize, const N: usize> Eq for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

impl<T: Float, const M: usize, const N: usize> Index<usize> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Vector<T, M>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Float, const M: usize, const N: usize> IndexMut<usize> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

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

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

impl<T: Float, const M: usize, const N: usize> Mul<Matrix<T, M, N>> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Float, const M: usize, const N: usize> Mul<T> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, o: T) -> Self

Performs the * operation.

impl<T: Float, const M: usize> One for Matrix<T, M, M> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; M]: LengthAtMost32, 

Multiplicative identity

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

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

impl<T: PartialEq, const M: usize, const N: usize> PartialEq<Matrix<T, M, N>> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

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

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

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

This method tests for !=.

impl<T, const M: usize, const N: usize> StructuralEq for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

impl<T, const M: usize, const N: usize> StructuralPartialEq for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

impl<T: Float, const M: usize, const N: usize> Sub<Matrix<T, M, N>> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Float, const M: usize, const N: usize> Sub<T> for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, o: T) -> Self

Performs the - operation.

impl<T: Float, const M: usize, const N: usize> Zero for Matrix<T, M, N> where
    [T; M]: LengthAtMost32,
    [T; N]: LengthAtMost32,
    [Vector<T, M>; N]: LengthAtMost32, 

fn zero() -> Self

Returns the additive identity element of Self, 0. # Purity

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.