Struct nalgebra_sparse::csc::CscMatrix

pub struct CscMatrix<T> { /* fields omitted */ }

A CSC representation of a sparse matrix.

The Compressed Sparse Column (CSC) format is well-suited as a general-purpose storage format for many sparse matrix applications.

Usage

use nalgebra_sparse::csc::CscMatrix;
use nalgebra::{DMatrix, Matrix3x4};
use matrixcompare::assert_matrix_eq;

// The sparsity patterns of CSC matrices are immutable. This means that you cannot dynamically
// change the sparsity pattern of the matrix after it has been constructed. The easiest
// way to construct a CSC matrix is to first incrementally construct a COO matrix,
// and then convert it to CSC.
let csc = CscMatrix::from(&coo);

// Alternatively, a CSC matrix can be constructed directly from raw CSC data.
// Here, we construct a 3x4 matrix
let col_offsets = vec![0, 1, 3, 4, 5];
let row_indices = vec![0, 0, 2, 2, 0];
let values = vec![1.0, 2.0, 3.0, 4.0, 5.0];

// The dense representation of the CSC data, for comparison
let dense = Matrix3x4::new(1.0, 2.0, 0.0, 5.0,
                           0.0, 0.0, 0.0, 0.0,
                           0.0, 3.0, 4.0, 0.0);

// The constructor validates the raw CSC data and returns an error if it is invalid.
let csc = CscMatrix::try_from_csc_data(3, 4, col_offsets, row_indices, values)
    .expect("CSC data must conform to format specifications");
assert_matrix_eq!(csc, dense);

// A third approach is to construct a CSC matrix from a pattern and values. Sometimes this is
// useful if the sparsity pattern is constructed separately from the values of the matrix.
let (pattern, values) = csc.into_pattern_and_values();
let csc = CscMatrix::try_from_pattern_and_values(pattern, values)
    .expect("The pattern and values must be compatible");

// Once we have constructed our matrix, we can use it for arithmetic operations together with
// other CSC matrices and dense matrices/vectors.
let x = csc;
let xTx = x.transpose() * &x;
let z = DMatrix::from_fn(4, 8, |i, j| (i as f64) * (j as f64));
let w = 3.0 * xTx * z;

// Although the sparsity pattern of a CSC matrix cannot be changed, its values can.
// Here are two different ways to scale all values by a constant:
let mut x = x;
x *= 5.0;
x.values_mut().iter_mut().for_each(|x_i| *x_i *= 5.0);

Format

An m x n sparse matrix with nnz non-zeros in CSC format is represented by the following three arrays:

• col_offsets, an array of integers with length n + 1.
• row_indices, an array of integers with length nnz.
• values, an array of values with length nnz.

The relationship between the arrays is described below.

• Each consecutive pair of entries col_offsets[j] .. col_offsets[j + 1] corresponds to an offset range in row_indices that holds the row indices in column j.
• For an entry represented by the index idx, row_indices[idx] stores its column index and values[idx] stores its value.

The following invariants must be upheld and are enforced by the data structure:

• col_offsets[0] == 0
• col_offsets[m] == nnz
• col_offsets is monotonically increasing.
• 0 <= row_indices[idx] < m for all idx < nnz.
• The row indices associated with each column are monotonically increasing (see below).

The CSC format is a standard sparse matrix format (see Wikipedia article). The format represents the matrix in a column-by-column fashion. The entries associated with column j are determined as follows:

let range = col_offsets[j] .. col_offsets[j + 1];
let col_j_rows = &row_indices[range.clone()];
let col_j_vals = &values[range];

// For each pair (i, v) in (col_j_rows, col_j_vals), we obtain a corresponding entry
// (i, j, v) in the matrix.
assert_eq!(col_j_rows.len(), col_j_vals.len());

In the above example, for each column j, the row indices col_j_cols must appear in monotonically increasing order. In other words, they must be sorted. This criterion is not standard among all sparse matrix libraries, but we enforce this property as it is a crucial assumption for both correctness and performance for many algorithms.

