linear solver using dense cholesky decomposition More...

#include <linear_solver_dense.h>

Inheritance diagram for g2o::LinearSolverDense< MatrixType >:

Collaboration diagram for g2o::LinearSolverDense< MatrixType >:

Public Member Functions
	LinearSolverDense ()

virtual	~LinearSolverDense ()

virtual bool	init ()

bool	solve (const SparseBlockMatrix< MatrixType > &A, double x, double b)

Public Member Functions inherited from g2o::LinearSolver< MatrixType >
	LinearSolver ()

virtual	~LinearSolver ()

virtual bool	solveBlocks (double **&blocks, const SparseBlockMatrix< MatrixType > &A)

virtual bool	solvePattern (SparseBlockMatrix< MatrixXD > &spinv, const std::vector< std::pair< int, int > > &blockIndices, const SparseBlockMatrix< MatrixType > &A)

virtual bool	writeDebug () const
	write a debug dump of the system matrix if it is not PSD in solve More...

virtual void	setWriteDebug (bool)

Protected Attributes
bool	_reset

MatrixXD	_H

Eigen::LDLT< MatrixXD >	_cholesky

Detailed Description

template<typename MatrixType>
class g2o::LinearSolverDense< MatrixType >

linear solver using dense cholesky decomposition

Definition at line 46 of file linear_solver_dense.h.

Constructor & Destructor Documentation

template<typename MatrixType>

g2o::LinearSolverDense< MatrixType >::LinearSolverDense ( )

inline

Definition at line 49 of file linear_solver_dense.h.

                           :
         LinearSolver<MatrixType>(),
         _reset(true)
       {
       }

template<typename MatrixType>

virtual g2o::LinearSolverDense< MatrixType >::~LinearSolverDense ( )

inlinevirtual

Definition at line 55 of file linear_solver_dense.h.

56 {

57 }

Member Function Documentation

template<typename MatrixType>

virtual bool g2o::LinearSolverDense< MatrixType >::init ( )

inlinevirtual

init for operating on matrices with a different non-zero pattern like before

Implements g2o::LinearSolver< MatrixType >.

Definition at line 59 of file linear_solver_dense.h.

References g2o::LinearSolverDense< MatrixType >::_reset.

       {
         _reset = true;
         return true;
       }

template<typename MatrixType>

bool g2o::LinearSolverDense< MatrixType >::solve	(	const SparseBlockMatrix< MatrixType > &	A,
		double *	x,
		double *	b
	)

inlinevirtual

Assumes that A is the same matrix for several calls. Among other assumptions, the non-zero pattern does not change! If the matrix changes call init() before. solve system Ax = b, x and b have to allocated beforehand!!

Implements g2o::LinearSolver< MatrixType >.

Definition at line 65 of file linear_solver_dense.h.

References g2o::LinearSolverDense< MatrixType >::_cholesky, g2o::LinearSolverDense< MatrixType >::_H, g2o::LinearSolverDense< MatrixType >::_reset, g2o::SparseBlockMatrix< MatrixType >::blockCols(), g2o::SparseBlockMatrix< MatrixType >::colBaseOfBlock(), g2o::SparseBlockMatrix< MatrixType >::cols(), g2o::SparseBlockMatrix< MatrixType >::colsOfBlock(), g2o::SparseBlockMatrix< MatrixType >::rowBaseOfBlock(), g2o::SparseBlockMatrix< MatrixType >::rowsOfBlock(), and g2o::SparseBlockMatrix< MatrixType >::transpose().

       {
         int n = A.cols();
         int m = A.cols();
 
         MatrixXD& H = _H;
         if (H.cols() != n) {
           H.resize(n, m);
           _reset = true;
         }
         if (_reset) {
           _reset = false;
           H.setZero();
         }
 
         // copy the sparse block matrix into a dense matrix
         int c_idx = 0;
         for (size_t i = 0; i < A.blockCols().size(); ++i) {
           int c_size = A.colsOfBlock(i);
           assert(c_idx == A.colBaseOfBlock(i) && "mismatch in block indices");
 
           const typename SparseBlockMatrix<MatrixType>::IntBlockMap& col = A.blockCols()[i];
           if (col.size() > 0) {
             typename SparseBlockMatrix<MatrixType>::IntBlockMap::const_iterator it;
             for (it = col.begin(); it != col.end(); ++it) {
               int r_idx = A.rowBaseOfBlock(it->first);
               // only the upper triangular block is processed
               if (it->first <= (int)i) {
                 int r_size = A.rowsOfBlock(it->first);
                 H.block(r_idx, c_idx, r_size, c_size) = *(it->second);
                 if (r_idx != c_idx) // write the lower triangular block
                   H.block(c_idx, r_idx, c_size, r_size) = it->second->transpose();
               }
             }
           }
 
           c_idx += c_size;
         }
 
         // solving via Cholesky decomposition
         VectorXD::MapType xvec(x, m);
         VectorXD::ConstMapType bvec(b, n);
         _cholesky.compute(H);
         if (_cholesky.isPositive()) {
           xvec = _cholesky.solve(bvec);
           return true;
         }
         return false;
       }