Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering > Class Template Reference

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

Inheritance diagram for Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >:

Collaboration diagram for Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >:

Public Types
enum	{ UpLo = _UpLo }
typedef _MatrixType	MatrixType
typedef SimplicialCholeskyBase< SimplicialCholesky >	Base
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::StorageIndex	StorageIndex
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	CholMatrixType
typedef Matrix< Scalar, Dynamic, 1 >	VectorType
typedef internal::traits< SimplicialCholesky >	Traits
typedef internal::traits< SimplicialLDLT< MatrixType, UpLo > >	LDLTTraits
typedef internal::traits< SimplicialLLT< MatrixType, UpLo > >	LLTTraits
enum
enum
typedef internal::traits< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::OrderingType	OrderingType
typedef CholMatrixType const *	ConstCholMatrixPtr
typedef Matrix< StorageIndex, Dynamic, 1 >	VectorI

Public Member Functions
	SimplicialCholesky ()
	SimplicialCholesky (const MatrixType &matrix)
SimplicialCholesky &	setMode (SimplicialCholeskyMode mode)
const VectorType	vectorD () const
const CholMatrixType	rawMatrix () const
SimplicialCholesky &	compute (const MatrixType &matrix)
void	analyzePattern (const MatrixType &a)
void	factorize (const MatrixType &a)
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
Scalar	determinant () const
SimplicialCholesky< _MatrixType, _UpLo, _Ordering > &	derived ()
const SimplicialCholesky< _MatrixType, _UpLo, _Ordering > &	derived () const
SimplicialCholesky< _MatrixType, _UpLo, _Ordering > &	derived ()
const SimplicialCholesky< _MatrixType, _UpLo, _Ordering > &	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
SimplicialCholesky< _MatrixType, _UpLo, _Ordering > &	setShift (const RealScalar &offset, const RealScalar &scale=1)
void	dumpMemory (Stream &s)
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	compute (const MatrixType &matrix)
void	factorize (const MatrixType &a)
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
bool	m_LDLT
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 Attributes
bool	m_isInitialized

Detailed Description

template<typename _MatrixType, int _UpLo, typename _Ordering>
class Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >

See also

class SimplicialLDLT, class SimplicialLLT

Member Typedef Documentation

Base

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef SimplicialCholeskyBase<SimplicialCholesky> Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::Base

CholMatrixType

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef SparseMatrix<Scalar,ColMajor,StorageIndex> Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::CholMatrixType

ConstCholMatrixPtr

typedef CholMatrixType const* Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::ConstCholMatrixPtr

inherited

LDLTTraits

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef internal::traits<SimplicialLDLT<MatrixType,UpLo> > Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::LDLTTraits

LLTTraits

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef internal::traits<SimplicialLLT<MatrixType,UpLo> > Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::LLTTraits

MatrixType

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef _MatrixType Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::MatrixType

OrderingType

typedef internal::traits<SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::OrderingType Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::OrderingType

inherited

RealScalar

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef MatrixType::RealScalar Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::RealScalar

Scalar

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef MatrixType::Scalar Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::Scalar

StorageIndex

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef MatrixType::StorageIndex Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::StorageIndex

Traits

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef internal::traits<SimplicialCholesky> Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::Traits

VectorI

typedef Matrix<StorageIndex,Dynamic,1> Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::VectorI

inherited

VectorType

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef Matrix<Scalar,Dynamic,1> Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::VectorType

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

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

anonymous enum

anonymous enum

inherited

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

anonymous enum

template<typename _MatrixType , int _UpLo, typename _Ordering >

anonymous enum

Enumerator
UpLo

{ UpLo = _UpLo };

Constructor & Destructor Documentation

