Crate sprs[][src]

Expand description

sprs is a sparse linear algebra library for Rust.

It features a sparse matrix type, CsMat, and a sparse vector type, CsVec, both based on the compressed storage scheme.


  • sparse matrix/sparse matrix addition, multiplication.
  • sparse vector/sparse vector addition, dot product.
  • sparse matrix/dense matrix addition, multiplication.
  • sparse triangular solves.
  • powerful iteration over the sparse structure, enabling easy extension of the library.
  • matrix construction using the triplet format, vertical and horizontal stacking, block construction.
  • sparse cholesky solver in the separate crate sprs-ldl.
  • fully generic integer type for the storage of indices, enabling compact representations.
  • planned interoperability with existing sparse solvers such as SuiteSparse.

Quick Examples

Matrix construction:

use sprs::{CsMat, TriMat};

let mut a = TriMat::new((4, 4));
a.add_triplet(0, 0, 3.0_f64);
a.add_triplet(1, 2, 2.0);
a.add_triplet(3, 0, -2.0);

// This matrix type does not allow computations, and must to
// converted to a compatible sparse type, using for example
let b: CsMat<_> = a.to_csr();

Constructing matrix using the more efficient direct sparse constructor

use sprs::{CsMat, CsVec};
let eye : CsMat<f64> = CsMat::eye(3);
let a = CsMat::new_csc((3, 3),
                       vec![0, 2, 4, 5],
                       vec![0, 1, 0, 2, 2],
                       vec![1., 2., 3., 4., 5.]);

Matrix vector multiplication:

use sprs::{CsMat, CsVec};
let eye = CsMat::eye(5);
let x = CsVec::new(5, vec![0, 2, 4], vec![1., 2., 3.]);
let y = &eye * &x;
assert_eq!(x, y);

Matrix matrix multiplication, addition:

use sprs::{CsMat, CsVec};
let eye = CsMat::eye(3);
let a = CsMat::new_csc((3, 3),
                       vec![0, 2, 4, 5],
                       vec![0, 1, 0, 2, 2],
                       vec![1., 2., 3., 4., 5.]);
let b = &eye * &a;
assert_eq!(a, b.to_csc());


pub use crate::indexing::SpIndex;
pub use crate::sparse::CompressedStorage::CSC;
pub use crate::sparse::CompressedStorage::CSR;
pub use SymmetryCheck::*;
pub use PermutationCheck::*;


Traits for comparing vectors and matrices using the approx traits

Fixed size arrays usable for sparse matrices.

Sparse matrix addition, subtraction

Error type for sprs

Serialization and deserialization of sparse matrices

Trait to be able to know at runtime if a generic scalar is an integer, a float or a complex.

Implementation of the paper Bank and Douglas, 2001, Sparse Matrix Multiplication Package (SMPP)


Compressed matrix in the CSR or CSC format, with sorted indices.

A sparse vector, storing the indices of its non-zero data.

Sparse matrix in the triplet format.

An iterator over elements of a sparse matrix, in the triplet format


Describe the storage of a CsMat

The different kinds of fill-in-reduction algorithms supported by sprs

Configuration enum to ask for permutation checks in algorithms

Configuration enum to ask for symmetry checks in algorithms


A trait for types representing dense vectors, useful for expressing algorithms such as sparse-dense dot product, or linear solves.

Trait for dense vectors that can be modified, useful for expressing algorithms which compute a resulting dense vector, such as solvers.

Trait for types that have a multiply-accumulate operation, as required in dot products and matrix products.

A trait for common members of sparse matrices


Assign a sparse matrix into a dense matrix

Specify a sparse matrix by constructing it from blocks of other matrices

Construct a sparse matrix by horizontally stacking other matrices

Compute the Kronecker product between two matrices

Compute the square matrix resulting from the product P * A * P^T

Construct a sparse matrix by vertically stacking other matrices

Type Definitions