g2o::csparse::CSparse Class Reference

#include <csparse_wrapper.h>

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

Public Member Functions
	CSparse ()
	~CSparse ()
bool	factorize ()
bool	hasFactor () const
void	freeFactor ()
FactorView	factor ()
bool	amd (const SparseView &sparseView, VectorXI &result)
	compute AMD ordering on the given SparseView, store into result
int	choleskyNz () const
bool	solve (double *x, double *b) const
bool	analyze ()
bool	analyze_p (int *permutation)
bool	hasSymbolic () const
void	freeSymbolic ()
SparseView	sparseView ()
bool	writeSparse (const std::string &filename) const

Private Attributes
std::unique_ptr< Impl >	pImpl

Detailed Description

Definition at line 38 of file csparse_wrapper.h.

Constructor & Destructor Documentation

CSparse()

g2o::csparse::CSparse::CSparse

(

)

Definition at line 104 of file csparse_wrapper.cpp.

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

~CSparse()

g2o::csparse::CSparse::~CSparse ( )

default

Member Function Documentation

amd()

bool g2o::csparse::CSparse::amd	(	const SparseView &	sparseView,
		VectorXI &	result
	)

compute AMD ordering on the given SparseView, store into result

Definition at line 117 of file csparse_wrapper.cpp.

                                                                {
  // prepare block structure for the CSparse call
  cs auxBlock;
  auxBlock.nzmax = sparseView.nzmax;
  auxBlock.m = sparseView.m;
  auxBlock.n = sparseView.n;
  auxBlock.p = sparseView.p;
  auxBlock.i = sparseView.i;
  auxBlock.x = NULL;  // no values
  auxBlock.nz = -1;   // CCS format
 
  // AMD ordering on the block structure
  int* permutation = cs_amd(1, &auxBlock);
  if (!permutation) return false;
  result.resize(auxBlock.m);
  VectorXI::ConstMapType permutation_map(permutation, result.size());
  result = permutation_map;
  cs_free(permutation);
  return true;
}

References g2o::csparse::CSparse::SparseView::i, g2o::csparse::CSparse::SparseView::m, g2o::csparse::CSparse::SparseView::n, g2o::csparse::CSparse::SparseView::nzmax, g2o::csparse::CSparse::SparseView::p, and sparseView().

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

analyze()

bool g2o::csparse::CSparse::analyze

(

)

Definition at line 160 of file csparse_wrapper.cpp.

                      {
  freeSymbolic();
  pImpl->symbolicDecomposition = cs_schol(1, &pImpl->ccsA);
  return pImpl->symbolicDecomposition != nullptr;
}

References freeSymbolic(), and pImpl.

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

analyze_p()

bool g2o::csparse::CSparse::analyze_p

(

int *

permutation

)

Definition at line 166 of file csparse_wrapper.cpp.

                                        {
  freeSymbolic();
  pImpl->symbolicDecomposition = static_cast<css*>(cs_calloc(1, sizeof(css)));
  int n = pImpl->ccsA.n;
  pImpl->symbolicDecomposition->pinv = cs_pinv(permutation, n);
  cs* C = cs_symperm(&pImpl->ccsA, pImpl->symbolicDecomposition->pinv, 0);
  pImpl->symbolicDecomposition->parent = cs_etree(C, 0);
  int* post = cs_post(pImpl->symbolicDecomposition->parent, n);
  int* c = cs_counts(C, pImpl->symbolicDecomposition->parent, post, 0);
  cs_free(post);
  cs_spfree(C);
  pImpl->symbolicDecomposition->cp =
      static_cast<int*>(cs_malloc(n + 1, sizeof(int)));
  pImpl->symbolicDecomposition->unz = pImpl->symbolicDecomposition->lnz =
      cs_cumsum(pImpl->symbolicDecomposition->cp, c, n);
  cs_free(c);
  if (pImpl->symbolicDecomposition->lnz < 0) {
    cs_sfree(pImpl->symbolicDecomposition);
    pImpl->symbolicDecomposition = nullptr;
  }
  return pImpl->symbolicDecomposition != nullptr;
}

References freeSymbolic(), and pImpl.

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

choleskyNz()

int g2o::csparse::CSparse::choleskyNz

(

)

const

Definition at line 189 of file csparse_wrapper.cpp.

                              {
  if (pImpl->symbolicDecomposition) return pImpl->symbolicDecomposition->lnz;
  return -1;
}

References pImpl.

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

factor()

CSparse::FactorView g2o::csparse::CSparse::factor

(

)