Note that the CSR and CSC formats are essentially identical, except that CSC stores the matrix column-by-column instead of row-by-row like CSR.

Implementations

impl<T> CscMatrix<T>

pub fn identity(n: usize) -> Self where
    T: Scalar + One, 

Constructs a CSC representation of the (square) n x n identity matrix.

pub fn zeros(nrows: usize, ncols: usize) -> Self

Create a zero CSC matrix with no explicitly stored entries.

pub fn try_from_csc_data(
    num_rows: usize,
    num_cols: usize,
    col_offsets: Vec<usize>,
    row_indices: Vec<usize>,
    values: Vec<T>
) -> Result<Self, SparseFormatError>

Try to construct a CSC matrix from raw CSC data.

It is assumed that each column contains unique and sorted row indices that are in bounds with respect to the number of rows in the matrix. If this is not the case, an error is returned to indicate the failure.

An error is returned if the data given does not conform to the CSC storage format. See the documentation for CscMatrix for more information.

pub fn try_from_pattern_and_values(
    pattern: SparsityPattern,
    values: Vec<T>
) -> Result<Self, SparseFormatError>

Try to construct a CSC matrix from a sparsity pattern and associated non-zero values.

Returns an error if the number of values does not match the number of minor indices in the pattern.

pub fn nrows(&self) -> usize

The number of rows in the matrix.

pub fn ncols(&self) -> usize

The number of columns in the matrix.

pub fn nnz(&self) -> usize

The number of non-zeros in the matrix.

Note that this corresponds to the number of explicitly stored entries, not the actual number of algebraically zero entries in the matrix. Explicitly stored entries can still be zero. Corresponds to the number of entries in the sparsity pattern.

pub fn col_offsets(&self) -> &[usize]

The column offsets defining part of the CSC format.

pub fn row_indices(&self) -> &[usize]

The row indices defining part of the CSC format.

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

The non-zero values defining part of the CSC format.

pub fn values_mut(&mut self) -> &mut [T]

Mutable access to the non-zero values.

pub fn triplet_iter(&self) -> CscTripletIter<'_, T>

An iterator over non-zero triplets (i, j, v).

The iteration happens in column-major fashion, meaning that j increases monotonically, and i increases monotonically within each row.

Examples

let col_offsets = vec![0, 2, 3, 4];
let row_indices = vec![0, 2, 1, 0];
let values = vec![1, 3, 2, 4];
let mut csc = CscMatrix::try_from_csc_data(4, 3, col_offsets, row_indices, values)
    .unwrap();

let triplets: Vec<_> = csc.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect();
assert_eq!(triplets, vec![(0, 0, 1), (2, 0, 3), (1, 1, 2), (0, 2, 4)]);

pub fn triplet_iter_mut(&mut self) -> CscTripletIterMut<'_, T>

A mutable iterator over non-zero triplets (i, j, v).

Iteration happens in the same order as for triplet_iter.

Examples

let col_offsets = vec![0, 2, 3, 4];
let row_indices = vec![0, 2, 1, 0];
let values = vec![1, 3, 2, 4];
// Using the same data as in the `triplet_iter` example
let mut csc = CscMatrix::try_from_csc_data(4, 3, col_offsets, row_indices, values)
    .unwrap();

// Zero out lower-triangular terms
csc.triplet_iter_mut()
   .filter(|(i, j, _)| j < i)
   .for_each(|(_, _, v)| *v = 0);

let triplets: Vec<_> = csc.triplet_iter().map(|(i, j, v)| (i, j, *v)).collect();
assert_eq!(triplets, vec![(0, 0, 1), (2, 0, 0), (1, 1, 2), (0, 2, 4)]);

pub fn col(&self, index: usize) -> CscCol<'_, T>

Return the column at the given column index.

Panics

Panics if column index is out of bounds.

