Eigen::CholmodDecomposition< _MatrixType, _UpLo > Class Template Reference

A general Cholesky factorization and solver based on Cholmod. More...

#include <src/eigen/Eigen/src/CholmodSupport/CholmodSupport.h>

Inheritance diagram for Eigen::CholmodDecomposition< _MatrixType, _UpLo >:

Collaboration diagram for Eigen::CholmodDecomposition< _MatrixType, _UpLo >:

Public Types
typedef _MatrixType	MatrixType
enum	{ UpLo = _UpLo }
enum	{ ColsAtCompileTime = MatrixType::ColsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType	CholMatrixType
typedef MatrixType::StorageIndex	StorageIndex

Public Member Functions
	CholmodDecomposition ()
	CholmodDecomposition (const MatrixType &matrix)
	~CholmodDecomposition ()
void	setMode (CholmodMode mode)
StorageIndex	cols () const
StorageIndex	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful.
Derived &	compute (const MatrixType &matrix)
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
cholmod_common &	cholmod ()
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
template<typename RhsDerived , typename DestDerived >
void	_solve_impl (const SparseMatrixBase< RhsDerived > &b, SparseMatrixBase< DestDerived > &dest) const
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
Derived &	setShift (const RealScalar &offset)
Scalar	determinant () const
Scalar	logDeterminant () const
template<typename Stream >
void	dumpMemory (Stream &)
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const MatrixBase< Rhs > &b) const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const

Protected Member Functions
void	init ()
Derived &	derived ()
const Derived &	derived () const

Protected Attributes
cholmod_factor *	m_cholmodFactor
double	m_shiftOffset [2]
ComputationInfo	m_info
int	m_factorizationIsOk
int	m_analysisIsOk
bool	m_isInitialized

Private Types
typedef CholmodBase< _MatrixType, _UpLo, CholmodDecomposition >	Base

Private Attributes
cholmod_common	m_cholmod

Detailed Description

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

A general Cholesky factorization and solver based on Cholmod.

This class allows to solve for A.X = B sparse linear problems via a LL^T or LDL^T Cholesky factorization using the Cholmod library. The sparse matrix A must be selfadjoint and positive definite. The vectors or matrices X and B can be either dense or sparse.

This variant permits to change the underlying Cholesky method at runtime. On the other hand, it does not provide access to the result of the factorization. The default is to let Cholmod automatically choose between a simplicial and supernodal factorization.

Template Parameters

_MatrixType	the type of the sparse matrix A, it must be a SparseMatrix<>
_UpLo	the triangular part that will be used for the computations. It can be Lower or Upper. Default is Lower.

\implsparsesolverconcept

This class supports all kind of SparseMatrix<>: row or column major; upper, lower, or both; compressed or non compressed.

Warning

Only double precision real and complex scalar types are supported by Cholmod.

See also

TutorialSparseSolverConcept

Member Typedef Documentation

Base

template<typename _MatrixType , int _UpLo = Lower>

typedef CholmodBase<_MatrixType, _UpLo, CholmodDecomposition> Eigen::CholmodDecomposition< _MatrixType, _UpLo >::Base

private

CholMatrixType

template<typename _MatrixType , int _UpLo, typename Derived >

typedef MatrixType Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::CholMatrixType

inherited

MatrixType

template<typename _MatrixType , int _UpLo = Lower>

typedef _MatrixType Eigen::CholmodDecomposition< _MatrixType, _UpLo >::MatrixType

RealScalar

template<typename _MatrixType , int _UpLo, typename Derived >

typedef MatrixType::RealScalar Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::RealScalar

inherited

Scalar

template<typename _MatrixType , int _UpLo, typename Derived >

typedef MatrixType::Scalar Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::Scalar

inherited

StorageIndex

template<typename _MatrixType , int _UpLo, typename Derived >

typedef MatrixType::StorageIndex Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::StorageIndex

inherited

Member Enumeration Documentation

anonymous enum

template<typename _MatrixType , int _UpLo, typename Derived >

