Struct Matrix

pub struct Matrix<T: Real> {
    pub nrows: usize,
    pub ncols: usize,
    pub data: Vec<T>,
    pub storage: MatrixStorage<T>,
}

Generic matrix for linear algebra (typically square in current use).

Fields

nrows: usize

ncols: usize

data: Vec<T>

storage: MatrixStorage<T>

Implementations

impl<T: Real> Matrix<T>

pub fn component_add(self, rhs: T) -> Self

Return a new matrix where each stored entry has rhs added. Off-band for banded becomes dense if rhs != 0.

impl<T: Real> Matrix<T>

pub fn identity(n: usize) -> Self

Identity matrix of size n x n.

pub fn full(n: usize, data: Vec<T>) -> Self

Full matrix from a row-major vector of length n*n.

pub fn zeros(n: usize) -> Self

Zero matrix of size n x n.

pub fn banded(n: usize, ml: usize, mu: usize) -> Self

Zero banded matrix with the given bandwidths. For entry (i,j) within the band, index maps to data[i - j + mu, j].

pub fn diagonal(diag: Vec<T>) -> Self

Diagonal matrix from the provided diagonal entries (ml=mu=0).

pub fn lower_triangular(n: usize) -> Self

Zero lower-triangular matrix (ml = n-1, mu = 0).

pub fn upper_triangular(n: usize) -> Self

Zero upper-triangular matrix (ml = 0, mu = n-1).

pub fn dims(&self) -> (usize, usize)

Dimensions (nrows, ncols).

pub fn n(&self) -> usize

Convenience: n for an n x n matrix.

impl<T: Real> Matrix<T>

pub fn lin_solve<V>(&self, b: V) -> V

where V: State<T>,

Solve A x = b (returns same State<T> type as b). Densifies A as needed.

pub fn lin_solve_mut(&self, b: &mut [T])

In-place solve: overwrites b with x.

impl<T: Real> Matrix<T>

pub fn component_mul(self, rhs: T) -> Self

Return a new matrix where each stored entry is multiplied by rhs.

pub fn component_mul_mut(&mut self, rhs: T)

In-place component-wise scalar multiplication: self[i,j] *= rhs for all stored entries. For Identity, converts to a diagonal banded matrix with rhs on the diagonal.

pub fn mul_state<V: State<T>>(&self, vec: &V) -> V

impl<T: Real> Matrix<T>

pub fn component_sub(self, rhs: T) -> Self

Return a new matrix where each stored entry has rhs subtracted. Off-band handling similar to add.

Trait Implementations

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

type Output = Matrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Real> AddAssign for Matrix<T>

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

Performs the += operation.

impl<T: Clone + Real> 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 + Real> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<T> Display for Matrix<T>

where T: Real + Display,

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

Formats the value using the given formatter.

impl<T: Real> Index<(usize, usize)> for Matrix<T>

2D indexing by (i, j), read-only.

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T: Real> IndexMut<(usize, usize)> for Matrix<T>

2D indexing by (i, j), mutable (where supported).

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

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

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

type Output = Matrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Real> SubAssign<&Matrix<T>> for Matrix<T>

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

Performs the -= operation.

impl<T: Real> SubAssign for Matrix<T>

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

Performs the -= operation.