Eigen::SimplicialCholeskyBase< Derived > Class Template Reference

A base class for direct sparse Cholesky factorizations. More...

#include <src/eigen/Eigen/src/SparseCholesky/SimplicialCholesky.h>

Inheritance diagram for Eigen::SimplicialCholeskyBase< Derived >:

Collaboration diagram for Eigen::SimplicialCholeskyBase< Derived >:

Classes
struct	keep_diag

Public Types
enum	{ UpLo = internal::traits<Derived>::UpLo }
enum	{ ColsAtCompileTime = MatrixType::ColsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
typedef internal::traits< Derived >::MatrixType	MatrixType
typedef internal::traits< Derived >::OrderingType	OrderingType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::StorageIndex	StorageIndex
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	CholMatrixType
typedef CholMatrixType const *	ConstCholMatrixPtr
typedef Matrix< Scalar, Dynamic, 1 >	VectorType
typedef Matrix< StorageIndex, Dynamic, 1 >	VectorI

Public Member Functions
	SimplicialCholeskyBase ()
	SimplicialCholeskyBase (const MatrixType &matrix)
	~SimplicialCholeskyBase ()
Derived &	derived ()
const Derived &	derived () const
Index	cols () const
Index	rows () const
ComputationInfo	info () const
	Reports whether previous computation was successful.
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationP () const
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationPinv () const
Derived &	setShift (const RealScalar &offset, const RealScalar &scale=1)
template<typename Stream >
void	dumpMemory (Stream &s)
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const
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

Protected Member Functions
template<bool DoLDLT>
void	compute (const MatrixType &matrix)
template<bool DoLDLT>
void	factorize (const MatrixType &a)
template<bool DoLDLT>
void	factorize_preordered (const CholMatrixType &a)
void	analyzePattern (const MatrixType &a, bool doLDLT)
void	analyzePattern_preordered (const CholMatrixType &a, bool doLDLT)
void	ordering (const MatrixType &a, ConstCholMatrixPtr &pmat, CholMatrixType &ap)

Protected Attributes
ComputationInfo	m_info
bool	m_factorizationIsOk
bool	m_analysisIsOk
CholMatrixType	m_matrix
VectorType	m_diag
VectorI	m_parent
VectorI	m_nonZerosPerCol
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_P
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_Pinv
RealScalar	m_shiftOffset
RealScalar	m_shiftScale

Private Types
typedef SparseSolverBase< Derived >	Base

Private Attributes
bool	m_isInitialized

Detailed Description

template<typename Derived>
class Eigen::SimplicialCholeskyBase< Derived >

A base class for direct sparse Cholesky factorizations.

This is a base class for LL^T and LDL^T Cholesky factorizations of sparse matrices that are selfadjoint and positive definite. These factorizations allow for solving A.X = B where X and B can be either dense or sparse.

In order to reduce the fill-in, a symmetric permutation P is applied prior to the factorization such that the factorized matrix is P A P^-1.

Template Parameters

Derived

the type of the derived class, that is the actual factorization type.

Member Typedef Documentation

Base

template<typename Derived >

typedef SparseSolverBase<Derived> Eigen::SimplicialCholeskyBase< Derived >::Base

private

CholMatrixType

template<typename Derived >

typedef SparseMatrix<Scalar,ColMajor,StorageIndex> Eigen::SimplicialCholeskyBase< Derived >::CholMatrixType

ConstCholMatrixPtr

template<typename Derived >

typedef CholMatrixType const* Eigen::SimplicialCholeskyBase< Derived >::ConstCholMatrixPtr

MatrixType

template<typename Derived >

typedef internal::traits<Derived>::MatrixType Eigen::SimplicialCholeskyBase< Derived >::MatrixType

OrderingType

template<typename Derived >

typedef internal::traits<Derived>::OrderingType Eigen::SimplicialCholeskyBase< Derived >::OrderingType

RealScalar

template<typename Derived >

typedef MatrixType::RealScalar Eigen::SimplicialCholeskyBase< Derived >::RealScalar

Scalar

template<typename Derived >

typedef MatrixType::Scalar Eigen::SimplicialCholeskyBase< Derived >::Scalar

StorageIndex

template<typename Derived >

typedef MatrixType::StorageIndex Eigen::SimplicialCholeskyBase< Derived >::StorageIndex

VectorI

template<typename Derived >

typedef Matrix<StorageIndex,Dynamic,1> Eigen::SimplicialCholeskyBase< Derived >::VectorI

VectorType

template<typename Derived >

typedef Matrix<Scalar,Dynamic,1> Eigen::SimplicialCholeskyBase< Derived >::VectorType

Member Enumeration Documentation

anonymous enum

template<typename Derived >

anonymous enum

Enumerator
UpLo

{ UpLo = internal::traits<Derived>::UpLo };

anonymous enum

template<typename Derived >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

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

Constructor & Destructor Documentation

SimplicialCholeskyBase() [1/2]

template<typename Derived >

Eigen::SimplicialCholeskyBase< Derived >::SimplicialCholeskyBase ( )

inline

Default constructor