anonymous enum

inherited

Enumerator
UpLo

{ UpLo = _UpLo };

anonymous enum

template<typename _MatrixType , int _UpLo, typename Derived >

anonymous enum

inherited

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

         {
      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
    };

Constructor & Destructor Documentation

CholmodDecomposition() [1/2]

template<typename _MatrixType , int _UpLo = Lower>

Eigen::CholmodDecomposition< _MatrixType, _UpLo >::CholmodDecomposition ( )

inline

: Base() { init(); }

References Eigen::CholmodDecomposition< _MatrixType, _UpLo >::init().

Here is the call graph for this function:

CholmodDecomposition() [2/2]

template<typename _MatrixType , int _UpLo = Lower>

Eigen::CholmodDecomposition< _MatrixType, _UpLo >::CholmodDecomposition ( const MatrixType &  matrix )

inline

                                                   : Base()
    {
      init();
      this->compute(matrix);
    }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::compute(), and Eigen::CholmodDecomposition< _MatrixType, _UpLo >::init().

Here is the call graph for this function:

~CholmodDecomposition()

template<typename _MatrixType , int _UpLo = Lower>

Eigen::CholmodDecomposition< _MatrixType, _UpLo >::~CholmodDecomposition ( )

inline

{}

Member Function Documentation

_solve_impl() [1/3]

template<typename _MatrixType , int _UpLo, typename Derived >

template<typename Rhs , typename Dest >

void Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl ( const MatrixBase< Rhs > &  b, MatrixBase< Dest > &  dest  ) const

inlineinherited

    {
      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
      const Index size = m_cholmodFactor->n;
      EIGEN_UNUSED_VARIABLE(size);
      eigen_assert(size==b.rows());
      
      // Cholmod needs column-major stoarge without inner-stride, which corresponds to the default behavior of Ref.
      Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b.derived());
 
      cholmod_dense b_cd = viewAsCholmod(b_ref);
      cholmod_dense* x_cd = cholmod_solve(CHOLMOD_A, m_cholmodFactor, &b_cd, &m_cholmod);
      if(!x_cd)
      {
        this->m_info = NumericalIssue;
        return;
      }
      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
      dest = Matrix<Scalar,Dest::RowsAtCompileTime,Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),b.rows(),b.cols());
      cholmod_free_dense(&x_cd, &m_cholmod);
    }

References Eigen::PlainObjectBase< Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >::Eigen::Map, eigen_assert, EIGEN_UNUSED_VARIABLE, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info, Eigen::NumericalIssue, and Eigen::viewAsCholmod().

Here is the call graph for this function:

_solve_impl() [2/3]

template<typename Derived >

template<typename Rhs , typename Dest >

void Eigen::SparseSolverBase< Derived >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inlineinherited

    {
      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), Eigen::SparseMatrixBase< Derived >::derived(), and Eigen::internal::solve_sparse_through_dense_panels().

Here is the call graph for this function:

_solve_impl() [3/3]

template<typename _MatrixType , int _UpLo, typename Derived >

template<typename RhsDerived , typename DestDerived >

void Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl ( const SparseMatrixBase< RhsDerived > &  b, SparseMatrixBase< DestDerived > &  dest  ) const

inlineinherited

    {
      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
      const Index size = m_cholmodFactor->n;
      EIGEN_UNUSED_VARIABLE(size);
      eigen_assert(size==b.rows());
 
      // note: cs stands for Cholmod Sparse
      Ref<SparseMatrix<typename RhsDerived::Scalar,ColMajor,typename RhsDerived::StorageIndex> > b_ref(b.const_cast_derived());
      cholmod_sparse b_cs = viewAsCholmod(b_ref);
      cholmod_sparse* x_cs = cholmod_spsolve(CHOLMOD_A, m_cholmodFactor, &b_cs, &m_cholmod);
      if(!x_cs)
      {
        this->m_info = NumericalIssue;
        return;
      }
      // TODO optimize this copy by swapping when possible (be careful with alignment, etc.)
      dest.derived() = viewAsEigen<typename DestDerived::Scalar,ColMajor,typename DestDerived::StorageIndex>(*x_cs);
      cholmod_free_sparse(&x_cs, &m_cholmod);
    }