pub fn col_mut(&mut self, index: usize) -> CscColMut<'_, T>

Mutable column access for the given column index.

Panics

Panics if column index is out of bounds.

pub fn get_col(&self, index: usize) -> Option<CscCol<'_, T>>

Return the column at the given column index, or None if out of bounds.

pub fn get_col_mut(&mut self, index: usize) -> Option<CscColMut<'_, T>>

Mutable column access for the given column index, or None if out of bounds.

pub fn col_iter(&self) -> CscColIter<'_, T>

An iterator over columns in the matrix.

pub fn col_iter_mut(&mut self) -> CscColIterMut<'_, T>

A mutable iterator over columns in the matrix.

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

Disassembles the CSC matrix into its underlying offset, index and value arrays.

If the matrix contains the sole reference to the sparsity pattern, then the data is returned as-is. Otherwise, the sparsity pattern is cloned.

Examples

let col_offsets = vec![0, 2, 3, 4];
let row_indices = vec![0, 2, 1, 0];
let values = vec![1, 3, 2, 4];
let mut csc = CscMatrix::try_from_csc_data(
    4,
    3,
    col_offsets.clone(),
    row_indices.clone(),
    values.clone())
    .unwrap();
let (col_offsets2, row_indices2, values2) = csc.disassemble();
assert_eq!(col_offsets2, col_offsets);
assert_eq!(row_indices2, row_indices);
assert_eq!(values2, values);

pub fn into_pattern_and_values(self) -> (SparsityPattern, Vec<T>)

Returns the sparsity pattern and values associated with this matrix.

pub fn pattern_and_values_mut(&mut self) -> (&SparsityPattern, &mut [T])

Returns a reference to the sparsity pattern and a mutable reference to the values.

pub fn pattern(&self) -> &SparsityPattern

Returns a reference to the underlying sparsity pattern.

pub fn transpose_as_csr(self) -> CsrMatrix<T>

Reinterprets the CSC matrix as its transpose represented by a CSR matrix.

This operation does not touch the CSC data, and is effectively a no-op.

pub fn get_entry(
    &self,
    row_index: usize,
    col_index: usize
) -> Option<SparseEntry<'_, T>>

Returns an entry for the given row/col indices, or None if the indices are out of bounds.

Each call to this function incurs the cost of a binary search among the explicitly stored row entries for the given column.

pub fn get_entry_mut(
    &mut self,
    row_index: usize,
    col_index: usize
) -> Option<SparseEntryMut<'_, T>>

Returns a mutable entry for the given row/col indices, or None if the indices are out of bounds.

Each call to this function incurs the cost of a binary search among the explicitly stored row entries for the given column.

pub fn index_entry(
    &self,
    row_index: usize,
    col_index: usize
) -> SparseEntry<'_, T>

Returns an entry for the given row/col indices.

Same as get_entry, except that it directly panics upon encountering row/col indices out of bounds.

Panics

Panics if row_index or col_index is out of bounds.

pub fn index_entry_mut(
    &mut self,
    row_index: usize,
    col_index: usize
) -> SparseEntryMut<'_, T>

Returns a mutable entry for the given row/col indices.

Same as get_entry_mut, except that it directly panics upon encountering row/col indices out of bounds.

Panics

Panics if row_index or col_index is out of bounds.

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

Returns a triplet of slices (row_offsets, col_indices, values) that make up the CSC data.

pub fn csc_data_mut(&mut self) -> (&[usize], &[usize], &mut [T])

Returns a triplet of slices (row_offsets, col_indices, values) that make up the CSC data, where the values array is mutable.

pub fn filter<P>(&self, predicate: P) -> Self where
    T: Clone,
    P: Fn(usize, usize, &T) -> bool, 

Creates a sparse matrix that contains only the explicit entries decided by the given predicate.

pub fn upper_triangle(&self) -> Self where
    T: Clone, 

Returns a new matrix representing the upper triangular part of this matrix.

The result includes the diagonal of the matrix.

