Eigen::CholmodBase< MatrixType_, UpLo_, Derived > Class Template Reference

The base class for the direct Cholesky factorization of Cholmod. More...

#include <CholmodSupport.h>

Inheritance diagram for Eigen::CholmodBase< MatrixType_, UpLo_, Derived >:

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

Public Member Functions
	CholmodBase ()
	CholmodBase (const MatrixType &matrix)
	~CholmodBase ()
StorageIndex	cols () const
StorageIndex	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
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
Derived &	setShift (const RealScalar &offset)
Scalar	determinant () const
Scalar	logDeterminant () const
template<typename Stream >
void	dumpMemory (Stream &)
Public Member Functions inherited from Eigen::SparseSolverBase< Derived >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
Derived &	derived ()
const Derived &	derived () const
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
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< Derived >	Base

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

Protected Attributes
cholmod_common	m_cholmod
cholmod_factor *	m_cholmodFactor
double	m_shiftOffset [2]
ComputationInfo	m_info
int	m_factorizationIsOk
int	m_analysisIsOk
bool	m_isInitialized
Protected Attributes inherited from Eigen::SparseSolverBase< Derived >
bool	m_isInitialized

Detailed Description

template<typename MatrixType_, int UpLo_, typename Derived>
class Eigen::CholmodBase< MatrixType_, UpLo_, Derived >

The base class for the direct Cholesky factorization of Cholmod.

See also

class CholmodSupernodalLLT, class CholmodSimplicialLDLT, class CholmodSimplicialLLT

Member Typedef Documentation

Base

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef SparseSolverBase<Derived> Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::Base

protected

CholMatrixType

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef MatrixType Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::CholMatrixType

MatrixType

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef MatrixType_ Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::MatrixType

RealScalar

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef MatrixType::RealScalar Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::RealScalar

Scalar

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef MatrixType::Scalar Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::Scalar

StorageIndex

template<typename MatrixType_ , int UpLo_, typename Derived >

typedef MatrixType::StorageIndex Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::StorageIndex

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ , int UpLo_, typename Derived >

anonymous enum

Enumerator
UpLo

{ UpLo = UpLo_ };

anonymous enum

template<typename MatrixType_ , int UpLo_, typename Derived >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

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

Constructor & Destructor Documentation

CholmodBase() [1/2]

template<typename MatrixType_ , int UpLo_, typename Derived >

Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::CholmodBase ( )

