Struct Matrix 

pub struct Matrix<T> { /* private fields */ }

A dense rows × cols matrix stored row-major.

Implementations

impl<T> Matrix<T>

pub fn new(rows: usize, cols: usize, data: Vec<T>) -> Matrix<T>

Builds a rows × cols matrix from row-major data. Panics on a length mismatch.

pub fn from_rows(rows: Vec<Vec<T>>) -> Matrix<T>

Builds a matrix from a list of rows. Panics if the rows differ in length.

pub fn rows(&self) -> usize

Returns the number of rows.

pub fn cols(&self) -> usize

Returns the number of columns.

pub fn is_square(&self) -> bool

Returns true if the matrix is square.

pub fn get(&self, row: usize, col: usize) -> &T

Returns the entry at (row, col).

pub fn set(&mut self, row: usize, col: usize, value: T)

Sets the entry at (row, col).

pub fn as_slice(&self) -> &[T]

Returns the entries in row-major order.

impl<T: Clone> Matrix<T>

pub fn filled(value: T, rows: usize, cols: usize) -> Matrix<T>

Builds a rows × cols matrix with every entry a clone of value.

This is the context-carrying constructor: unlike zeros (which needs a context-free Default), it works for rings whose zero depends on a runtime context (ModInt, GfElement) — pass their Ring::zero.

pub fn transpose(&self) -> Matrix<T>

Returns the transpose.

impl<T: Clone + Default> Matrix<T>

pub fn zeros(rows: usize, cols: usize) -> Matrix<T>

Builds a rows × cols zero matrix.

impl<T: Ring> Matrix<T>

pub fn zeros_like(sample: &T, rows: usize, cols: usize) -> Matrix<T>

Builds a rows × cols zero matrix, taking the ring’s zero from sample.

The context-carrying counterpart of zeros: use it for component rings whose zero depends on a runtime context (ModInt, GfElement).

pub fn identity_like(sample: &T, n: usize) -> Matrix<T>

Builds the n × n identity, taking the ring’s zero/one from sample.

The context-carrying counterpart of the concrete Matrix::<Int>::identity / Matrix::<Rational>::identity.

impl<T: Ring> Matrix<T>

pub fn add(&self, rhs: &Matrix<T>) -> Matrix<T>

Returns self + rhs. Panics on a shape mismatch.

pub fn sub(&self, rhs: &Matrix<T>) -> Matrix<T>

Returns self - rhs. Panics on a shape mismatch.

pub fn mul(&self, rhs: &Matrix<T>) -> Matrix<T>

Returns the matrix product self · rhs. Panics if the inner dimensions disagree.

For component rings whose arithmetic is exact and associative (Ring::REASSOCIATIVE) the product is computed by the recursive Strassen–Winograd algorithm above a size threshold (7 recursive block products instead of 8), falling back to the naive triple loop below the threshold and for small or awkward shapes. The visible result is always bit-identical to the naive product.

pub fn scalar_mul(&self, scalar: &T) -> Matrix<T>

Returns self · scalar.

impl<T: Ring> Matrix<T>

pub fn neg(&self) -> Matrix<T>

Returns -self.

impl Matrix<Int>

pub fn identity(n: usize) -> Matrix<Int>

Returns the n × n integer identity matrix.

pub fn determinant(&self) -> Int

Returns the exact determinant via the fraction-free Bareiss algorithm. Panics if the matrix is not square.

impl Matrix<Rational>

pub fn identity(n: usize) -> Matrix<Rational>

Returns the n × n rational identity matrix.

pub fn determinant(&self) -> Rational

Returns the exact determinant. Panics if the matrix is not square.

pub fn rank(&self) -> usize

Returns the rank (number of linearly independent rows).

pub fn inverse(&self) -> Option<Matrix<Rational>>

Returns the inverse, or None if the matrix is singular. Panics if not square.

pub fn solve(&self, b: &[Rational]) -> Option<Vec<Rational>>

Solves self · x = b, returning x, or None if there is no unique solution. Panics if self is not square or b has the wrong length.

impl Matrix<Rational>

Exact eigenvalues of a rational matrix, as real algebraic numbers.

These methods compose the two exact building blocks the crate already provides: the division-free RingMatrix::charpoly (Samuelson–Berkowitz) gives the monic characteristic polynomial det(x·I − A) over ℚ, and Algebraic::real_roots_of isolates its real roots exactly (Sturm sequences + bisection). Every returned eigenvalue is therefore an exact Algebraic — compared and combined by its true real value, never a float approximation.