      : m_info(Success), m_shiftOffset(0), m_shiftScale(1)
    {}

SimplicialCholeskyBase() [2/2]

template<typename Derived >

Eigen::SimplicialCholeskyBase< Derived >::SimplicialCholeskyBase ( const MatrixType &  matrix )

inlineexplicit

      : m_info(Success), m_shiftOffset(0), m_shiftScale(1)
    {
      derived().compute(matrix);
    }

References Eigen::SimplicialCholeskyBase< Derived >::derived().

Here is the call graph for this function:

~SimplicialCholeskyBase()

template<typename Derived >

Eigen::SimplicialCholeskyBase< Derived >::~SimplicialCholeskyBase ( )

inline

    {
    }

Member Function Documentation

_solve_impl() [1/2]

template<typename Derived >

template<typename Rhs , typename Dest >

void Eigen::SimplicialCholeskyBase< 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()");
      eigen_assert(m_matrix.rows()==b.rows());
 
      if(m_info!=Success)
        return;
 
      if(m_P.size()>0)
        dest = m_P * b;
      else
        dest = b;
 
      if(m_matrix.nonZeros()>0) // otherwise L==I
        derived().matrixL().solveInPlace(dest);
 
      if(m_diag.size()>0)
        dest = m_diag.asDiagonal().inverse() * dest;
 
      if (m_matrix.nonZeros()>0) // otherwise U==I
        derived().matrixU().solveInPlace(dest);
 
      if(m_P.size()>0)
        dest = m_Pinv * dest;
    }

References Eigen::SimplicialCholeskyBase< Derived >::derived(), eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_diag, Eigen::SimplicialCholeskyBase< Derived >::m_factorizationIsOk, Eigen::SimplicialCholeskyBase< Derived >::m_info, Eigen::SimplicialCholeskyBase< Derived >::m_matrix, Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::SimplicialCholeskyBase< Derived >::m_Pinv, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), Eigen::PermutationBase< Derived >::size(), and Eigen::Success.

Here is the call graph for this function:

_solve_impl() [2/2]

template<typename Derived >

template<typename Rhs , typename Dest >

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

inline

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

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

Here is the call graph for this function:

analyzePattern()

template<typename Derived >

void Eigen::SimplicialCholeskyBase< Derived >::analyzePattern ( const MatrixType &  a, bool  doLDLT  )

inlineprotected

    {
      eigen_assert(a.rows()==a.cols());
      Index size = a.cols();
      CholMatrixType tmp(size,size);
      ConstCholMatrixPtr pmat;
      ordering(a, pmat, tmp);
      analyzePattern_preordered(*pmat,doLDLT);
    }

References Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered(), eigen_assert, and ordering.