References Eigen::SparseMatrixBase< Derived >::derived(), eigen_assert, EIGEN_UNUSED_VARIABLE, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info, Eigen::NumericalIssue, and Eigen::viewAsCholmod().

Here is the call graph for this function:

analyzePattern()

template<typename _MatrixType , int _UpLo, typename Derived >

void Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern ( const MatrixType &  matrix )

inlineinherited

Performs a symbolic decomposition on the sparsity pattern of matrix.

This function is particularly useful when solving for several problems having the same structure.

See also

factorize()

    {
      if(m_cholmodFactor)
      {
        cholmod_free_factor(&m_cholmodFactor, &m_cholmod);
        m_cholmodFactor = 0;
      }
      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
      m_cholmodFactor = cholmod_analyze(&A, &m_cholmod);
      
      this->m_isInitialized = true;
      this->m_info = Success;
      m_analysisIsOk = true;
      m_factorizationIsOk = false;
    }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_analysisIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_isInitialized, Eigen::Success, and Eigen::viewAsCholmod().

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

cholmod()

template<typename _MatrixType , int _UpLo, typename Derived >

cholmod_common & Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::cholmod ( )

inlineinherited

Returns a reference to the Cholmod's configuration structure to get a full control over the performed operations. See the Cholmod user guide for details.

{ return m_cholmod; }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod.

cols()

template<typename _MatrixType , int _UpLo, typename Derived >

StorageIndex Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::cols ( ) const

inlineinherited

