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

A direct sparse LLT Cholesky factorizations. More...

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

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

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

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

Public Member Functions
	SimplicialLLT ()
	SimplicialLLT (const MatrixType &matrix)
const MatrixL	matrixL () const
const MatrixU	matrixU () const
SimplicialLLT &	compute (const MatrixType &matrix)
void	analyzePattern (const MatrixType &a)
void	factorize (const MatrixType &a)
Scalar	determinant () const
SimplicialLLT< _MatrixType, _UpLo, _Ordering > &	derived ()
const SimplicialLLT< _MatrixType, _UpLo, _Ordering > &	derived () const
SimplicialLLT< _MatrixType, _UpLo, _Ordering > &	derived ()
const SimplicialLLT< _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
SimplicialLLT< _MatrixType, _UpLo, _Ordering > &	setShift (const RealScalar &offset, const RealScalar &scale=1)
void	dumpMemory (Stream &s)
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) 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
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
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::SimplicialLLT< _MatrixType, _UpLo, _Ordering >

A direct sparse LLT Cholesky factorizations.

This class provides a LL^T Cholesky factorizations of sparse matrices that are selfadjoint and positive definite. The factorization allows 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

_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.
_Ordering	The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<>

\implsparsesolverconcept

See also

class SimplicialLDLT, class AMDOrdering, class NaturalOrdering

Member Typedef Documentation

Base

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

CholMatrixType

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef SparseMatrix<Scalar,ColMajor,Index> Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::CholMatrixType

ConstCholMatrixPtr

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

inherited

MatrixL

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef Traits::MatrixL Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::MatrixL

MatrixType

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

MatrixU

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef Traits::MatrixU Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::MatrixU

OrderingType

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

inherited

RealScalar

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

Scalar

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

StorageIndex

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

Traits

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

VectorI

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

inherited

VectorType

template<typename _MatrixType , int _UpLo, typename _Ordering >

typedef Matrix<Scalar,Dynamic,1> Eigen::SimplicialLLT< _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

SimplicialLLT() [1/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

inline

Default constructor

: Base() {}

SimplicialLLT() [2/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

inlineexplicit

Constructs and performs the LLT factorization of matrix

        : Base(matrix) {}

Member Function Documentation

_solve_impl() [1/2]

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _MatrixType, _UpLo, _Ordering > >::_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()");
      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;
    }

_solve_impl() [2/2]

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

inlineinherited

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

analyzePattern() [1/2]

template<typename _MatrixType , int _UpLo, typename _Ordering >

void Eigen::SimplicialLLT< _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, false);
    }

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

Here is the call graph for this function:

analyzePattern() [2/2]

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _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< SimplicialLLT< _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< SimplicialLLT< _MatrixType, _UpLo, _Ordering > >::cols ( ) const

inlineinherited

{ return m_matrix.cols(); }

compute() [1/2]

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _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 >

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

inline

Computes the sparse Cholesky decomposition of matrix

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

Referenced by igl::embree::bone_heat().

Here is the caller graph for this function:

derived() [1/4]

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

inlineinherited

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

derived() [2/4]

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

inlineinherited

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

derived() [3/4]

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

inlineinherited

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

derived() [4/4]

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

inlineinherited

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

determinant()

template<typename _MatrixType , int _UpLo, typename _Ordering >

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

inline

Returns

the determinant of the underlying matrix from the current factorization

    {
      Scalar detL = Base::m_matrix.diagonal().prod();
      return numext::abs2(detL);
    }

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

Here is the call graph for this function:

dumpMemory()

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _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< SimplicialLLT< _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::SimplicialLLT< _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()

    {
      Base::template factorize<false>(a);
    }

factorize_preordered()

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _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< SimplicialLLT< _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;
    }

matrixL()

template<typename _MatrixType , int _UpLo, typename _Ordering >

const MatrixL Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixL ( ) const

inline

Returns

an expression of the factor L

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

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

matrixU()

template<typename _MatrixType , int _UpLo, typename _Ordering >

const MatrixU Eigen::SimplicialLLT< _MatrixType, _UpLo, _Ordering >::matrixU ( ) const

inline

Returns

an expression of the factor U (= L^*)

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

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

ordering()

void Eigen::SimplicialCholeskyBase< SimplicialLLT< _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< SimplicialLLT< _MatrixType, _UpLo, _Ordering > >::permutationP ( ) const

inlineinherited

Returns

the permutation P

See also

permutationPinv()

    { return m_P; }

permutationPinv()

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

inlineinherited

Returns

the inverse P^-1 of the permutation P

See also

permutationP()

    { return m_Pinv; }

rows()

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

inlineinherited

{ return m_matrix.rows(); }

setShift()

SimplicialLLT< _MatrixType, _UpLo, _Ordering > & Eigen::SimplicialCholeskyBase< SimplicialLLT< _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());
    }

Member Data Documentation

m_analysisIsOk

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

protectedinherited

m_diag

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

protectedinherited

m_factorizationIsOk

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

protectedinherited

m_info

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

mutableprotectedinherited

m_isInitialized

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

mutableprivateinherited

m_matrix

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

protectedinherited

m_nonZerosPerCol

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

protectedinherited

m_P

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

protectedinherited

m_parent

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

protectedinherited

m_Pinv

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

protectedinherited

m_shiftOffset

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

protectedinherited

m_shiftScale

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

protectedinherited

---

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

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