Referenced by Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::analyzePattern(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::analyzePattern(), and Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::analyzePattern().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzePattern_preordered()

template<typename Derived >

void Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered ( const CholMatrixType &  a, bool  doLDLT  )

protected

{
  const StorageIndex size = StorageIndex(ap.rows());
  m_matrix.resize(size, size);
  m_parent.resize(size);
  m_nonZerosPerCol.resize(size);
 
  ei_declare_aligned_stack_constructed_variable(StorageIndex, tags, size, 0);
 
  for(StorageIndex k = 0; k < size; ++k)
  {
    /* L(k,:) pattern: all nodes reachable in etree from nz in A(0:k-1,k) */
    m_parent[k] = -1;             /* parent of k is not yet known */
    tags[k] = k;                  /* mark node k as visited */
    m_nonZerosPerCol[k] = 0;      /* count of nonzeros in column k of L */
    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
    {
      StorageIndex i = it.index();
      if(i < k)
      {
        /* follow path from i to root of etree, stop at flagged node */
        for(; tags[i] != k; i = m_parent[i])
        {
          /* find parent of i if not yet determined */
          if (m_parent[i] == -1)
            m_parent[i] = k;
          m_nonZerosPerCol[i]++;        /* L (k,i) is nonzero */
          tags[i] = k;                  /* mark i as visited */
        }
      }
    }
  }
 
  /* construct Lp index array from m_nonZerosPerCol column counts */
  StorageIndex* Lp = m_matrix.outerIndexPtr();
  Lp[0] = 0;
  for(StorageIndex k = 0; k < size; ++k)
    Lp[k+1] = Lp[k] + m_nonZerosPerCol[k] + (doLDLT ? 0 : 1);
 
  m_matrix.resizeNonZeros(Lp[size]);
 
  m_isInitialized     = true;
  m_info              = Success;
  m_analysisIsOk      = true;
  m_factorizationIsOk = false;
}

References ei_declare_aligned_stack_constructed_variable, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), and Eigen::Success.

Referenced by Eigen::SimplicialCholeskyBase< Derived >::analyzePattern(), and Eigen::SimplicialCholeskyBase< Derived >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

cols()

template<typename Derived >

Index Eigen::SimplicialCholeskyBase< Derived >::cols ( ) const

inline

{ return m_matrix.cols(); }

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), and Eigen::SimplicialCholeskyBase< Derived >::m_matrix.

Here is the call graph for this function:

compute()

template<typename Derived >

template<bool DoLDLT>

void Eigen::SimplicialCholeskyBase< Derived >::compute ( const MatrixType &  matrix )

inlineprotected

Computes the sparse Cholesky decomposition of matrix

    {
      eigen_assert(matrix.rows()==matrix.cols());
      Index size = matrix.cols();
      CholMatrixType tmp(size,size);
      ConstCholMatrixPtr pmat;
      ordering(matrix, pmat, tmp);
      analyzePattern_preordered(*pmat, DoLDLT);
      factorize_preordered<DoLDLT>(*pmat);
    }

References Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered(), eigen_assert, and ordering.

Here is the call graph for this function:

derived() [1/4]

template<typename Derived >

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

inline

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

derived() [2/4]

template<typename Derived >

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

inline

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

Referenced by Eigen::SimplicialCholeskyBase< Derived >::SimplicialCholeskyBase(), Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), and Eigen::SimplicialCholeskyBase< Derived >::setShift().

Here is the caller graph for this function:

derived() [3/4]

template<typename Derived >

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

inline

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

derived() [4/4]

template<typename Derived >

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

inline

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

dumpMemory()

template<typename Derived >

template<typename Stream >

void Eigen::SimplicialCholeskyBase< Derived >::dumpMemory ( Stream &  s )

inline

    {
      int total = 0;
      s << "  L:        " << ((total+=(m_matrix.cols()+1) * sizeof(int) + m_matrix.nonZeros()*(sizeof(int)+sizeof(Scalar))) >> 20) << "Mb" << "\n";
      s << "  diag:     " << ((total+=m_diag.size() * sizeof(Scalar)) >> 20) << "Mb" << "\n";
      s << "  tree:     " << ((total+=m_parent.size() * sizeof(int)) >> 20) << "Mb" << "\n";
      s << "  nonzeros: " << ((total+=m_nonZerosPerCol.size() * sizeof(int)) >> 20) << "Mb" << "\n";
      s << "  perm:     " << ((total+=m_P.size() * sizeof(int)) >> 20) << "Mb" << "\n";
      s << "  perm^-1:  " << ((total+=m_Pinv.size() * sizeof(int)) >> 20) << "Mb" << "\n";
      s << "  TOTAL:    " << (total>> 20) << "Mb" << "\n";
    }

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), Eigen::SimplicialCholeskyBase< Derived >::m_diag, Eigen::SimplicialCholeskyBase< Derived >::m_matrix, Eigen::SimplicialCholeskyBase< Derived >::m_nonZerosPerCol, Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::SimplicialCholeskyBase< Derived >::m_parent, Eigen::SimplicialCholeskyBase< Derived >::m_Pinv, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros(), and Eigen::PermutationBase< Derived >::size().

