Struct SpMat 

pub struct SpMat<R> { /* private fields */ }

Sparse matrix in compressed sparse column (CSC) format, backed by nalgebra_sparse::CscMatrix.

The fundamental matrix type for all differential maps in the homology pipeline. Generic over the element ring R; bounds are applied per-method.

Note: the underlying CSC may carry explicit zero entries (e.g. after an in-place subtraction). iter walks all stored triplets; iter_nz filters them.

Implementations

impl<R> SpMat<R>

pub fn try_from_csc_data( num_rows: usize, num_cols: usize, col_offsets: Vec<usize>, row_indices: Vec<usize>, values: Vec<R>, ) -> Option<Self>

pub fn csc_data(&self) -> (&[usize], &[usize], &[R])

pub fn disassemble(self) -> (Vec<usize>, Vec<usize>, Vec<R>)

pub fn zero(shape: (usize, usize)) -> Self

pub fn is_zero(&self) -> bool

where R: Zero,

pub fn id(n: usize) -> Self

where R: Scalar + One,

pub fn is_id(&self) -> bool

where R: Scalar + One + Zero,

pub fn is_triang(&self, t: TriangularType) -> bool

where R: Zero,

pub fn iter(&self) -> impl Iterator<Item = (usize, usize, &R)>

Iterates the stored (row, col, value) triplets — may include explicit zeros.

pub fn iter_nz(&self) -> impl Iterator<Item = (usize, usize, &R)>

where R: Zero,

iter, filtered to non-zero values.

pub fn into_dense(self) -> Mat<R>

where R: Scalar + Zero + ClosedAddAssign,

pub fn nnz(&self) -> usize

pub fn density(&self) -> f64

pub fn redundancy(&self) -> f64

where R: Zero,

pub fn mean_weight(&self) -> f64

where R: Ring, for<'x> &'x R: RingOps<R>,

pub fn block_diag<I>(blocks: I) -> SpMat<R>

where I: IntoIterator<Item = SpMat<R>>,

pub fn map<F, S>(self, f: F) -> SpMat<S>

where F: Fn(R) -> S,

impl<R> SpMat<R>

where R: Scalar + Clone + Zero + ClosedAddAssign,

pub fn from_entries<T>(shape: (usize, usize), entries: T) -> Self

where T: IntoIterator<Item = (usize, usize, R)>,

Builds an SpMat of shape from (row, col, value) triplets. Zero values are skipped; duplicates at the same position are summed.

pub fn from_col_vecs<I>(nrows: usize, vecs: I) -> Self

where I: IntoIterator<Item = SpVec<R>>,

pub fn from_row_major<I>(shape: (usize, usize), data: I) -> Self

where I: IntoIterator<Item = R>,

pub fn scalar(n: usize, a: &R) -> Self

pub fn diag<I>(shape: (usize, usize), entries: I) -> Self

where I: IntoIterator<Item = R>,

pub fn is_diag(&self) -> bool

pub fn col_vec(&self, j: usize) -> SpVec<R>

where R: Scalar + Zero + ClosedAddAssign,

pub fn transpose(&self) -> Self

pub fn extract<F>(&self, shape: (usize, usize), f: F) -> SpMat<R>

where F: Fn(usize, usize) -> Option<(usize, usize)>,

New shape-d matrix whose entry at f(i, j) (if Some) is self[(i, j)]. Entries where f returns None are dropped.

pub fn permute(&self, p: &Perm, q: &Perm) -> SpMat<R>

pub fn permute_rows(&self, p: &Perm) -> SpMat<R>

pub fn permute_cols(&self, q: &Perm) -> SpMat<R>

pub fn permute_and_split(&self, p: &Perm, q: &Perm, r: usize) -> [SpMat<R>; 4]

Applies the permutations (p, q) to self and partitions the result into four blocks at row/col r:

  paq = [[a0 | a1],   a0: r×r,     a1: r×(n-r)
         [a2 | a3]]   a2: (m-r)×r, a3: (m-r)×(n-r)

pub fn submat(&self, rows: Range<usize>, cols: Range<usize>) -> SpMat<R>

pub fn submat_rows(&self, rows: Range<usize>) -> SpMat<R>

pub fn submat_cols(&self, cols: Range<usize>) -> SpMat<R>

pub fn block_split(self, point: (usize, usize)) -> [SpMat<R>; 4]

pub fn h_split(self, k: usize) -> [SpMat<R>; 2]