Definition at line 144 of file csparse_wrapper.cpp.

                                  {
  csn* factor = pImpl->numericCholesky;
  return CSparse::FactorView(factor->L->n, factor->L->p, factor->L->i,
                             factor->L->x, pImpl->symbolicDecomposition->pinv);
}

References factor(), g2o::csparse::CSparse::FactorView::i, g2o::csparse::CSparse::FactorView::n, g2o::csparse::CSparse::FactorView::p, pImpl, and g2o::csparse::CSparse::FactorView::x.

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

factorize()

bool g2o::csparse::CSparse::factorize

(

)

Definition at line 194 of file csparse_wrapper.cpp.

                        {
  pImpl->prepareWorkspace();
  freeFactor();
  pImpl->numericCholesky = csparse_extension::cs_chol_workspace(
      &pImpl->ccsA, pImpl->symbolicDecomposition, pImpl->csIntWorkspace,
      pImpl->csWorkspace);
 
  return pImpl->numericCholesky != nullptr;
}

References g2o::csparse_extension::cs_chol_workspace(), freeFactor(), and pImpl.

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

freeFactor()

void g2o::csparse::CSparse::freeFactor

(

)

Definition at line 108 of file csparse_wrapper.cpp.

                         {
  if (pImpl->numericCholesky) {
    cs_nfree(pImpl->numericCholesky);
    pImpl->numericCholesky = nullptr;
  }
}

References pImpl.

Referenced by factorize(), and g2o::LinearSolverCSparse< MatrixType >::solveBlocks_impl().

freeSymbolic()

void g2o::csparse::CSparse::freeSymbolic

(

)

Definition at line 208 of file csparse_wrapper.cpp.

                           {
  if (pImpl->symbolicDecomposition != nullptr) {
    cs_sfree(pImpl->symbolicDecomposition);
    pImpl->symbolicDecomposition = nullptr;
  }
}

References pImpl.

Referenced by analyze(), analyze_p(), and g2o::LinearSolverCSparse< MatrixType >::init().

hasFactor()

bool g2o::csparse::CSparse::hasFactor

(

)

const

Definition at line 115 of file csparse_wrapper.cpp.

{ return pImpl->numericCholesky != nullptr; }

References pImpl.

hasSymbolic()

bool g2o::csparse::CSparse::hasSymbolic

(

)

const

Definition at line 204 of file csparse_wrapper.cpp.

                                {
  return pImpl->symbolicDecomposition != nullptr;
}

References pImpl.

Referenced by g2o::LinearSolverCSparse< MatrixType >::prepareSolve().

solve()

bool g2o::csparse::CSparse::solve	(	double *	x,
		double *	b
	)		const

Definition at line 150 of file csparse_wrapper.cpp.

                                              {
  pImpl->prepareWorkspace();
 
  if (x != b) memcpy(x, b, pImpl->ccsA.n * sizeof(double));
  int ok = csparse_extension::cs_cholsolsymb(
      &pImpl->ccsA, x, pImpl->symbolicDecomposition, pImpl->csWorkspace,
      pImpl->csIntWorkspace);
  return static_cast<bool>(ok);
}

References g2o::csparse_extension::cs_cholsolsymb(), and pImpl.

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

sparseView()

CSparse::SparseView g2o::csparse::CSparse::sparseView

(

)

Definition at line 138 of file csparse_wrapper.cpp.

                                      {
  CSparseExt& sparse = pImpl->ccsA;
  return CSparse::SparseView(sparse.m, sparse.n, sparse.nzmax, sparse.p,
                             sparse.i, sparse.x, sparse.columnsAllocated);
}

References g2o::csparse::CSparseExt::columnsAllocated, and pImpl.

Referenced by amd(), and g2o::LinearSolverCSparse< MatrixType >::fillCSparse().

writeSparse()

bool g2o::csparse::CSparse::writeSparse

(

const std::string &

filename

)

const

Definition at line 215 of file csparse_wrapper.cpp.

                                                         {
  return csparse_extension::writeCs2Octave(filename.c_str(), &pImpl->ccsA,
                                           true);
}

References pImpl, and g2o::csparse_extension::writeCs2Octave().

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

Member Data Documentation

pImpl

std::unique_ptr<Impl> g2o::csparse::CSparse::pImpl

private

Definition at line 97 of file csparse_wrapper.h.

Referenced by analyze(), analyze_p(), choleskyNz(), factor(), factorize(), freeFactor(), freeSymbolic(), hasFactor(), hasSymbolic(), solve(), sparseView(), and writeSparse().

---

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

• /build/reproducible-path/g2o-0~20230806/g2o/solvers/csparse/csparse_wrapper.h
• /build/reproducible-path/g2o-0~20230806/g2o/solvers/csparse/csparse_wrapper.cpp