Here is the call graph for this function:

factorize()

template<typename Derived >

template<bool DoLDLT>

void Eigen::SimplicialCholeskyBase< Derived >::factorize ( const MatrixType &  a )

inlineprotected

    {
      eigen_assert(a.rows()==a.cols());
      Index size = a.cols();
      CholMatrixType tmp(size,size);
      ConstCholMatrixPtr pmat;
      
      if(m_P.size()==0 && (UpLo&Upper)==Upper)
      {
        // If there is no ordering, try to directly use the input matrix without any copy
        internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, tmp);
      }
      else
      {
        tmp.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
        pmat = &tmp;
      }
      
      factorize_preordered<DoLDLT>(*pmat);
    }

References eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::internal::simplicial_cholesky_grab_input< CholMatrixType, InputMatrixType >::run(), Eigen::PermutationBase< Derived >::size(), Eigen::SimplicialCholeskyBase< Derived >::UpLo, and Eigen::Upper.

Here is the call graph for this function:

factorize_preordered()

template<typename Derived >

template<bool DoLDLT>

void Eigen::SimplicialCholeskyBase< Derived >::factorize_preordered ( const CholMatrixType &  a )

protected

{
  using std::sqrt;
 
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  eigen_assert(ap.rows()==ap.cols());
  eigen_assert(m_parent.size()==ap.rows());
  eigen_assert(m_nonZerosPerCol.size()==ap.rows());
 
  const StorageIndex size = StorageIndex(ap.rows());
  const StorageIndex* Lp = m_matrix.outerIndexPtr();
  StorageIndex* Li = m_matrix.innerIndexPtr();
  Scalar* Lx = m_matrix.valuePtr();
 
  ei_declare_aligned_stack_constructed_variable(Scalar, y, size, 0);
  ei_declare_aligned_stack_constructed_variable(StorageIndex,  pattern, size, 0);
  ei_declare_aligned_stack_constructed_variable(StorageIndex,  tags, size, 0);
 
  bool ok = true;
  m_diag.resize(DoLDLT ? size : 0);
 
  for(StorageIndex k = 0; k < size; ++k)
  {
    // compute nonzero pattern of kth row of L, in topological order
    y[k] = 0.0;                     // Y(0:k) is now all zero
    StorageIndex top = size;               // stack for pattern is empty
    tags[k] = k;                    // mark node k as visited
    m_nonZerosPerCol[k] = 0;        // count of nonzeros in column k of L
    for(typename CholMatrixType::InnerIterator it(ap,k); it; ++it)
    {
      StorageIndex i = it.index();
      if(i <= k)
      {
        y[i] += numext::conj(it.value());            /* scatter A(i,k) into Y (sum duplicates) */
        Index len;
        for(len = 0; tags[i] != k; i = m_parent[i])
        {
          pattern[len++] = i;     /* L(k,i) is nonzero */
          tags[i] = k;            /* mark i as visited */
        }
        while(len > 0)
          pattern[--top] = pattern[--len];
      }
    }
 
    /* compute numerical values kth row of L (a sparse triangular solve) */
 
    RealScalar d = numext::real(y[k]) * m_shiftScale + m_shiftOffset;    // get D(k,k), apply the shift function, and clear Y(k)
    y[k] = 0.0;
    for(; top < size; ++top)
    {
      Index i = pattern[top];       /* pattern[top:n-1] is pattern of L(:,k) */
      Scalar yi = y[i];             /* get and clear Y(i) */
      y[i] = 0.0;
 
      /* the nonzero entry L(k,i) */
      Scalar l_ki;
      if(DoLDLT)
        l_ki = yi / m_diag[i];
      else
        yi = l_ki = yi / Lx[Lp[i]];
 
      Index p2 = Lp[i] + m_nonZerosPerCol[i];
      Index p;
      for(p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p)
        y[Li[p]] -= numext::conj(Lx[p]) * yi;
      d -= numext::real(l_ki * numext::conj(yi));
      Li[p] = k;                          /* store L(k,i) in column form of L */
      Lx[p] = l_ki;
      ++m_nonZerosPerCol[i];              /* increment count of nonzeros in col i */
    }
    if(DoLDLT)
    {
      m_diag[k] = d;
      if(d == RealScalar(0))
      {
        ok = false;                         /* failure, D(k,k) is zero */
        break;
      }
    }
    else
    {
      Index p = Lp[k] + m_nonZerosPerCol[k]++;
      Li[p] = k ;                /* store L(k,k) = sqrt (d) in column k */
      if(d <= RealScalar(0)) {
        ok = false;              /* failure, matrix is not positive definite */
        break;
      }
      Lx[p] = sqrt(d) ;
    }
  }
 
  m_info = ok ? Success : NumericalIssue;
  m_factorizationIsOk = true;
}

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), ei_declare_aligned_stack_constructed_variable, eigen_assert, Eigen::NumericalIssue, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), sqrt(), and Eigen::Success.

