Struct CscMatrix 

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

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::coo::CooMatrix;
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 mut coo = CooMatrix::<f64>::new(3, 3);
coo.push(2, 0, 1.0);
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) -> CscMatrix<T>

where T: Scalar + One,

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

pub fn zeros(nrows: usize, ncols: usize) -> CscMatrix<T>

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<CscMatrix<T>, 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_unsorted_csc_data( num_rows: usize, num_cols: usize, col_offsets: Vec<usize>, row_indices: Vec<usize>, values: Vec<T>, ) -> Result<CscMatrix<T>, SparseFormatError>

where T: Scalar,

Try to construct a CSC matrix from raw CSC data with unsorted row indices.

It is assumed that each column contains unique 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 with the exception of having unsorted row indices and values. See the documentation for CscMatrix for more information.

pub fn try_from_pattern_and_values( pattern: SparsityPattern, values: Vec<T>, ) -> Result<CscMatrix<T>, 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 (col_offsets, row_indices, values) that make up the CSC data.

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

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

pub fn filter<P>(&self, predicate: P) -> CscMatrix<T>

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) -> CscMatrix<T>

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) -> CscMatrix<T>

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) -> CscMatrix<T>

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 for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T> Add<&'a CscMatrix<T>> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T> Add<CscMatrix<T>> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AdjustByDivisionOp<CscMatrix<T>, T> for CscMatrix<T>

where T: RealField + Copy + Sum,

fn adjust_by_division_inplace(&mut self, denom: &CscMatrix<T>)

adjust each column with the corresponding column of the denom

fn adjust_by_division_of_selected_inplace( &mut self, denom_db: &CscMatrix<T>, batches: &[usize], )

Adjust each column with the column of the matching batch index

impl<T> AdjustByDivisionOp<Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>, T> for CscMatrix<T>

where T: RealField + Copy + Sum,

fn adjust_by_division_of_selected_inplace( &mut self, denom_db: &Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>, batches: &[usize], )

Adjust each column with the column of the matching batch index

fn adjust_by_division_inplace( &mut self, denom: &Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>, )

adjust each column with the corresponding column of the denom

impl<T> Clone for CscMatrix<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ConvertMatOps for CscMatrix<T>

where T: RealField + Copy + WithDType,

type Mat = CscMatrix<T>

type Scalar = T

fn from_tensor( tensor: &Tensor, ) -> Result<<CscMatrix<T> as ConvertMatOps>::Mat, Error>

fn to_tensor(&self, dev: &Device) -> Result<Tensor, Error>

impl<T> Debug for CscMatrix<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for CscMatrix<T>

fn default() -> CscMatrix<T>

Returns the “default value” for a type.

impl<T> DistanceOps for CscMatrix<T>

where T: RealField + Copy + Sum,

type Scalar = T

type Other = CscMatrix<T>

fn euclidean_distance( &self, other: &<CscMatrix<T> as DistanceOps>::Other, ) -> Result<Vec<(usize, usize, <CscMatrix<T> as DistanceOps>::Scalar)>, Error>

A vector of Euclidean distances between sources and targets other

fn euclidean_distance_on_select_columns( &self, other: &<CscMatrix<T> as DistanceOps>::Other, select_columns_in_other: &[usize], ) -> Result<Vec<(usize, usize, <CscMatrix<T> as DistanceOps>::Scalar)>, Error>

A vector of Euclidean distances between sources and targets other

impl<'a, T> Div<&'a T> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: &'a T) -> <&'a CscMatrix<T> as Div<&'a T>>::Output

Performs the / operation.

impl<'a, T> Div<&T> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: &T) -> <CscMatrix<T> as Div<&T>>::Output

Performs the / operation.

impl<T> Div<T> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: T) -> <CscMatrix<T> as Div<T>>::Output

Performs the / operation.

impl<'a, T> Div<T> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the / operator.

fn div(self, scalar: T) -> <&'a CscMatrix<T> as Div<T>>::Output

Performs the / operation.

impl<'a, T> DivAssign<&'a T> for CscMatrix<T>