pub fn lower_triangle(&self) -> Self where
    T: Clone, 

Returns a new matrix representing the lower triangular part of this matrix.

The result includes the diagonal of the matrix.

pub fn diagonal_as_csc(&self) -> Self where
    T: Clone, 

Returns the diagonal of the matrix as a sparse matrix.

pub fn transpose(&self) -> CscMatrix<T> where
    T: Scalar, 

Compute the transpose of the matrix.

Trait Implementations

impl<'a, T> Add<&'a CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the + operator.

fn add(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the + operation.

impl<'a, T> Add<&'a CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the + operator.

fn add(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the + operation.

impl<'a, T> Add<CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the + operator.

fn add(self, b: CscMatrix<T>) -> Self::Output

Performs the + operation.

impl<T> Add<CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the + operator.

fn add(self, b: CscMatrix<T>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for CscMatrix<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CscMatrix<T>

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

Formats the value using the given formatter.

impl<'a, T> Div<&'_ T> for CscMatrix<T> where
    T: ClosedDiv + Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: &T) -> Self::Output

Performs the / operation.

impl<'a, T> Div<&'a T> for &'a CscMatrix<T> where
    T: ClosedDiv + Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: &'a T) -> Self::Output

Performs the / operation.

impl<T> Div<T> for CscMatrix<T> where
    T: ClosedDiv + Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: T) -> Self::Output

Performs the / operation.

impl<'a, T> Div<T> for &'a CscMatrix<T> where
    T: ClosedDiv + Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: T) -> Self::Output

Performs the / operation.

impl<'a, T> DivAssign<&'a T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedMul + ClosedDiv + Zero + One, 

fn div_assign(&mut self, scalar: &'a T)

Performs the /= operation.

impl<T> DivAssign<T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedMul + ClosedDiv + Zero + One, 

fn div_assign(&mut self, scalar: T)

Performs the /= operation.

impl<T: Eq> Eq for CscMatrix<T>

impl<'a, T> From<&'a CooMatrix<T>> for CscMatrix<T> where
    T: Scalar + Zero + ClosedAdd, 

fn from(matrix: &'a CooMatrix<T>) -> Self

Performs the conversion.

impl<'a, T> From<&'a CscMatrix<T>> for CooMatrix<T> where
    T: Scalar + Zero, 

fn from(matrix: &'a CscMatrix<T>) -> Self

Performs the conversion.

impl<'a, T> From<&'a CscMatrix<T>> for CsrMatrix<T> where
    T: Scalar, 

fn from(matrix: &'a CscMatrix<T>) -> Self

Performs the conversion.

impl<'a, T> From<&'a CsrMatrix<T>> for CscMatrix<T> where
    T: Scalar, 

fn from(matrix: &'a CsrMatrix<T>) -> Self

Performs the conversion.

impl<'a, T, R, C, S> From<&'a Matrix<T, R, C, S>> for CscMatrix<T> where
    T: Scalar + Zero,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>, 

fn from(matrix: &'a Matrix<T, R, C, S>) -> Self

Performs the conversion.

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

fn rows(&self) -> usize

fn cols(&self) -> usize

fn access(&self) -> Access<'_, T>

Expose dense or sparse access to the matrix.

impl<'a, T> Mul<&'a CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<&'a CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the * operation.

impl<'a, T, R, C, S> Mul<&'a Matrix<T, R, C, S>> for &'a CscMatrix<T> where
    T: Scalar + ClosedMul + ClosedAdd + ClosedSub + ClosedDiv + Neg + Zero + One,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<T, Dynamic, C>,
    ShapeConstraint: DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::RStride> + DimEq<C, Dynamic> + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::CStride> + DimEq<U1, S::RStride> + DimEq<R, Dynamic> + DimEq<Dynamic, S::CStride>, 

type Output = OMatrix<T, Dynamic, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Matrix<T, R, C, S>) -> Self::Output

Performs the * operation.

impl<'a, T, R, C, S> Mul<&'a Matrix<T, R, C, S>> for CscMatrix<T> where
    T: Scalar + ClosedMul + ClosedAdd + ClosedSub + ClosedDiv + Neg + Zero + One,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<T, Dynamic, C>,
    ShapeConstraint: DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::RStride> + DimEq<C, Dynamic> + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::CStride> + DimEq<U1, S::RStride> + DimEq<R, Dynamic> + DimEq<Dynamic, S::CStride>, 

type Output = OMatrix<T, Dynamic, C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Matrix<T, R, C, S>) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<&'a T> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: &'a T) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<&'a T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: &'a T) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: CscMatrix<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: CscMatrix<T>) -> Self::Output

Performs the * operation.

impl<'a, T, R, C, S> Mul<Matrix<T, R, C, S>> for &'a CscMatrix<T> where
    T: Scalar + ClosedMul + ClosedAdd + ClosedSub + ClosedDiv + Neg + Zero + One,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<T, Dynamic, C>,
    ShapeConstraint: DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::RStride> + DimEq<C, Dynamic> + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::CStride> + DimEq<U1, S::RStride> + DimEq<R, Dynamic> + DimEq<Dynamic, S::CStride>, 

type Output = OMatrix<T, Dynamic, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T, R, C, S>) -> Self::Output