Here is the call graph for this function:

info()

template<typename Derived >

ComputationInfo Eigen::SimplicialCholeskyBase< Derived >::info ( ) const

inline

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::SimplicialCholeskyBase< Derived >::m_info, and Eigen::SimplicialCholeskyBase< Derived >::m_isInitialized.

Referenced by igl::embree::bone_heat(), igl::Frame_field_deformer::compute_optimal_positions(), igl::eigs(), and igl::Frame_field_deformer::precompute_opt().

Here is the caller graph for this function:

ordering()

template<typename Derived >

void Eigen::SimplicialCholeskyBase< Derived >::ordering ( const MatrixType &  a, ConstCholMatrixPtr &  pmat, CholMatrixType &  ap  )

protected

{
  eigen_assert(a.rows()==a.cols());
  const Index size = a.rows();
  pmat = ≈
  // Note that ordering methods compute the inverse permutation
  if(!internal::is_same<OrderingType,NaturalOrdering<Index> >::value)
  {
    {
      CholMatrixType C;
      C = a.template selfadjointView<UpLo>();
      
      OrderingType ordering;
      ordering(C,m_Pinv);
    }
 
    if(m_Pinv.size()>0) m_P = m_Pinv.inverse();
    else                m_P.resize(0);
    
    ap.resize(size,size);
    ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>().twistedBy(m_P);
  }
  else
  {
    m_Pinv.resize(0);
    m_P.resize(0);
    if(int(UpLo)==int(Lower) || MatrixType::IsRowMajor)
    {
      // we have to transpose the lower part to to the upper one
      ap.resize(size,size);
      ap.template selfadjointView<Upper>() = a.template selfadjointView<UpLo>();
    }
    else
      internal::simplicial_cholesky_grab_input<CholMatrixType,MatrixType>::run(a, pmat, ap);
  }  
}

References eigen_assert, Eigen::Lower, ordering, Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize(), and Eigen::internal::simplicial_cholesky_grab_input< CholMatrixType, InputMatrixType >::run().

Here is the call graph for this function:

permutationP()

template<typename Derived >

const PermutationMatrix< Dynamic, Dynamic, StorageIndex > & Eigen::SimplicialCholeskyBase< Derived >::permutationP ( ) const

inline

Returns

the permutation P

See also

permutationPinv()

    { return m_P; }

References Eigen::SimplicialCholeskyBase< Derived >::m_P.

permutationPinv()

template<typename Derived >

const PermutationMatrix< Dynamic, Dynamic, StorageIndex > & Eigen::SimplicialCholeskyBase< Derived >::permutationPinv ( ) const

