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< MatrixX > &spinv, const std::vector< std::pair< int, int > > &blockIndices, const SparseBlockMatrix< MatrixType > &A)

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

void	setWriteDebug (bool b)

Protected Attributes
bool	_reset

MatrixX	_H

Eigen::LDLT< MatrixX >	_cholesky

Protected Attributes inherited from g2o::LinearSolver< MatrixType >
bool	_writeDebug

Additional Inherited Members
Static Public Member Functions inherited from g2o::LinearSolver< MatrixType >
static void	allocateBlocks (const SparseBlockMatrix< MatrixType > &A, double **&blocks)
	allocate block memory structure

static void	deallocateBlocks (const SparseBlockMatrix< MatrixType > &A, double **&blocks)
	de-allocate the block structure

template<typename BlockDerived , typename ScalarDerived >
static void	blockToScalarPermutation (const SparseBlockMatrix< MatrixType > &A, const Eigen::MatrixBase< BlockDerived > &p, const Eigen::MatrixBase< ScalarDerived > &scalar)

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

◆ LinearSolverDense()

template<typename MatrixType >

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

inline

Definition at line 48 of file linear_solver_dense.h.

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

g2o::LinearSolverDense::_reset

bool _reset

Definition linear_solver_dense.h:108

◆ ~LinearSolverDense()

template<typename MatrixType >

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

inlinevirtual

Definition at line 50 of file linear_solver_dense.h.

50{}

Member Function Documentation

◆ init()

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 52 of file linear_solver_dense.h.

                      {
    _reset = true;
    return true;
  }

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

◆ solve()

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 57 of file linear_solver_dense.h.

                                                                           {
    int n = A.cols();
    int m = A.cols();
 
    MatrixX& 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
    VectorX::MapType xvec(x, m);
    VectorX::ConstMapType bvec(b, n);
    _cholesky.compute(H);
    if (_cholesky.isPositive()) {
      xvec = _cholesky.solve(bvec);
      return true;
    }
    return false;
  }