g2o::cholmod::Cholmod Class Reference

#include <cholmod_wrapper.h>

Classes
struct	FactorView
	View onto the cholesky factor. More...
class	Impl
struct	SparseView
	View onto the sparse matrix structure of Cholmod using CCS storage. More...

Public Member Functions
	Cholmod ()
	~Cholmod ()
bool	factorize ()
bool	hasFactor () const
void	freeFactor ()
bool	simplifyFactor ()
bool	amd (SparseView &sparseView, int *result)
	compute AMD ordering on the given SparseView, store into result
int	choleskyNz () const
void	solve (double *x, double *b) const
bool	analyze ()
bool	analyze_p (int *permutation)
SparseView	sparseView ()
FactorView	factor ()

Private Attributes
std::unique_ptr< Impl >	pImpl

Detailed Description

Definition at line 36 of file cholmod_wrapper.h.

Constructor & Destructor Documentation

Cholmod()

g2o::cholmod::Cholmod::Cholmod

(

)

Definition at line 70 of file cholmod_wrapper.cpp.

: pImpl(std::make_unique<Impl>()) {}

~Cholmod()

g2o::cholmod::Cholmod::~Cholmod ( )

default

Member Function Documentation

amd()

bool g2o::cholmod::Cholmod::amd	(	SparseView &	sparseView,
		int *	result
	)

compute AMD ordering on the given SparseView, store into result

Definition at line 78 of file cholmod_wrapper.cpp.

                                                     {
  cholmod_sparse auxCholmodSparse;
  auxCholmodSparse.nzmax = sparseView.nzmax;
  auxCholmodSparse.nrow = sparseView.nrow;
  auxCholmodSparse.ncol = sparseView.ncol;
  auxCholmodSparse.p = sparseView.p;
  auxCholmodSparse.i = sparseView.i;
  auxCholmodSparse.nz = 0;
  auxCholmodSparse.x = 0;
  auxCholmodSparse.z = 0;
  auxCholmodSparse.stype = 1;
  auxCholmodSparse.xtype = CHOLMOD_PATTERN;
  auxCholmodSparse.itype = CHOLMOD_INT;
  auxCholmodSparse.dtype = CHOLMOD_DOUBLE;
  auxCholmodSparse.sorted = 1;
  auxCholmodSparse.packed = 1;
 
  int amdStatus =
      cholmod_amd(&auxCholmodSparse, NULL, 0, result, &pImpl->cholmodCommon);
  return amdStatus != 0;
}

References g2o::cholmod::Cholmod::SparseView::i, g2o::cholmod::Cholmod::SparseView::ncol, g2o::cholmod::Cholmod::SparseView::nrow, g2o::cholmod::Cholmod::SparseView::nzmax, g2o::cholmod::Cholmod::SparseView::p, pImpl, and sparseView().

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

analyze()

bool g2o::cholmod::Cholmod::analyze

(

)