inline

                : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) {
    EIGEN_STATIC_ASSERT((internal::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
    m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
    internal::cm_start<StorageIndex>(m_cholmod);
  }

References EIGEN_STATIC_ASSERT, Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmod, and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_shiftOffset.

CholmodBase() [2/2]

template<typename MatrixType_ , int UpLo_, typename Derived >

Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::CholmodBase ( const MatrixType &  matrix )

inlineexplicit

      : m_cholmodFactor(0), m_info(Success), m_factorizationIsOk(false), m_analysisIsOk(false) {
    EIGEN_STATIC_ASSERT((internal::is_same<double, RealScalar>::value), CHOLMOD_SUPPORTS_DOUBLE_PRECISION_ONLY);
    m_shiftOffset[0] = m_shiftOffset[1] = 0.0;
    internal::cm_start<StorageIndex>(m_cholmod);
    compute(matrix);
  }

References Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::compute(), EIGEN_STATIC_ASSERT, Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmod, Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_shiftOffset, and matrix().

~CholmodBase()

template<typename MatrixType_ , int UpLo_, typename Derived >

Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::~CholmodBase ( )

inline

                 {
    if (m_cholmodFactor) internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
    internal::cm_finish<StorageIndex>(m_cholmod);
  }

References Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmod, and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmodFactor.

Member Function Documentation

_solve_impl() [1/2]

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

inline

                                                                           {
    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 storage 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 = internal::cm_solve<StorageIndex>(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.)
    // NOTE Actually, the copy can be avoided by calling cholmod_solve2 instead of cholmod_solve
    dest = Matrix<Scalar, Dest::RowsAtCompileTime, Dest::ColsAtCompileTime>::Map(reinterpret_cast<Scalar*>(x_cd->x),
                                                                                 b.rows(), b.cols());
    internal::cm_free_dense<StorageIndex>(x_cd, m_cholmod);
  }

References b, 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::PlainObjectBase< Matrix< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ > >::Map(), Eigen::NumericalIssue, size, and Eigen::viewAsCholmod().

_solve_impl() [2/2]

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

inline

                                                                                                     {
    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 = internal::cm_spsolve<StorageIndex>(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.)
    // NOTE cholmod_spsolve in fact just calls the dense solver for blocks of 4 columns at a time (similar to Eigen's
    // sparse solver)
    dest.derived() = viewAsEigen<typename DestDerived::Scalar, typename DestDerived::StorageIndex>(*x_cs);
    internal::cm_free_sparse<StorageIndex>(x_cs, m_cholmod);
  }

References b, 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, size, and Eigen::viewAsCholmod().

analyzePattern()

template<typename MatrixType_ , int UpLo_, typename Derived >

void Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::analyzePattern ( const MatrixType &  matrix )

inline

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) {
      internal::cm_free_factor<StorageIndex>(m_cholmodFactor, m_cholmod);
      m_cholmodFactor = 0;
    }
    cholmod_sparse A = viewAsCholmod(matrix.template selfadjointView<UpLo>());
    m_cholmodFactor = internal::cm_analyze<StorageIndex>(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, matrix(), Eigen::Success, and Eigen::viewAsCholmod().

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::compute().

cholmod()

template<typename MatrixType_ , int UpLo_, typename Derived >

cholmod_common& Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::cholmod ( )

inline

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

inline

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

References Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmodFactor.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

compute()

template<typename MatrixType_ , int UpLo_, typename Derived >

Derived& Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::compute ( const MatrixType &  matrix )

inline

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(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::factorize(), and matrix().

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::CholmodBase().

derived() [1/2]

template<typename MatrixType_ , int UpLo_, typename Derived >

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

inlineprotected

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

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::compute(), and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::setShift().

derived() [2/2]

template<typename MatrixType_ , int UpLo_, typename Derived >

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

inlineprotected

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

determinant()

template<typename MatrixType_ , int UpLo_, typename Derived >

Scalar Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::determinant ( ) const

inline

Returns

the determinant of the underlying matrix from the current factorization

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

References Eigen::bfloat16_impl::exp(), and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::logDeterminant().

dumpMemory()

template<typename MatrixType_ , int UpLo_, typename Derived >

template<typename Stream >

void Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::dumpMemory ( Stream &  )

inline

{}

factorize()

template<typename MatrixType_ , int UpLo_, typename Derived >

void Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::factorize ( const MatrixType &  matrix )

inline

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>());
    internal::cm_factorize_p<StorageIndex>(&A, m_shiftOffset, 0, 0, m_cholmodFactor, m_cholmod);
 
    // If the factorization failed, either the input matrix was zero (so m_cholmodFactor == nullptr), or minor is the
    // column at which it failed. On success minor == n.
    this->m_info =
        (m_cholmodFactor != nullptr && 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, matrix(), Eigen::NumericalIssue, Eigen::Success, and Eigen::viewAsCholmod().

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::compute().

info()

template<typename MatrixType_ , int UpLo_, typename Derived >

ComputationInfo Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

Success if computation was successful, 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.

logDeterminant()

template<typename MatrixType_ , int UpLo_, typename Derived >

Scalar Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::logDeterminant ( ) const

inline

Returns

the log determinant of the underlying matrix from the current factorization

                                {
    using numext::real;
    using std::log;
    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 blocks,
      // 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, k, Eigen::bfloat16_impl::log(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmodFactor, Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_factorizationIsOk, p, constants::pi, px, Eigen::real(), size, and plotDoE::x.

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::determinant().

rows()

template<typename MatrixType_ , int UpLo_, typename Derived >

StorageIndex Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::rows ( ) const

inline

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

References Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmodFactor.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

setShift()

template<typename MatrixType_ , int UpLo_, typename Derived >

Derived& Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::setShift ( const RealScalar &  offset )

inline

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.

Member Data Documentation

m_analysisIsOk

template<typename MatrixType_ , int UpLo_, typename Derived >

int Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_analysisIsOk

protected

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::analyzePattern(), and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::factorize().

m_cholmod

template<typename MatrixType_ , int UpLo_, typename Derived >

cholmod_common Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmod

mutableprotected

Referenced by Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::_solve_impl(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::analyzePattern(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::cholmod(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::CholmodBase(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::factorize(), and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::~CholmodBase().

m_cholmodFactor

template<typename MatrixType_ , int UpLo_, typename Derived >

cholmod_factor* Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_cholmodFactor

protected

Referenced by 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(), Eigen::CholmodSimplicialLLT< MatrixType_, UpLo_ >::matrixL(), Eigen::CholmodSimplicialLDLT< MatrixType_, UpLo_ >::matrixL(), Eigen::CholmodSupernodalLLT< MatrixType_, UpLo_ >::matrixL(), Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::rows(), Eigen::CholmodSimplicialLDLT< MatrixType_, UpLo_ >::vectorD(), and Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::~CholmodBase().

m_factorizationIsOk

template<typename MatrixType_ , int UpLo_, typename Derived >

int Eigen::CholmodBase< MatrixType_, UpLo_, Derived >::m_factorizationIsOk

protected

Referenced by 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

mutableprotected

Referenced by 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

mutableprotected

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]

protected

Referenced by 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:

• CholmodSupport.h