{ return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor.

compute()

template<typename _MatrixType , int _UpLo, typename Derived >

Derived & Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::compute ( const MatrixType &  matrix )

inlineinherited

Computes the sparse Cholesky decomposition of matrix

    {
      analyzePattern(matrix);
      factorize(matrix);
      return derived();
    }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::derived(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize().

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::CholmodBase(), Eigen::CholmodDecomposition< _MatrixType, _UpLo >::CholmodDecomposition(), Eigen::CholmodSimplicialLDLT< _MatrixType, _UpLo >::CholmodSimplicialLDLT(), Eigen::CholmodSimplicialLLT< _MatrixType, _UpLo >::CholmodSimplicialLLT(), Eigen::CholmodSupernodalLLT< _MatrixType, _UpLo >::CholmodSupernodalLLT(), and igl::slim::solve_weighted_arap().

Here is the call graph for this function:

Here is the caller graph for this function:

derived() [1/2]

template<typename _MatrixType , int _UpLo, typename Derived >

Derived & Eigen::SparseSolverBase< Derived >::derived ( )

inlineprotectedinherited

{ return *static_cast<Derived*>(this); }

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::compute(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::setShift().

Here is the caller graph for this function:

derived() [2/2]

template<typename _MatrixType , int _UpLo, typename Derived >

const Derived & Eigen::SparseSolverBase< Derived >::derived ( ) const

inlineprotectedinherited

{ return *static_cast<const Derived*>(this); }

determinant()

template<typename _MatrixType , int _UpLo, typename Derived >

Scalar Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::determinant ( ) const

inlineinherited

Returns

the determinant of the underlying matrix from the current factorization

    {
      using std::exp;
      return exp(logDeterminant());
    }

References exp(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::logDeterminant().

Here is the call graph for this function:

dumpMemory()

template<typename _MatrixType , int _UpLo, typename Derived >

template<typename Stream >

void Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::dumpMemory ( Stream &  )

inlineinherited

    {}

factorize()

template<typename _MatrixType , int _UpLo, typename Derived >

void Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize ( const MatrixType &  matrix )

inlineinherited

Performs a numeric decomposition of matrix

The given matrix must have the same sparsity pattern as the matrix on which the symbolic decomposition has been performed.

See also

analyzePattern()

    {
      eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
      cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
      cholmod_factorize_p(&A, m_shiftOffset, 0, 0, m_cholmodFactor, &m_cholmod);
 
      // If the factorization failed, minor is the column at which it did. On success minor == n.
      this->m_info = (m_cholmodFactor->minor == m_cholmodFactor->n ? Success : NumericalIssue);
      m_factorizationIsOk = true;
    }

References eigen_assert, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_analysisIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_shiftOffset, Eigen::NumericalIssue, Eigen::Success, and Eigen::viewAsCholmod().

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

info()

template<typename _MatrixType , int _UpLo, typename Derived >

ComputationInfo Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::info ( ) const

inlineinherited

Reports whether previous computation was successful.

Returns

Success if computation was succesful, NumericalIssue if the matrix.appears to be negative.

    {
      eigen_assert(m_isInitialized && "Decomposition is not initialized.");
      return m_info;
    }

References eigen_assert, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info, and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_isInitialized.

init()

template<typename _MatrixType , int _UpLo = Lower>

void Eigen::CholmodDecomposition< _MatrixType, _UpLo >::init ( )

inlineprotected

    {
      m_cholmod.final_asis = 1;
      m_cholmod.supernodal = CHOLMOD_AUTO;
    }

References Eigen::CholmodDecomposition< _MatrixType, _UpLo >::m_cholmod.

Referenced by Eigen::CholmodDecomposition< _MatrixType, _UpLo >::CholmodDecomposition(), and Eigen::CholmodDecomposition< _MatrixType, _UpLo >::CholmodDecomposition().

Here is the caller graph for this function:

logDeterminant()

template<typename _MatrixType , int _UpLo, typename Derived >

Scalar Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::logDeterminant ( ) const

inlineinherited

Returns

the log determinant of the underlying matrix from the current factorization

    {
      using std::log;
      using numext::real;
      eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
 
      RealScalar logDet = 0;
      Scalar *x = static_cast<Scalar*>(m_cholmodFactor->x);
      if (m_cholmodFactor->is_super)
      {
        // Supernodal factorization stored as a packed list of dense column-major blocs,
        // as described by the following structure:
 
        // super[k] == index of the first column of the j-th super node
        StorageIndex *super = static_cast<StorageIndex*>(m_cholmodFactor->super);
        // pi[k] == offset to the description of row indices
        StorageIndex *pi = static_cast<StorageIndex*>(m_cholmodFactor->pi);
        // px[k] == offset to the respective dense block
        StorageIndex *px = static_cast<StorageIndex*>(m_cholmodFactor->px);
 
        Index nb_super_nodes = m_cholmodFactor->nsuper;
        for (Index k=0; k < nb_super_nodes; ++k)
        {
          StorageIndex ncols = super[k + 1] - super[k];
          StorageIndex nrows = pi[k + 1] - pi[k];
 
          Map<const Array<Scalar,1,Dynamic>, 0, InnerStride<> > sk(x + px[k], ncols, InnerStride<>(nrows+1));
          logDet += sk.real().log().sum();
        }
      }
      else
      {
        // Simplicial factorization stored as standard CSC matrix.
        StorageIndex *p = static_cast<StorageIndex*>(m_cholmodFactor->p);
        Index size = m_cholmodFactor->n;
        for (Index k=0; k<size; ++k)
          logDet += log(real( x[p[k]] ));
      }
      if (m_cholmodFactor->is_ll)
        logDet *= 2.0;
      return logDet;
    };

References eigen_assert, log(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor, Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk, and real().

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::determinant().

Here is the call graph for this function:

Here is the caller graph for this function:

rows()

template<typename _MatrixType , int _UpLo, typename Derived >

StorageIndex Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::rows ( ) const

inlineinherited

{ return internal::convert_index<StorageIndex, Index>(m_cholmodFactor->n); }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor.

setMode()

template<typename _MatrixType , int _UpLo = Lower>

void Eigen::CholmodDecomposition< _MatrixType, _UpLo >::setMode ( CholmodMode  mode )

inline

    {
      switch(mode)
      {
        case CholmodAuto:
          m_cholmod.final_asis = 1;
          m_cholmod.supernodal = CHOLMOD_AUTO;
          break;
        case CholmodSimplicialLLt:
          m_cholmod.final_asis = 0;
          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
          m_cholmod.final_ll = 1;
          break;
        case CholmodSupernodalLLt:
          m_cholmod.final_asis = 1;
          m_cholmod.supernodal = CHOLMOD_SUPERNODAL;
          break;
        case CholmodLDLt:
          m_cholmod.final_asis = 1;
          m_cholmod.supernodal = CHOLMOD_SIMPLICIAL;
          break;
        default:
          break;
      }
    }

References Eigen::CholmodAuto, Eigen::CholmodLDLt, Eigen::CholmodSimplicialLLt, Eigen::CholmodSupernodalLLt, and Eigen::CholmodDecomposition< _MatrixType, _UpLo >::m_cholmod.

setShift()

template<typename _MatrixType , int _UpLo, typename Derived >

Derived & Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::setShift ( const RealScalar &  offset )

inlineinherited

Sets the shift parameter that will be used to adjust the diagonal coefficients during the numerical factorization.

During the numerical factorization, an offset term is added to the diagonal coefficients:
d_ii = offset + d_ii

The default is offset=0.

Returns

a reference to *this.

    {
      m_shiftOffset[0] = double(offset);
      return derived();
    }

References Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::derived(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_shiftOffset.

Here is the call graph for this function:

solve() [1/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const MatrixBase< Rhs > &  b ) const

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

References Eigen::SparseSolverBase< Derived >::derived(), eigen_assert, and Eigen::SparseSolverBase< Derived >::m_isInitialized.

Referenced by igl::embree::bone_heat(), igl::Frame_field_deformer::compute_optimal_positions(), igl::eigs(), igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric(), igl::slim::solve_weighted_arap(), and igl::copyleft::comiso::NRosyField::solveNoRoundings().

Here is the call graph for this function:

Here is the caller graph for this function:

solve() [2/2]

template<typename Derived >

template<typename Rhs >

const Solve< Derived, Rhs > Eigen::SparseSolverBase< Derived >::solve ( const SparseMatrixBase< Rhs > &  b ) const

inlineinherited

Returns

an expression of the solution x of using the current decomposition of A.

See also

compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

Member Data Documentation

m_analysisIsOk

template<typename _MatrixType , int _UpLo, typename Derived >

int Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_analysisIsOk

protectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize().

m_cholmod

template<typename _MatrixType , int _UpLo = Lower>

cholmod_common Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmod

mutableprivate

Referenced by Eigen::CholmodDecomposition< _MatrixType, _UpLo >::init(), and Eigen::CholmodDecomposition< _MatrixType, _UpLo >::setMode().

m_cholmodFactor

template<typename _MatrixType , int _UpLo, typename Derived >

cholmod_factor* Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_cholmodFactor

protectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::~CholmodBase(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::cols(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::logDeterminant(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::rows().

m_factorizationIsOk

template<typename _MatrixType , int _UpLo, typename Derived >

int Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_factorizationIsOk

protectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::logDeterminant().

m_info

template<typename _MatrixType , int _UpLo, typename Derived >

ComputationInfo Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_info

mutableprotectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::_solve_impl(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::info().

m_isInitialized

template<typename _MatrixType , int _UpLo, typename Derived >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::analyzePattern(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::info().

m_shiftOffset

template<typename _MatrixType , int _UpLo, typename Derived >

double Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::m_shiftOffset[2]

protectedinherited

Referenced by Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::CholmodBase(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::CholmodBase(), Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::factorize(), and Eigen::CholmodBase< _MatrixType, _UpLo, Derived >::setShift().

---

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

• src/eigen/Eigen/src/CholmodSupport/CholmodSupport.h