inline

Returns

the inverse P^-1 of the permutation P

See also

permutationP()

    { return m_Pinv; }

References Eigen::SimplicialCholeskyBase< Derived >::m_Pinv.

rows()

template<typename Derived >

Index Eigen::SimplicialCholeskyBase< Derived >::rows ( ) const

inline

{ return m_matrix.rows(); }

References Eigen::SimplicialCholeskyBase< Derived >::m_matrix, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows().

Here is the call graph for this function:

setShift()

template<typename Derived >

Derived & Eigen::SimplicialCholeskyBase< Derived >::setShift ( const RealScalar &  offset, const RealScalar &  scale = 1  )

inline

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

During the numerical factorization, the diagonal coefficients are transformed by the following linear model:
d_ii = offset + scale * d_ii

The default is the identity transformation with offset=0, and scale=1.

Returns

a reference to *this.

    {
      m_shiftOffset = offset;
      m_shiftScale = scale;
      return derived();
    }

References Eigen::SimplicialCholeskyBase< Derived >::derived(), Eigen::SimplicialCholeskyBase< Derived >::m_shiftOffset, Eigen::SimplicialCholeskyBase< Derived >::m_shiftScale, and scale().

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 Derived >

bool Eigen::SimplicialCholeskyBase< Derived >::m_analysisIsOk

protected

m_diag

template<typename Derived >

VectorType Eigen::SimplicialCholeskyBase< Derived >::m_diag

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::determinant(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::determinant(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::vectorD(), and Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::vectorD().

m_factorizationIsOk

template<typename Derived >

bool Eigen::SimplicialCholeskyBase< Derived >::m_factorizationIsOk

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixL(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::matrixL(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixU(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::matrixU(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::rawMatrix(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::vectorD(), and Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::vectorD().

m_info

template<typename Derived >

ComputationInfo Eigen::SimplicialCholeskyBase< Derived >::m_info

mutableprotected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), and Eigen::SimplicialCholeskyBase< Derived >::info().

m_isInitialized

template<typename Derived >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprivate

Referenced by Eigen::SimplicialCholeskyBase< Derived >::info().

m_matrix

template<typename Derived >

CholMatrixType Eigen::SimplicialCholeskyBase< Derived >::m_matrix

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialCholeskyBase< Derived >::cols(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::determinant(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::determinant(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixL(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::matrixL(), Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixU(), Eigen::SimplicialLDLT< _MatrixType, _UpLo, _Ordering >::matrixU(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::rawMatrix(), and Eigen::SimplicialCholeskyBase< Derived >::rows().

m_nonZerosPerCol

template<typename Derived >

VectorI Eigen::SimplicialCholeskyBase< Derived >::m_nonZerosPerCol

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::dumpMemory().

m_P

template<typename Derived >

PermutationMatrix<Dynamic,Dynamic,StorageIndex> Eigen::SimplicialCholeskyBase< Derived >::m_P

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), Eigen::SimplicialCholeskyBase< Derived >::factorize(), and Eigen::SimplicialCholeskyBase< Derived >::permutationP().

m_parent

template<typename Derived >

VectorI Eigen::SimplicialCholeskyBase< Derived >::m_parent

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::dumpMemory().

m_Pinv

template<typename Derived >

PermutationMatrix<Dynamic,Dynamic,StorageIndex> Eigen::SimplicialCholeskyBase< Derived >::m_Pinv

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), and Eigen::SimplicialCholeskyBase< Derived >::permutationPinv().

m_shiftOffset

template<typename Derived >

RealScalar Eigen::SimplicialCholeskyBase< Derived >::m_shiftOffset

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::setShift().

m_shiftScale

template<typename Derived >

RealScalar Eigen::SimplicialCholeskyBase< Derived >::m_shiftScale

protected

Referenced by Eigen::SimplicialCholeskyBase< Derived >::setShift().

---

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

• src/eigen/Eigen/src/SparseCholesky/SimplicialCholesky.h
• src/eigen/Eigen/src/SparseCholesky/SimplicialCholesky_impl.h