# Crate sprs

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.

### Features

• 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));

// 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);``````

``````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());``````

## Re-exports

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

## Traits

• 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