SimplicialCholesky() [1/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::SimplicialCholesky ( )

inline

: Base(), m_LDLT(true) {}

SimplicialCholesky() [2/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

inlineexplicit

      : Base(), m_LDLT(true)
    {
      compute(matrix);
    }

References Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::compute().

Here is the call graph for this function:

Member Function Documentation

_solve_impl() [1/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

template<typename Rhs , typename Dest >

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

inline

    {
      eigen_assert(Base::m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or symbolic()/numeric()");
      eigen_assert(Base::m_matrix.rows()==b.rows());
 
      if(Base::m_info!=Success)
        return;
 
      if(Base::m_P.size()>0)
        dest = Base::m_P * b;
      else
        dest = b;
 
      if(Base::m_matrix.nonZeros()>0) // otherwise L==I
      {
        if(m_LDLT)
          LDLTTraits::getL(Base::m_matrix).solveInPlace(dest);
        else
          LLTTraits::getL(Base::m_matrix).solveInPlace(dest);
      }
 
      if(Base::m_diag.size()>0)
        dest = Base::m_diag.asDiagonal().inverse() * dest;
 
      if (Base::m_matrix.nonZeros()>0) // otherwise I==I
      {
        if(m_LDLT)
          LDLTTraits::getU(Base::m_matrix).solveInPlace(dest);
        else
          LLTTraits::getU(Base::m_matrix).solveInPlace(dest);
      }
 
      if(Base::m_P.size()>0)
        dest = Base::m_Pinv * dest;
    }

References eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_diag, Eigen::SimplicialCholeskyBase< Derived >::m_factorizationIsOk, Eigen::SimplicialCholeskyBase< Derived >::m_info, Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT, Eigen::SimplicialCholeskyBase< Derived >::m_matrix, Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::SimplicialCholeskyBase< Derived >::m_Pinv, Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::rows(), and Eigen::Success.

Here is the call graph for this function:

_solve_impl() [2/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

template<typename Rhs , typename Dest >

void Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inline

    {
      internal::solve_sparse_through_dense_panels(*this, b, dest);
    }

References Eigen::internal::solve_sparse_through_dense_panels().

Here is the call graph for this function:

analyzePattern() [1/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

void Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::analyzePattern ( const MatrixType &  a )

inline

Performs a symbolic decomposition on the sparcity of matrix.

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

See also

factorize()

    {
      Base::analyzePattern(a, m_LDLT);
    }

References Eigen::SimplicialCholeskyBase< Derived >::analyzePattern(), and Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT.

Here is the call graph for this function:

analyzePattern() [2/2]

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::analyzePattern ( const MatrixType &  a, bool  doLDLT  )

inlineprotectedinherited

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

analyzePattern_preordered()

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::analyzePattern_preordered ( const CholMatrixType &  a, bool  doLDLT  )

protectedinherited

{
  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;
}

cols()

Index Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::cols ( ) const

inlineinherited

{ return m_matrix.cols(); }

compute() [1/2]

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::compute ( const MatrixType &  matrix )

inlineprotectedinherited

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);
    }

compute() [2/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

SimplicialCholesky & Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::compute ( const MatrixType &  matrix )

inline

Computes the sparse Cholesky decomposition of matrix

    {
      if(m_LDLT)
        Base::template compute<true>(matrix);
      else
        Base::template compute<false>(matrix);
      return *this;
    }

References Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT.

Referenced by Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::SimplicialCholesky(), and igl::Frame_field_deformer::precompute_opt().

Here is the caller graph for this function:

derived() [1/4]

SimplicialCholesky< _MatrixType, _UpLo, _Ordering > & Eigen::SparseSolverBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::derived ( )

inlineinherited

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

derived() [2/4]

SimplicialCholesky< _MatrixType, _UpLo, _Ordering > & Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::derived ( )

inlineinherited

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

derived() [3/4]

const SimplicialCholesky< _MatrixType, _UpLo, _Ordering > & Eigen::SparseSolverBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::derived ( ) const

inlineinherited

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

derived() [4/4]

const SimplicialCholesky< _MatrixType, _UpLo, _Ordering > & Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::derived ( ) const

inlineinherited

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

determinant()

template<typename _MatrixType , int _UpLo, typename _Ordering >

Scalar Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::determinant ( ) const

inline

    {
      if(m_LDLT)
      {
        return Base::m_diag.prod();
      }
      else
      {
        Scalar detL = Diagonal<const CholMatrixType>(Base::m_matrix).prod();
        return numext::abs2(detL);
      }
    }

References Eigen::SimplicialCholeskyBase< Derived >::m_diag, Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT, and Eigen::SimplicialCholeskyBase< Derived >::m_matrix.

dumpMemory()

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::dumpMemory ( Stream &  s )

inlineinherited

    {
      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";
    }

factorize() [1/2]

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::factorize ( const MatrixType &  a )

inlineprotectedinherited

    {
      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);
    }

factorize() [2/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

void Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::factorize ( const MatrixType &  a )

inline

Performs a numeric decomposition of matrix

The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.

See also

analyzePattern()

    {
      if(m_LDLT)
        Base::template factorize<true>(a);
      else
        Base::template factorize<false>(a);
    }

References Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT.

factorize_preordered()

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::factorize_preordered ( const CholMatrixType &  a )

protectedinherited

{
  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;
}

info()

ComputationInfo Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::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;
    }

ordering()

void Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::ordering ( const MatrixType &  a, ConstCholMatrixPtr &  pmat, CholMatrixType &  ap  )

protectedinherited

{
  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);
  }  
}

permutationP()

const PermutationMatrix< Dynamic, Dynamic, StorageIndex > & Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::permutationP ( ) const

inlineinherited

Returns

the permutation P

See also

permutationPinv()

    { return m_P; }

permutationPinv()

const PermutationMatrix< Dynamic, Dynamic, StorageIndex > & Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::permutationPinv ( ) const

inlineinherited

Returns

the inverse P^-1 of the permutation P

See also

permutationP()

    { return m_Pinv; }

rawMatrix()

template<typename _MatrixType , int _UpLo, typename _Ordering >

const CholMatrixType Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::rawMatrix ( ) const

inline

                                                  {
        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
        return Base::m_matrix;
    }

References eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_factorizationIsOk, and Eigen::SimplicialCholeskyBase< Derived >::m_matrix.

rows()

Index Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::rows ( ) const

inlineinherited

{ return m_matrix.rows(); }

setMode()

template<typename _MatrixType , int _UpLo, typename _Ordering >

SimplicialCholesky & Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::setMode ( SimplicialCholeskyMode  mode )

inline

    {
      switch(mode)
      {
      case SimplicialCholeskyLLT:
        m_LDLT = false;
        break;
      case SimplicialCholeskyLDLT:
        m_LDLT = true;
        break;
      default:
        break;
      }
 
      return *this;
    }

References Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT, Eigen::SimplicialCholeskyLDLT, and Eigen::SimplicialCholeskyLLT.

setShift()

SimplicialCholesky< _MatrixType, _UpLo, _Ordering > & Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::setShift ( const RealScalar &  offset, const RealScalar &  scale = 1  )

inlineinherited

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();
    }

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());
    }

