Struct MatrixPrecise 

pub struct MatrixPrecise<const R: usize, const C: usize> {
    pub data: [[r32; C]; R],
}

Precise Matrix Type using rational components - R rows, C columns, components are r32. Stored in row-major format, indexable by usize indices - row then column.

Fields

data: [[r32; C]; R]

2D Array of r32 data.

Implementations

impl<const R: usize, const C: usize> MatrixPrecise<R, C>

pub fn new(data: [[r32; C]; R]) -> Self

Returns a new Matrix with R rows and C columns from a correctly shaped array of r32.

pub fn num_rows() -> usize

Returns R, the number of rows in this Matrix Type (i.e. returns 3 for a Matrix<3, 4>).

pub fn col_len() -> usize

Returns R, the length of a column in this Matrix Type (i.e. returns 3 for a Matrix<3, 4>).

pub fn num_cols() -> usize

Returns C, the number of columns in this Matrix Type (i.e. returns 4 for a Matrix<3, 4>).

pub fn row_len() -> usize

Returns C, the length of a row in this Matrix Type (i.e. returns 4 for a Matrix<3, 4>).

pub fn row(&self, index: usize) -> VectorPrecise<C>

Returns a single row of the Matrix as a VectorPrecise, indexed by usize.

pub fn col(&self, index: usize) -> VectorPrecise<R>

Returns a single column of the Matrix as a VectorPrecise, indexed by usize.

pub fn multiply<const D: usize>( &self, other: MatrixPrecise<C, D>, ) -> MatrixPrecise<R, D>

Utility function for multiplying matrices - as per standard matrix multiplication, to multiply two matrices of dimensions (A, B) and (C, D), B must equal C. Used for implementing std::ops.

pub fn transpose(&self) -> MatrixPrecise<C, R>

pub fn change_dimensions<const R0: usize, const C0: usize>( &self, ) -> MatrixPrecise<R0, C0>

pub fn minor(&self, row: usize, col: usize) -> Option<MatrixPrecise<R, C>>

pub fn to_data_vec(&self) -> Vec<r32>

pub fn minor_vec( vec: &Vec<r32>, dim: (usize, usize), index: (usize, usize), ) -> Vec<r32>

impl<const L: usize> MatrixPrecise<L, L>

pub fn det(&self) -> Option<r32>

pub fn det_vec(vec: &Vec<r32>, dim: usize) -> Option<r32>

pub fn cofactor(&self) -> Option<MatrixPrecise<L, L>>

pub fn adjoint(&self) -> Option<MatrixPrecise<L, L>>

pub fn inverse(&self) -> Option<MatrixPrecise<L, L>>

pub fn cofactor_vec(vec: &Vec<r32>, dim: usize) -> Option<Vec<r32>>

pub fn lu(&self) -> Option<(Self, Self)>

LU decomposition - may not succeed, tries to triangulate into two triangular matrices, L and U.

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

LUP decomposition - may not succeed, tries to decompose into two triangular matrices L and U, with a permutation matrix P.

pub fn lup_det(&self) -> Option<r32>

Tries to calculate the determinant using LUP decomposition.

pub fn forward_sub(&self, target: VectorPrecise<L>) -> VectorPrecise<L>

Forward substitution - solves for Lx = b where L is a lower triangular matrix. Takes target vector b and calculates x, where the matrix is L.

pub fn back_sub(&self, target: VectorPrecise<L>) -> VectorPrecise<L>

Backward substitution - solves for Ux = b where U is an upper triangular matrix. Takes target vector b and calculates x, where the matrix is U.

pub fn lup_sub(&self, target: VectorPrecise<L>) -> Option<VectorPrecise<L>>

LUP substitution - uses LUP decomposition to solve for Ax = b, where A is the matrix calling this, b is the target vector provided as an argument, and x is returned - dependent on successful LUP decomposition.

pub fn lup_inverse(&self) -> Option<MatrixPrecise<L, L>>

Attempts to calculate an inverse matrix for this matrix using LUP substitution. This will fail if a LUP decomposition cannot be found for the matrix.

Trait Implementations

impl<const R: usize, const C: usize> Clone for MatrixPrecise<R, C>

fn clone(&self) -> MatrixPrecise<R, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const R: usize, const C: usize> Debug for MatrixPrecise<R, C>

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

Formats the value using the given formatter.

impl<const A: usize, const B: usize> Default for MatrixPrecise<A, B>

fn default() -> Self

Returns the “default value” for a type.

impl<const A: usize, const B: usize> Display for MatrixPrecise<A, B>

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

Formats the value using the given formatter.

impl<const R: usize, const C: usize> From<Matrix<R, C>> for MatrixPrecise<R, C>

fn from(v: Matrix<R, C>) -> Self

Converts to this type from the input type.

impl<const R: usize, const C: usize> From<MatrixPrecise<R, C>> for Matrix<R, C>

fn from(v: MatrixPrecise<R, C>) -> Self

Converts to this type from the input type.

impl<const R: usize, const C: usize> Hash for MatrixPrecise<R, C>

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<const A: usize> Identity for MatrixPrecise<A, A>

fn identity() -> Self

impl<const A: usize, const B: usize> Index<usize> for MatrixPrecise<A, B>

type Output = [r32; B]

The returned type after indexing.

fn index(&self, index: usize) -> &[r32; B]

Performs the indexing (container[index]) operation.

impl<const A: usize, const B: usize> IndexMut<usize> for MatrixPrecise<A, B>

fn index_mut(&mut self, index: usize) -> &mut [r32; B]

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

impl<const A: usize, const B: usize> Mul<MatrixPrecise<A, B>> for VectorPrecise<A>

type Output = VectorPrecise<B>

The resulting type after applying the * operator.

fn mul(self, other: MatrixPrecise<A, B>) -> VectorPrecise<B>

Performs the * operation.

impl<const A: usize, const B: usize> Mul<MatrixPrecise<A, B>> for r32

type Output = MatrixPrecise<A, B>

The resulting type after applying the * operator.

fn mul(self, other: MatrixPrecise<A, B>) -> MatrixPrecise<A, B>

Performs the * operation.

impl<const A: usize, const B: usize, const C: usize> Mul<MatrixPrecise<B, C>> for MatrixPrecise<A, B>

type Output = MatrixPrecise<A, C>

The resulting type after applying the * operator.

fn mul(self, other: MatrixPrecise<B, C>) -> MatrixPrecise<A, C>

Performs the * operation.

impl<const A: usize, const B: usize> Mul<VectorPrecise<B>> for MatrixPrecise<A, B>

type Output = VectorPrecise<A>

The resulting type after applying the * operator.

fn mul(self, other: VectorPrecise<B>) -> VectorPrecise<A>

Performs the * operation.

impl<const A: usize, const B: usize> Mul<r32> for MatrixPrecise<A, B>

type Output = MatrixPrecise<A, B>

The resulting type after applying the * operator.

fn mul(self, other: r32) -> MatrixPrecise<A, B>

Performs the * operation.

impl<const R: usize, const C: usize> PartialEq for MatrixPrecise<R, C>

fn eq(&self, other: &MatrixPrecise<R, C>) -> 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<const R: usize, const C: usize> Copy for MatrixPrecise<R, C>

impl<const R: usize, const C: usize> Eq for MatrixPrecise<R, C>

impl<const R: usize, const C: usize> StructuralPartialEq for MatrixPrecise<R, C>