Struct Matrix 

pub struct Matrix<V: Vector, const N: usize>(/* private fields */);

A matrix, interpreted as the (1, 1) tensor V ⊗ V*. N must be equal to V::N. This is enforced by all constructors at compile time. This is due to limitations in Rust’s const generics.

Implementations

impl<F: Field, V: Vector<F = F>, const N: usize> Matrix<V, N>

pub fn new(m: [[F; N]; N]) -> Self

Wraps a raw N×N array as a matrix, checking V::N == N at compile time. The const assertion is the crate’s stand-in for Matrix<V, {V::N}>, which stable const generics can’t express — it guarantees the matrix’s dimension matches the space it acts on.

pub fn mul(&self, rhs: &Self) -> Self

The contraction (V ⊗ V*) ⊗ (V ⊗ V*) -> (V ⊗ V*)

pub fn mul_v(&self, v: &V) -> V

The contraction (V ⊗ V*) ⊗ V -> V

pub fn mul_dual_v(&self, v: &Dual<V>) -> Dual<V>

The contraction V* ⊗ (V ⊗ V*) -> V*

pub fn transpose(self) -> Matrix<Dual<V>, N>

The transpose V ⊗ V* -> V* ⊗ V** ≅ V* ⊗ V

pub fn flat_iter<'a>(&'a self) -> impl Iterator<Item = &'a F>

where F: 'a,

Iterates all N² entries in row-major order.

pub fn trace(&self) -> F

The trace Σᵢ Mᵢᵢ — the contraction V ⊗ V* -> F.

pub fn destructure<const M: usize>(&self) -> [[F; M]; M]

Extracts the raw entry array, checking N == M at compile time. Escape hatch back to a plain [[F; M]; M] for callers that need the components directly.

pub fn solve(&self, rhs: Self) -> Self

Solves A * X = B by Gauss–Jordan elimination.

Assumes A is invertible.

pub fn inverse(&self) -> Self

Inverts the matrix by Gauss–Jordan elimination.

Assumes invertibility: it panic!s on a zero pivot (a singular matrix). For an Sl element that panic is unreachable — determinant one is never singular — so this is a total operation on the special linear group, which is where it’s used.

impl<F: Field + Metric, V: Vector<F = F>, const N: usize> Matrix<V, N>

pub fn frobenius_norm(&self) -> F::R

The Frobenius norm √(Σᵢⱼ |Mᵢⱼ|²), valued in the real field F::R.

Requires F: Metric so each entry has a definite squared magnitude (interval_squared against zero), keeping the sum a non-negative real. This is the norm the MatrixExponential Taylor series measures convergence against; it is submultiplicative, which is what makes that series converge.

pub fn one_norm(&self) -> F::R

pub fn solve_pivoted(&self, rhs: Self) -> Self

Solves A * X = B using Gauss–Jordan elimination with partial pivoting.

Pivot rows are chosen by maximizing the scalar metric magnitude. This improves numerical stability for approximate fields.

Assumes A is invertible.

pub fn inverse_pivoted(&self) -> Self

impl<F: CField + Metric, V: Vector<F = F>, const N: usize> Matrix<V, N>

pub fn det(&self) -> F

Trait Implementations

impl<F: Field, V: Vector<F = F>, const N: usize> Add for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<V: Clone + Vector, const N: usize> Clone for Matrix<V, N>

where V::F: Clone,

fn clone(&self) -> Matrix<V, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Copy + Vector, const N: usize> Copy for Matrix<V, N>

where V::F: Copy,

impl<V: Debug + Vector, const N: usize> Debug for Matrix<V, N>

where V::F: Debug,

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

Formats the value using the given formatter.

impl<F: Field, V: Vector<F = F>, const N: usize> Div<F> for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V: Vector, const N: usize> Index<(usize, usize)> for Matrix<V, N>

type Output = <V as Vector>::F

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<V: Vector, const N: usize> IndexMut<(usize, usize)> for Matrix<V, N>

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

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

impl<const N: usize, F: Field<Characteristic = NatZero> + Metric + FromReal + FieldExp, V: Vector<F = F>> MatrixExponential for Matrix<V, N>

fn exp(&self) -> Self

fn log(&self) -> Option<Self>

impl<F: Field, V: Vector<F = F>, const N: usize> Mul for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field, V: Vector<F = F>, const N: usize> Mul<F> for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field, V: Vector<F = F>, const N: usize> Neg for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: Field, V: Vector<F = F>, const N: usize> One for Matrix<V, N>

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,

Returns true if self is equal to the multiplicative identity.

impl<V: Vector, const N: usize> PartialEq for Matrix<V, N>

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<F: Field, V: Vector<F = F>, const N: usize> Sub for Matrix<V, N>

type Output = Matrix<V, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<F: Field, V: Vector<F = F>, const N: usize> Zero for Matrix<V, N>

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.