Class sym::SparseCholeskySolver¶

template<typename _MatrixType, int _UpLo = Eigen::Lower> class SparseCholeskySolver¶

Efficiently solves A * x = b, where A is a sparse matrix and b is a dense vector or matrix, using the LDLT cholesky factorization A = L * D * L^T, where L is a unit triangular matrix and D is a diagonal matrix.

When repeatedly solving systems where A changes but its sparsity pattern remains identical, this class can analyze the sparsity pattern once and use it to more efficiently factorize and solve on subsequent calls.

Public Types

enum [anonymous]¶

Values:

enumerator UpLo¶

using MatrixType = _MatrixType ¶

using Scalar = typename MatrixType::Scalar¶

using StorageIndex = typename MatrixType::StorageIndex¶

using CholMatrixType = Eigen::SparseMatrix<Scalar, Eigen::ColMajor, StorageIndex>¶

using VectorType = Eigen::Matrix<Scalar, Eigen::Dynamic, 1>¶

using RhsType = Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>¶

using PermutationMatrixType = Eigen::PermutationMatrix<Eigen::Dynamic, Eigen::Dynamic, StorageIndex>¶

using Ordering = std::function<void(const MatrixType&, PermutationMatrixType&)>¶

Public Functions

inline SparseCholeskySolver(const Ordering &ordering = Eigen::MetisOrdering<StorageIndex>())¶

Default constructor

Parameters:: ordering – Functor to compute the variable ordering to use. Can be any functor with signature void(const MatrixType&, PermutationMatrixType&) which takes in the sparsity pattern of the matrix A and fills out the permutation of variables to use in the second argument. The first argument is the full matrix A, not just the upper or lower triangle; the values may not be the same as in A, but will be nonzero for entries in A that are nonzero. Typically this will be an instance of one of the orderings provided by Eigen, such as Eigen::NaturalOrdering().

inline explicit SparseCholeskySolver(const MatrixType &A, const Ordering &ordering = Eigen::MetisOrdering<StorageIndex>())¶

Construct with a representative sparse matrix

Parameters:

A – The matrix to be factorized
ordering – Functor to compute the variable ordering to use. Can be any functor with signature void(const MatrixType&, PermutationMatrixType&) which takes in the sparsity pattern of the matrix A and fills out the permutation of variables to use in the second argument. The first argument is the full matrix A, not just the upper or lower triangle; the values may not be the same as in A, but will be nonzero for entries in A that are nonzero. Typically this will be an instance of one of the orderings provided by Eigen, such as Eigen::NaturalOrdering().

inline ~SparseCholeskySolver()¶

inline bool IsInitialized() const¶: Whether we have computed a symbolic sparsity and are ready to factorize/solve.

void ComputePermutationMatrix(const MatrixType &A)¶: Compute an efficient permutation matrix (ordering) for A and store internally.

void ComputeSymbolicSparsity(const MatrixType &A)¶: Compute symbolic sparsity pattern for A and store internally.

bool Factorize(const MatrixType &A)¶: Decompose A into A = L * D * L^T and store internally. A must have the same sparsity as the matrix used for construction. Returns true if factorization was successful, and false otherwise. NOTE(brad): Currently always returns true.

template<typename Rhs> RhsType Solve(const Eigen::MatrixBase<Rhs> &b) const¶: Returns x for A x = b, where x and b are dense.

template<typename Rhs> void SolveInPlace(Eigen::MatrixBase<Rhs> &b) const¶: Solves in place for x in A x = b, where x and b are dense.

inline const CholMatrixType &L() const¶

inline const VectorType &D() const¶

inline const PermutationMatrixType &Permutation() const¶

inline const PermutationMatrixType &InversePermutation() const¶

inline void AnalyzeSparsityPattern(const Eigen::SparseMatrix<Scalar> &matrix)¶