Real eigenvalues only

Algebraic models real algebraic numbers, so only the real eigenvalues are returned; non-real (complex-conjugate) eigenvalues are silently omitted. A matrix whose spectrum is entirely complex (e.g. the rotation [[0,−1],[1,0]], eigenvalues ±i) yields an empty list without error.

Cost

The characteristic polynomial costs O(n⁴) rational multiplications (Samuelson–Berkowitz), and real-root isolation runs Sturm sequences and polynomial GCDs by the subresultant PRS on the degree-n char poly. Both are exact but grow quickly with n; this is intended for modest matrix sizes.

pub fn characteristic_polynomial(&self) -> Poly<Rational>

Returns the characteristic polynomial det(x·I − A) over ℚ, monic and in low-to-high coefficient order (coeffs()[i] is the coefficient of xⁱ).

Computed division-free via RingMatrix::charpoly. Panics if the matrix is not square (or is 0×0, which has no ring context).

pub fn real_eigenvalues(&self) -> Vec<Algebraic>

Returns the distinct real eigenvalues as exact algebraic numbers, in increasing order.

Non-real (complex) eigenvalues are not returned — see the type-level note. A repeated eigenvalue appears once; use real_eigenvalues_with_multiplicity for algebraic multiplicities.

Panics if the matrix is not square (or is 0×0).

pub fn real_eigenvalues_with_multiplicity(&self) -> Vec<(Algebraic, usize)>

Returns the distinct real eigenvalues paired with their algebraic multiplicity (their multiplicity as roots of the characteristic polynomial), in increasing order of eigenvalue.

The multiplicities come from a squarefree decomposition of the char poly (Yun’s algorithm — repeated GCDs with the derivative): the roots of the multiplicity-k squarefree factor are exactly the eigenvalues of algebraic multiplicity k. Non-real eigenvalues are omitted, so the returned multiplicities need not sum to n.

Panics if the matrix is not square (or is 0×0).

Trait Implementations

impl<T: Ring> Add for Matrix<T>

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<T: Ring> Add<&Matrix<T>> for &Matrix<T>

type Output = Matrix<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Matrix<T>) -> Matrix<T>

Performs the + operation.

impl<T: Clone> Clone for Matrix<T>

fn clone(&self) -> Matrix<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Matrix<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Matrix<T>

impl<T: Field> FieldMatrix<T> for Matrix<T>

fn determinant(&self) -> T

The determinant, computed as (∏ pivots) · (−1)^{#row swaps} after forward elimination to upper-triangular form. A wholly-zero pivot column means the matrix is singular, so the determinant is the field’s zero. Panics if the matrix is not square (or is 0 × 0, which has no sample element from which to take the ring’s one).

fn inverse(&self) -> Option<Matrix<T>>

The inverse via Gauss–Jordan elimination on the augmented [A | I], or None if A is singular. Panics if the matrix is not square.

fn solve(&self, b: &[T]) -> Option<Vec<T>>

Solves self · x = b, returning x, or None when there is no unique solution (a zero pivot column ⇒ singular). Panics if self is not square or b has the wrong length.

fn rank(&self) -> usize

The rank: the number of nonzero pivots produced by row-reducing to row echelon form (works for any shape).

impl<T: Hash> Hash for Matrix<T>

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<T: Ring> Mul for Matrix<T>

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<T: Ring> Mul<&Matrix<T>> for &Matrix<T>

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Matrix<T>) -> Matrix<T>

Performs the * operation.

impl<T: PartialEq> PartialEq for Matrix<T>

fn eq(&self, other: &Matrix<T>) -> 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<T: Ring> RingMatrix<T> for Matrix<T>

fn charpoly(&self) -> Vec<T>

The characteristic polynomial det(x·I − self) as coefficients from the constant term up: charpoly()[i] is the coefficient of xⁱ, so charpoly()[0] is (−1)ⁿ·det and the leading coefficient is one.

fn det(&self) -> T

The determinant of self, computed division-free.

impl<T: PartialEq> StructuralPartialEq for Matrix<T>

impl<T: Ring> Sub for Matrix<T>

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<T>) -> Matrix<T>

Performs the - operation.

impl<T: Ring> Sub<&Matrix<T>> for &Matrix<T>

type Output = Matrix<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Matrix<T>) -> Matrix<T>

Performs the - operation.