Performs the * operation.

impl<'a, T, R, C, S> Mul<Matrix<T, R, C, S>> for CscMatrix<T> where
    T: Scalar + ClosedMul + ClosedAdd + ClosedSub + ClosedDiv + Neg + Zero + One,
    R: Dim,
    C: Dim,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<T, Dynamic, C>,
    ShapeConstraint: DimEq<U1, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::RStride> + DimEq<C, Dynamic> + DimEq<Dynamic, <<DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer as Storage<T, Dynamic, C>>::CStride> + DimEq<U1, S::RStride> + DimEq<R, Dynamic> + DimEq<Dynamic, S::CStride>, 

type Output = OMatrix<T, Dynamic, C>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T, R, C, S>) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<T> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: T) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the * operator.

fn mul(self, b: T) -> Self::Output

Performs the * operation.

impl<'a, T> MulAssign<&'a T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedMul + Zero + One, 

fn mul_assign(&mut self, scalar: &'a T)

Performs the *= operation.

impl<T> MulAssign<T> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedMul + Zero + One, 

fn mul_assign(&mut self, scalar: T)

Performs the *= operation.

impl<T> Neg for CscMatrix<T> where
    T: Scalar + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T> Neg for &'a CscMatrix<T> where
    T: Scalar + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq> PartialEq<CscMatrix<T>> for CscMatrix<T>

fn eq(&self, other: &CscMatrix<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &CscMatrix<T>) -> bool

This method tests for !=.

impl<T: Clone> SparseAccess<T> for CscMatrix<T>

fn nnz(&self) -> usize

Number of non-zero elements in the matrix.

fn fetch_triplets(&self) -> Vec<(usize, usize, T)>

Retrieve the triplets that identify the coefficients of the sparse matrix.

impl<T> StructuralEq for CscMatrix<T>

impl<T> StructuralPartialEq for CscMatrix<T>

impl<'a, T> Sub<&'a CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn sub(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the - operation.

impl<'a, T> Sub<&'a CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn sub(self, b: &'a CscMatrix<T>) -> Self::Output

Performs the - operation.

impl<'a, T> Sub<CscMatrix<T>> for &'a CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn sub(self, b: CscMatrix<T>) -> Self::Output

Performs the - operation.

impl<T> Sub<CscMatrix<T>> for CscMatrix<T> where
    T: Scalar + ClosedAdd + ClosedSub + ClosedMul + Zero + One + Neg<Output = T>, 

type Output = CscMatrix<T>

The resulting type after applying the - operator.

fn sub(self, b: CscMatrix<T>) -> Self::Output

Performs the - operation.