vectorD()

template<typename _MatrixType , int _UpLo, typename _Ordering >

const VectorType Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::vectorD ( ) const

inline

                                            {
        eigen_assert(Base::m_factorizationIsOk && "Simplicial Cholesky not factorized");
        return Base::m_diag;
    }

References eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_diag, and Eigen::SimplicialCholeskyBase< Derived >::m_factorizationIsOk.

Member Data Documentation

m_analysisIsOk

bool Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_analysisIsOk

protectedinherited

m_diag

VectorType Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_diag

protectedinherited

m_factorizationIsOk

bool Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_factorizationIsOk

protectedinherited

m_info

ComputationInfo Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_info

mutableprotectedinherited

m_isInitialized

bool Eigen::SparseSolverBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_isInitialized

mutableprivateinherited

m_LDLT

template<typename _MatrixType , int _UpLo, typename _Ordering >

bool Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::m_LDLT

protected

Referenced by Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::_solve_impl(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::analyzePattern(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::compute(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::determinant(), Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::factorize(), and Eigen::SimplicialCholesky< _MatrixType, _UpLo, _Ordering >::setMode().

m_matrix

CholMatrixType Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_matrix

protectedinherited

m_nonZerosPerCol

VectorI Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_nonZerosPerCol

protectedinherited

m_P

PermutationMatrix<Dynamic,Dynamic,StorageIndex> Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_P

protectedinherited

m_parent

VectorI Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_parent

protectedinherited

m_Pinv

PermutationMatrix<Dynamic,Dynamic,StorageIndex> Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_Pinv

protectedinherited

m_shiftOffset

RealScalar Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_shiftOffset

protectedinherited

m_shiftScale

RealScalar Eigen::SimplicialCholeskyBase< SimplicialCholesky< _MatrixType, _UpLo, _Ordering > >::m_shiftScale

protectedinherited

---

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

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