where T: Scalar + ClosedAddAssign + ClosedMulAssign + ClosedDivAssign + Zero + One,

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

Performs the /= operation.

impl<T> DivAssign<T> for CscMatrix<T>

where T: Scalar + ClosedAddAssign + ClosedMulAssign + ClosedDivAssign + Zero + One,

fn div_assign(&mut self, scalar: T)

Performs the /= operation.

impl<T> Eq for CscMatrix<T>

where T: Eq,

impl<'a, T> From<&'a CooMatrix<T>> for CscMatrix<T>

where T: Scalar + Zero + ClosedAddAssign,

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

Converts to this type from the input type.

impl<'a, T> From<&'a CscMatrix<T>> for Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>

where T: Scalar + Zero + ClosedAddAssign,

fn from( matrix: &'a CscMatrix<T>, ) -> Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>

Converts to this type from the input type.

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

where T: Scalar,

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

Converts to this type from the input type.

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

where T: Scalar,

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

Converts to this type from the input type.

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: RawStorage<T, R, C>,

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

Converts to this type from the input type.

impl<T> MatElemOps for CscMatrix<T>

where T: RealField + Copy,

type Mat = CscMatrix<T>

type Scalar = T

fn log1p_inplace(&mut self)

fn log1p(&self) -> <CscMatrix<T> as MatElemOps>::Mat

impl<T> MatOps for CscMatrix<T>

where T: RealField + Copy,

type Mat = CscMatrix<T>

type Scalar = T

fn normalize_exp_logits_columns_inplace(&mut self)

normalize logits after taking exp (log-sum-exp)

fn normalize_exp_logits_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

normalize logits after taking exp (log-sum-exp)

fn log_softmax_columns_inplace(&mut self)

column-wise log-softmax: subtract each column’s log-sum-exp so the exp of each column sums to 1. Returns log-probabilities (unlike Self::normalize_exp_logits_columns, which returns probabilities).

fn log_softmax_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

column-wise log-softmax (see Self::log_softmax_columns_inplace)

fn sum_to_one_columns_inplace(&mut self)

make each column sum to 1

fn sum_to_one_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

make each column sum to 1

fn sum_to_one_rows(&self) -> <CscMatrix<T> as MatOps>::Mat

make each row sum to 1

fn sum_to_one_rows_inplace(&mut self)

make each row sum to 1

fn normalize_columns_inplace(&mut self)

vector norm for each column

fn normalize_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

vector norm for each column

fn scale_columns_inplace(&mut self)

standardization for each column

fn scale_rows_inplace(&mut self)

standardization for each row

fn scale_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

standardization for each column

fn scale_rows(&self) -> <CscMatrix<T> as MatOps>::Mat

standardization for each row

fn centre_columns_inplace(&mut self)

centering for each column

fn centre_columns(&self) -> <CscMatrix<T> as MatOps>::Mat

centering for each column

impl<T> MatTriplets for CscMatrix<T>

where T: RealField + Float,

type Mat = CscMatrix<T>

type Scalar = T

fn from_nonzero_triplets<I>( nrow: usize, ncol: usize, triplets: &[(I, I, <CscMatrix<T> as MatTriplets>::Scalar)], ) -> Result<<CscMatrix<T> as MatTriplets>::Mat, Error>

where I: TryInto<usize> + Copy, <I as TryInto<usize>>::Error: Debug,

fn to_nonzero_triplets( &self, ) -> Result<NRowNColTriplets<<CscMatrix<T> as MatTriplets>::Scalar>, Error>

impl<'a, T> Mul for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<&'a CscMatrix<T>> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, R, C, S> Mul<&'a Matrix<T, R, C, S>> for &'a CscMatrix<T>

where T: Scalar + ClosedMulAssign + ClosedAddAssign + ClosedSubAssign + ClosedDivAssign + Neg + Zero + One, R: Dim, C: Dim, S: RawStorage<T, R, C>, DefaultAllocator: Allocator<Dyn, C>, ShapeConstraint: DimEq<Const<1>, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::RStride> + DimEq<C, Dyn> + DimEq<Dyn, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::CStride> + DimEq<Const<1>, <S as RawStorage<T, R, C>>::RStride> + DimEq<R, Dyn> + DimEq<Dyn, <S as RawStorage<T, R, C>>::CStride>,

type Output = Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, R, C, S> Mul<&'a Matrix<T, R, C, S>> for CscMatrix<T>

where T: Scalar + ClosedMulAssign + ClosedAddAssign + ClosedSubAssign + ClosedDivAssign + Neg + Zero + One, R: Dim, C: Dim, S: RawStorage<T, R, C>, DefaultAllocator: Allocator<Dyn, C>, ShapeConstraint: DimEq<Const<1>, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::RStride> + DimEq<C, Dyn> + DimEq<Dyn, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::CStride> + DimEq<Const<1>, <S as RawStorage<T, R, C>>::RStride> + DimEq<R, Dyn> + DimEq<Dyn, <S as RawStorage<T, R, C>>::CStride>,

type Output = Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<&'a T> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<&'a T> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<CscMatrix<T>> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, R, C, S> Mul<Matrix<T, R, C, S>> for &'a CscMatrix<T>

where T: Scalar + ClosedMulAssign + ClosedAddAssign + ClosedSubAssign + ClosedDivAssign + Neg + Zero + One, R: Dim, C: Dim, S: RawStorage<T, R, C>, DefaultAllocator: Allocator<Dyn, C>, ShapeConstraint: DimEq<Const<1>, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::RStride> + DimEq<C, Dyn> + DimEq<Dyn, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::CStride> + DimEq<Const<1>, <S as RawStorage<T, R, C>>::RStride> + DimEq<R, Dyn> + DimEq<Dyn, <S as RawStorage<T, R, C>>::CStride>,

type Output = Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, R, C, S> Mul<Matrix<T, R, C, S>> for CscMatrix<T>

where T: Scalar + ClosedMulAssign + ClosedAddAssign + ClosedSubAssign + ClosedDivAssign + Neg + Zero + One, R: Dim, C: Dim, S: RawStorage<T, R, C>, DefaultAllocator: Allocator<Dyn, C>, ShapeConstraint: DimEq<Const<1>, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::RStride> + DimEq<C, Dyn> + DimEq<Dyn, <<DefaultAllocator as Allocator<Dyn, C>>::Buffer<T> as RawStorage<T, Dyn, C>>::CStride> + DimEq<Const<1>, <S as RawStorage<T, R, C>>::RStride> + DimEq<R, Dyn> + DimEq<Dyn, <S as RawStorage<T, R, C>>::CStride>,

type Output = Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<T> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<T> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> MulAssign<&'a T> for CscMatrix<T>

where T: Scalar + ClosedAddAssign + ClosedMulAssign + Zero + One,

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

Performs the *= operation.

impl<T> MulAssign<T> for CscMatrix<T>

where T: Scalar + ClosedAddAssign + ClosedMulAssign + 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) -> <CscMatrix<T> as Neg>::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) -> <&'a CscMatrix<T> as Neg>::Output

Performs the unary - operation.

impl<T> PartialEq for CscMatrix<T>

where T: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> RandomizedAlgs for CscMatrix<T>

where T: RealField + Float + Copy,

type InMat = CscMatrix<T>

type OutMat = Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>

type DVec = Matrix<T, Dyn, Const<1>, VecStorage<T, Dyn, Const<1>>>

type Scalar = T

fn rsvd( &self, max_rank: usize, ) -> Result<(<CscMatrix<T> as RandomizedAlgs>::OutMat, <CscMatrix<T> as RandomizedAlgs>::DVec, <CscMatrix<T> as RandomizedAlgs>::OutMat), Error>

randomized singular value decomposition

impl<T> StructuralPartialEq for CscMatrix<T>

where T: PartialEq,

impl<'a, T> Sub for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T> Sub<&'a CscMatrix<T>> for CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T> Sub<CscMatrix<T>> for &'a CscMatrix<T>

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

type Output = CscMatrix<T>

The resulting type after applying the - operator.

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

Performs the - operation.