pub fn v_split(self, k: usize) -> [SpMat<R>; 2]

pub fn block_combine(blocks: [SpMat<R>; 4]) -> SpMat<R>

pub fn h_stack(left: Self, right: Self) -> Self

pub fn v_stack(top: Self, bot: Self) -> Self

pub fn extend_by_zero(&mut self, add_rows: usize, add_cols: usize)

pub fn row_perm_mat(p: &Perm) -> Self

where R: One,

pub fn col_perm_mat(p: &Perm) -> Self

where R: One,

Trait Implementations

impl<R> Add for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> Add<&SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the + operator.

fn add(self, rhs: &SpMat<R>) -> Self::Output

Performs the + operation.

impl<R> Add<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the + operator.

fn add(self, rhs: &SpMat<R>) -> Self::Output

Performs the + operation.

impl<R> Add<SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R> AddAssign for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn add_assign(&mut self, rhs: SpMat<R>)

Performs the += operation.

impl<R> AddAssign<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn add_assign(&mut self, rhs: &SpMat<R>)

Performs the += operation.

impl<R: Clone> Clone for SpMat<R>

fn clone(&self) -> SpMat<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for SpMat<R>

where R: Display + Debug,

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

Formats the value using the given formatter.

impl<R> Default for SpMat<R>

fn default() -> Self

Returns the “default value” for a type.

impl<R> Display for SpMat<R>

where R: Display + Debug,

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

Formats the value using the given formatter.

impl<R: Eq + Zero> Eq for SpMat<R>

impl<R> From<CscMatrix<R>> for SpMat<R>

fn from(inner: CscMatrix<R>) -> Self

Converts to this type from the input type.

impl<R> From<Mat<R>> for SpMat<R>

where R: Scalar + Zero,

fn from(value: Mat<R>) -> Self

Converts to this type from the input type.

impl<R> From<SpMat<R>> for Mat<R>

where R: Scalar + Zero + ClosedAddAssign,

fn from(value: SpMat<R>) -> Self

Converts to this type from the input type.

impl<R> From<SpMat<R>> for SpPluq<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

Converts a into the trivial PLUQ whose Schur complement is a itself

fn from(a: SpMat<R>) -> Self

Converts to this type from the input type.

impl<R> From<SpVec<R>> for SpMat<R>

fn from(vec: SpVec<R>) -> Self

Converts to this type from the input type.

impl<R> MatTrait for SpMat<R>

fn shape(&self) -> (usize, usize)

fn n_rows(&self) -> usize

fn n_cols(&self) -> usize

fn is_square(&self) -> bool

impl<R> Mul for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R> Mul<&SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpMat<R>) -> Self::Output

Performs the * operation.

impl<R> Mul<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpMat<R>) -> Self::Output

Performs the * operation.

impl<R> Mul<&SpVec<R>> for SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpVec<R>) -> Self::Output

Performs the * operation.

impl<R> Mul<&SpVec<R>> for &SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

fn mul(self, rhs: &SpVec<R>) -> Self::Output

Performs the * operation.

impl<R> Mul<SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R> Mul<SpVec<R>> for SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R> Mul<SpVec<R>> for &SpMat<R>

where R: Ring, for<'x> &'x R: RingOps<R>,

type Output = SpVec<R>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R> MulAssign for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn mul_assign(&mut self, rhs: SpMat<R>)

Performs the *= operation.

impl<R> MulAssign<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn mul_assign(&mut self, rhs: &SpMat<R>)

Performs the *= operation.

impl<R> Neg for SpMat<R>

where R: Scalar + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R> Neg for &SpMat<R>

where R: Scalar + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<R: PartialEq + Zero> PartialEq for SpMat<R>

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

Equality operator ==.

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

Inequality operator !=.

impl<R> Sub for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> Sub<&SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

fn sub(self, rhs: &SpMat<R>) -> Self::Output

Performs the - operation.

impl<R> Sub<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

fn sub(self, rhs: &SpMat<R>) -> Self::Output

Performs the - operation.

impl<R> Sub<SpMat<R>> for &SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

type Output = SpMat<R>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R> SubAssign for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn sub_assign(&mut self, rhs: SpMat<R>)

Performs the -= operation.

impl<R> SubAssign<&SpMat<R>> for SpMat<R>

where R: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign + Zero + One + Neg<Output = R>,

fn sub_assign(&mut self, rhs: &SpMat<R>)

Performs the -= operation.