Definition at line 131 of file cholmod_wrapper.cpp.

                      {
  // setup ordering strategy
  pImpl->cholmodCommon.nmethods = 1;
  pImpl->cholmodCommon.method[0].ordering = CHOLMOD_AMD;  // CHOLMOD_COLAMD
  pImpl->cholmodFactor =
      cholmod_analyze(&pImpl->cholmodSparse,
                      &pImpl->cholmodCommon);  // symbolic factorization
  return true;
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

analyze_p()

bool g2o::cholmod::Cholmod::analyze_p

(

int *

permutation

)

Definition at line 141 of file cholmod_wrapper.cpp.

                                        {
  pImpl->cholmodCommon.nmethods = 1;
  pImpl->cholmodCommon.method[0].ordering = CHOLMOD_GIVEN;
  pImpl->cholmodFactor = cholmod_analyze_p(&pImpl->cholmodSparse, permutation,
                                           NULL, 0, &pImpl->cholmodCommon);
  return true;
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeSymbolicDecomposition().

choleskyNz()

int g2o::cholmod::Cholmod::choleskyNz

(

)

const

Definition at line 149 of file cholmod_wrapper.cpp.

                              {
  return static_cast<int>(pImpl->cholmodCommon.method[0].lnz);
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::solve(), and g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

factor()

Cholmod::FactorView g2o::cholmod::Cholmod::factor

(

)

Definition at line 108 of file cholmod_wrapper.cpp.

                                  {
  cholmod_factor& factor = *pImpl->cholmodFactor;
  return Cholmod::FactorView(factor.n, *reinterpret_cast<int**>(&factor.p),
                             *reinterpret_cast<int**>(&factor.i),
                             *reinterpret_cast<double**>(&factor.x),
                             *reinterpret_cast<int**>(&factor.Perm));
}

References factor(), g2o::cholmod::Cholmod::FactorView::i, g2o::cholmod::Cholmod::FactorView::n, g2o::cholmod::Cholmod::FactorView::p, pImpl, and g2o::cholmod::Cholmod::FactorView::x.

Referenced by factor(), and g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

factorize()

bool g2o::cholmod::Cholmod::factorize

(

)

Definition at line 153 of file cholmod_wrapper.cpp.

                        {
  cholmod_factorize(&pImpl->cholmodSparse, pImpl->cholmodFactor,
                    &pImpl->cholmodCommon);
  return pImpl->cholmodCommon.status == CHOLMOD_OK;
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor().

freeFactor()

void g2o::cholmod::Cholmod::freeFactor

(

)

Definition at line 74 of file cholmod_wrapper.cpp.

{ pImpl->freeFactor(); }

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::freeCholdmodFactor().

hasFactor()

bool g2o::cholmod::Cholmod::hasFactor

(

)

const

Definition at line 76 of file cholmod_wrapper.cpp.

{ return pImpl->cholmodFactor != nullptr; }

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::computeCholmodFactor().

simplifyFactor()

bool g2o::cholmod::Cholmod::simplifyFactor

(

)

Definition at line 159 of file cholmod_wrapper.cpp.

                             {
  // convert the factorization to LL, simplical, packed, monotonic
  int change_status = cholmod_change_factor(
      CHOLMOD_REAL, 1, 0, 1, 1, pImpl->cholmodFactor, &pImpl->cholmodCommon);
  assert(pImpl->cholmodFactor->is_ll && !pImpl->cholmodFactor->is_super &&
         pImpl->cholmodFactor->is_monotonic &&
         "Cholesky factor has wrong format");
  return change_status != 0;
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

solve()

void g2o::cholmod::Cholmod::solve	(	double *	x,
		double *	b
	)		const

Definition at line 116 of file cholmod_wrapper.cpp.

                                              {
  // setting up b for calling cholmod
  cholmod_dense bcholmod;
  bcholmod.nrow = bcholmod.d = pImpl->cholmodSparse.nrow;
  bcholmod.ncol = 1;
  bcholmod.x = b;
  bcholmod.xtype = CHOLMOD_REAL;
  bcholmod.dtype = CHOLMOD_DOUBLE;
  cholmod_dense* xcholmod = cholmod_solve(CHOLMOD_A, pImpl->cholmodFactor,
                                          &bcholmod, &pImpl->cholmodCommon);
  std::memcpy(x, xcholmod->x,
              sizeof(double) * bcholmod.nrow);  // copy back to our array
  cholmod_free_dense(&xcholmod, &pImpl->cholmodCommon);
}

References pImpl.

Referenced by g2o::LinearSolverCholmod< MatrixType >::solve().

sparseView()

Cholmod::SparseView g2o::cholmod::Cholmod::sparseView

(

)

Definition at line 100 of file cholmod_wrapper.cpp.

                                      {
  CholmodExt& sparse = pImpl->cholmodSparse;
  return Cholmod::SparseView(
      sparse.nrow, sparse.ncol, sparse.nzmax,
      *reinterpret_cast<int**>(&sparse.p), *reinterpret_cast<int**>(&sparse.i),
      *reinterpret_cast<double**>(&sparse.x), sparse.columnsAllocated);
}

References g2o::cholmod::CholmodExt::columnsAllocated, and pImpl.

Referenced by amd(), g2o::LinearSolverCholmod< MatrixType >::fillCholmodExt(), g2o::LinearSolverCholmod< MatrixType >::saveMatrix(), and g2o::LinearSolverCholmod< MatrixType >::solveBlocks_impl().

Member Data Documentation

pImpl

std::unique_ptr<Impl> g2o::cholmod::Cholmod::pImpl

private

Definition at line 92 of file cholmod_wrapper.h.

Referenced by amd(), analyze(), analyze_p(), choleskyNz(), factor(), factorize(), freeFactor(), hasFactor(), simplifyFactor(), solve(), and sparseView().

---

The documentation for this class was generated from the following files:

• /build/reproducible-path/g2o-0~20230806/g2o/solvers/cholmod/cholmod_wrapper.h
• /build/reproducible-path/g2o-0~20230806/g2o/solvers/cholmod/cholmod_wrapper.cpp