Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ > Class Template Reference

Modified Incomplete Cholesky with dual threshold. More...

#include <IncompleteCholesky.h>

Inheritance diagram for Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >:

Public Types
enum	{ UpLo = UpLo_ }
enum	{ ColsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic }
typedef NumTraits< Scalar >::Real	RealScalar
typedef OrderingType_	OrderingType
typedef OrderingType::PermutationType	PermutationType
typedef PermutationType::StorageIndex	StorageIndex
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	FactorType
typedef Matrix< Scalar, Dynamic, 1 >	VectorSx
typedef Matrix< RealScalar, Dynamic, 1 >	VectorRx
typedef Matrix< StorageIndex, Dynamic, 1 >	VectorIx
typedef std::vector< std::list< StorageIndex > >	VectorList

Public Member Functions
	IncompleteCholesky ()
template<typename MatrixType >
	IncompleteCholesky (const MatrixType &matrix)
EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
void	setInitialShift (RealScalar shift)
	Set the initial shift parameter \( \sigma \). More...
template<typename MatrixType >
void	analyzePattern (const MatrixType &mat)
	Computes the fill reducing permutation vector using the sparsity pattern of mat. More...
template<typename MatrixType >
void	factorize (const MatrixType &mat)
	Performs the numerical factorization of the input matrix mat. More...
template<typename MatrixType >
void	compute (const MatrixType &mat)
template<typename Rhs , typename Dest >
void	_solve_impl (const Rhs &b, Dest &x) const
const FactorType &	matrixL () const
const VectorRx &	scalingS () const
const PermutationType &	permutationP () const
RealScalar	shift () const
template<typename MatrixType_ >
void	factorize (const MatrixType_ &mat)
Public Member Functions inherited from Eigen::SparseSolverBase< IncompleteCholesky< Scalar, Lower, AMDOrdering< int > > >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
IncompleteCholesky< Scalar, Lower, AMDOrdering< int > > &	derived ()
const IncompleteCholesky< Scalar, Lower, AMDOrdering< int > > &	derived () const
const Solve< IncompleteCholesky< Scalar, Lower, AMDOrdering< int > >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< IncompleteCholesky< Scalar, Lower, AMDOrdering< int > >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< IncompleteCholesky< Scalar, UpLo_, OrderingType_ > >	Base

Protected Attributes
FactorType	m_L
VectorRx	m_scale
RealScalar	m_initialShift
bool	m_analysisIsOk
bool	m_factorizationIsOk
ComputationInfo	m_info
PermutationType	m_perm
RealScalar	m_shift
bool	m_isInitialized
Protected Attributes inherited from Eigen::SparseSolverBase< IncompleteCholesky< Scalar, Lower, AMDOrdering< int > > >
bool	m_isInitialized

Private Member Functions
void	updateList (Ref< const VectorIx > colPtr, Ref< VectorIx > rowIdx, Ref< VectorSx > vals, const Index &col, const Index &jk, VectorIx &firstElt, VectorList &listCol)

Detailed Description

template<typename Scalar, int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>
class Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >

Modified Incomplete Cholesky with dual threshold.

References : C-J. Lin and J. J. Moré, Incomplete Cholesky Factorizations with Limited memory, SIAM J. Sci. Comput. 21(1), pp. 24-45, 1999

Template Parameters

Scalar	the scalar type of the input matrices
UpLo_	The triangular part that will be used for the computations. It can be Lower or Upper. Default is Lower.
OrderingType_	The ordering method to use, either AMDOrdering<> or NaturalOrdering<>. Default is AMDOrdering<int>.

\implsparsesolverconcept

It performs the following incomplete factorization: \( S P A P' S + \sigma I \approx L L' \) where L is a lower triangular factor, S is a diagonal scaling matrix, P is a fill-in reducing permutation as computed by the ordering method, and \( \sigma \) is a shift for ensuring the decomposed matrix is positive definite.

Shifting strategy: Let \( B = S P A P' S \) be the scaled matrix on which the factorization is carried out, and \( \beta \) be the minimum value of the diagonal. If \( \beta > 0 \) then, the factorization is directly performed on the matrix B, and \sigma = 0. Otherwise, the factorization is performed on the shifted matrix \( B + \sigma I \) for a shifting factor \( \sigma \). We start with \( \sigma = \sigma_0 - \beta \), where \( \sigma_0 \) is the initial shift value as returned and set by setInitialShift() method. The default value is \( \sigma_0 = 10^{-3} \). If the factorization fails, then the shift in doubled until it succeed or a maximum of ten attempts. If it still fails, as returned by the info() method, then you can either increase the initial shift, or better use another preconditioning technique.

Member Typedef Documentation

Base

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef SparseSolverBase<IncompleteCholesky<Scalar, UpLo_, OrderingType_> > Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::Base

protected

FactorType

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef SparseMatrix<Scalar, ColMajor, StorageIndex> Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::FactorType

OrderingType

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef OrderingType_ Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::OrderingType

PermutationType

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef OrderingType::PermutationType Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::PermutationType

RealScalar

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef NumTraits<Scalar>::Real Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::RealScalar

StorageIndex

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef PermutationType::StorageIndex Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::StorageIndex

VectorIx

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef Matrix<StorageIndex, Dynamic, 1> Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::VectorIx

VectorList

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef std::vector<std::list<StorageIndex> > Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::VectorList

VectorRx

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef Matrix<RealScalar, Dynamic, 1> Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::VectorRx

VectorSx

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

typedef Matrix<Scalar, Dynamic, 1> Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::VectorSx

Member Enumeration Documentation

anonymous enum

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

anonymous enum

Enumerator
UpLo

{ UpLo = UpLo_ };

anonymous enum

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

{ ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

Constructor & Destructor Documentation

IncompleteCholesky() [1/2]

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::IncompleteCholesky ( )

inline

Default constructor leaving the object in a partly non-initialized stage.

You must call compute() or the pair analyzePattern()/factorize() to make it valid.

See also

IncompleteCholesky(const MatrixType&)

: m_initialShift(1e-3), m_analysisIsOk(false), m_factorizationIsOk(false) {}

IncompleteCholesky() [2/2]

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename MatrixType >

Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::IncompleteCholesky ( const MatrixType &  matrix )

inline

Constructor computing the incomplete factorization for the given matrix matrix.

      : m_initialShift(1e-3), m_analysisIsOk(false), m_factorizationIsOk(false) {
    compute(matrix);
  }

References Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::compute(), and matrix().

Member Function Documentation

_solve_impl()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename Rhs , typename Dest >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::_solve_impl ( const Rhs &  b, Dest &  x  ) const

inline

                                                {
    eigen_assert(m_factorizationIsOk && "factorize() should be called first");
    if (m_perm.rows() == b.rows())
      x = m_perm * b;
    else
      x = b;
    x = m_scale.asDiagonal() * x;
    x = m_L.template triangularView<Lower>().solve(x);
    x = m_L.adjoint().template triangularView<Upper>().solve(x);
    x = m_scale.asDiagonal() * x;
    if (m_perm.rows() == b.rows()) x = m_perm.inverse() * x;
  }

References Eigen::SparseMatrixBase< Derived >::adjoint(), b, eigen_assert, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_factorizationIsOk, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_perm, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_scale, and plotDoE::x.

analyzePattern()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename MatrixType >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern ( const MatrixType &  mat )

inline

Computes the fill reducing permutation vector using the sparsity pattern of mat.

                                             {
    OrderingType ord;
    PermutationType pinv;
    ord(mat.template selfadjointView<UpLo>(), pinv);
    if (pinv.size() > 0)
      m_perm = pinv.inverse();
    else
      m_perm.resize(0);
    m_L.resize(mat.rows(), mat.cols());
    m_analysisIsOk = true;
    m_isInitialized = true;
    m_info = Success;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_analysisIsOk, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_info, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_isInitialized, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_perm, Global_Physical_Variables::pinv, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::resize(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), and Eigen::Success.

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::compute().

cols()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

EIGEN_CONSTEXPR Index Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::cols ( ) const

inline

Returns

number of columns of the factored matrix

{ return m_L.cols(); }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L.

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 Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename MatrixType >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::compute ( const MatrixType &  mat )

inline

Computes or re-computes the incomplete Cholesky factorization of the input matrix mat

It is a shortcut for a sequential call to the analyzePattern() and factorize() methods.

See also

analyzePattern(), factorize()

                                      {
    analyzePattern(mat);
    factorize(mat);
  }

References Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize().

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::IncompleteCholesky().

factorize() [1/2]

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename MatrixType >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize

(

const MatrixType &

mat

)

Performs the numerical factorization of the input matrix mat.

The method analyzePattern() or compute() must have been called beforehand with a matrix having the same pattern.

See also

compute(), analyzePattern()

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::compute().

factorize() [2/2]

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

template<typename MatrixType_ >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::factorize

(

const MatrixType_ &

mat

)

                                                                                      {
  using std::sqrt;
  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first");
 
  // Dropping strategy : Keep only the p largest elements per column, where p is the number of elements in the column of
  // the original matrix. Other strategies will be added
 
  // Apply the fill-reducing permutation computed in analyzePattern()
  if (m_perm.rows() == mat.rows())  // To detect the null permutation
  {
    // The temporary is needed to make sure that the diagonal entry is properly sorted
    FactorType tmp(mat.rows(), mat.cols());
    tmp = mat.template selfadjointView<UpLo_>().twistedBy(m_perm);
    m_L.template selfadjointView<Lower>() = tmp.template selfadjointView<Lower>();
  } else {
    m_L.template selfadjointView<Lower>() = mat.template selfadjointView<UpLo_>();
  }
 
  // The algorithm will insert increasingly large shifts on the diagonal until
  // factorization succeeds. Therefore we have to make sure that there is a
  // space in the datastructure to store such values, even if the original
  // matrix has a zero on the diagonal.
  bool modified = false;
  for (Index i = 0; i < mat.cols(); ++i) {
    bool inserted = false;
    m_L.findOrInsertCoeff(i, i, &inserted);
    if (inserted) {
      modified = true;
    }
  }
  if (modified) m_L.makeCompressed();
 
  Index n = m_L.cols();
  Index nnz = m_L.nonZeros();
  Map<VectorSx> vals(m_L.valuePtr(), nnz);           // values
  Map<VectorIx> rowIdx(m_L.innerIndexPtr(), nnz);    // Row indices
  Map<VectorIx> colPtr(m_L.outerIndexPtr(), n + 1);  // Pointer to the beginning of each row
  VectorIx firstElt(n - 1);  // for each j, points to the next entry in vals that will be used in the factorization
  VectorList listCol(n);     // listCol(j) is a linked list of columns to update column j
  VectorSx col_vals(n);      // Store a  nonzero values in each column
  VectorIx col_irow(n);      // Row indices of nonzero elements in each column
  VectorIx col_pattern(n);
  col_pattern.fill(-1);
  StorageIndex col_nnz;
 
  // Computes the scaling factors
  m_scale.resize(n);
  m_scale.setZero();
  for (Index j = 0; j < n; j++)
    for (Index k = colPtr[j]; k < colPtr[j + 1]; k++) {
      m_scale(j) += numext::abs2(vals(k));
      if (rowIdx[k] != j) m_scale(rowIdx[k]) += numext::abs2(vals(k));
    }
 
  m_scale = m_scale.cwiseSqrt().cwiseSqrt();
 
  for (Index j = 0; j < n; ++j)
    if (m_scale(j) > (std::numeric_limits<RealScalar>::min)())
      m_scale(j) = RealScalar(1) / m_scale(j);
    else
      m_scale(j) = 1;
 
  // TODO disable scaling if not needed, i.e., if it is roughly uniform? (this will make solve() faster)
 
  // Scale and compute the shift for the matrix
  RealScalar mindiag = NumTraits<RealScalar>::highest();
  for (Index j = 0; j < n; j++) {
    for (Index k = colPtr[j]; k < colPtr[j + 1]; k++) vals[k] *= (m_scale(j) * m_scale(rowIdx[k]));
    eigen_internal_assert(rowIdx[colPtr[j]] == j &&
                          "IncompleteCholesky: only the lower triangular part must be stored");
    mindiag = numext::mini(numext::real(vals[colPtr[j]]), mindiag);
  }
 
  FactorType L_save = m_L;
 
  m_shift = RealScalar(0);
  if (mindiag <= RealScalar(0.)) m_shift = m_initialShift - mindiag;
 
  m_info = NumericalIssue;
 
  // Try to perform the incomplete factorization using the current shift
  int iter = 0;
  do {
    // Apply the shift to the diagonal elements of the matrix
    for (Index j = 0; j < n; j++) vals[colPtr[j]] += m_shift;
 
    // jki version of the Cholesky factorization
    Index j = 0;
    for (; j < n; ++j) {
      // Left-looking factorization of the j-th column
      // First, load the j-th column into col_vals
      Scalar diag = vals[colPtr[j]];  // It is assumed that only the lower part is stored
      col_nnz = 0;
      for (Index i = colPtr[j] + 1; i < colPtr[j + 1]; i++) {
        StorageIndex l = rowIdx[i];
        col_vals(col_nnz) = vals[i];
        col_irow(col_nnz) = l;
        col_pattern(l) = col_nnz;
        col_nnz++;
      }
      {
        typename std::list<StorageIndex>::iterator k;
        // Browse all previous columns that will update column j
        for (k = listCol[j].begin(); k != listCol[j].end(); k++) {
          Index jk = firstElt(*k);  // First element to use in the column
          eigen_internal_assert(rowIdx[jk] == j);
          Scalar v_j_jk = numext::conj(vals[jk]);
 
          jk += 1;
          for (Index i = jk; i < colPtr[*k + 1]; i++) {
            StorageIndex l = rowIdx[i];
            if (col_pattern[l] < 0) {
              col_vals(col_nnz) = vals[i] * v_j_jk;
              col_irow[col_nnz] = l;
              col_pattern(l) = col_nnz;
              col_nnz++;
            } else
              col_vals(col_pattern[l]) -= vals[i] * v_j_jk;
          }
          updateList(colPtr, rowIdx, vals, *k, jk, firstElt, listCol);
        }
      }
 
      // Scale the current column
      if (numext::real(diag) <= 0) {
        if (++iter >= 10) return;
 
        // increase shift
        m_shift = numext::maxi(m_initialShift, RealScalar(2) * m_shift);
        // restore m_L, col_pattern, and listCol
        vals = Map<const VectorSx>(L_save.valuePtr(), nnz);
        rowIdx = Map<const VectorIx>(L_save.innerIndexPtr(), nnz);
        colPtr = Map<const VectorIx>(L_save.outerIndexPtr(), n + 1);
        col_pattern.fill(-1);
        for (Index i = 0; i < n; ++i) listCol[i].clear();
 
        break;
      }
 
      RealScalar rdiag = sqrt(numext::real(diag));
      vals[colPtr[j]] = rdiag;
      for (Index k = 0; k < col_nnz; ++k) {
        Index i = col_irow[k];
        // Scale
        col_vals(k) /= rdiag;
        // Update the remaining diagonals with col_vals
        vals[colPtr[i]] -= numext::abs2(col_vals(k));
      }
      // Select the largest p elements
      // p is the original number of elements in the column (without the diagonal)
      Index p = colPtr[j + 1] - colPtr[j] - 1;
      Ref<VectorSx> cvals = col_vals.head(col_nnz);
      Ref<VectorIx> cirow = col_irow.head(col_nnz);
      internal::QuickSplit(cvals, cirow, p);
      // Insert the largest p elements in the matrix
      Index cpt = 0;
      for (Index i = colPtr[j] + 1; i < colPtr[j + 1]; i++) {
        vals[i] = col_vals(cpt);
        rowIdx[i] = col_irow(cpt);
        // restore col_pattern:
        col_pattern(col_irow(cpt)) = -1;
        cpt++;
      }
      // Get the first smallest row index and put it after the diagonal element
      Index jk = colPtr(j) + 1;
      updateList(colPtr, rowIdx, vals, j, jk, firstElt, listCol);
    }
 
    if (j == n) {
      m_factorizationIsOk = true;
      m_info = Success;
    }
  } while (m_info != Success);
}

References Eigen::numext::abs2(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), conj(), diag, eigen_assert, eigen_internal_assert, i, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr(), j, k, Eigen::numext::maxi(), min, Eigen::numext::mini(), n, Eigen::NumericalIssue, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerIndexPtr(), p, Eigen::internal::QuickSplit(), Eigen::PlainObjectBase< Derived >::resize(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), sqrt(), Eigen::Success, tmp, Eigen::SparseMatrixBase< Derived >::twistedBy(), and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr().

info()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

ComputationInfo Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::info ( ) const

inline

Reports whether previous computation was successful.

It triggers an assertion if *this has not been initialized through the respective constructor, or a call to compute() or analyzePattern().

Returns

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

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

References eigen_assert, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_info, and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_isInitialized.

matrixL()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

const FactorType& Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::matrixL ( ) const

inline

Returns

the sparse lower triangular factor L

                                    {
    eigen_assert(m_factorizationIsOk && "factorize() should be called first");
    return m_L;
  }

References eigen_assert, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_factorizationIsOk, and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L.

permutationP()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

const PermutationType& Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::permutationP ( ) const

inline

Returns

the fill-in reducing permutation P (can be empty for a natural ordering)

                                              {
    eigen_assert(m_analysisIsOk && "analyzePattern() should be called first");
    return m_perm;
  }

References eigen_assert, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_analysisIsOk, and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_perm.

rows()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

EIGEN_CONSTEXPR Index Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::rows ( ) const

inline

Returns

number of rows of the factored matrix

{ return m_L.rows(); }

References Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows().

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().

scalingS()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

const VectorRx& Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::scalingS ( ) const

inline

Returns

a vector representing the scaling factor S

                                   {
    eigen_assert(m_factorizationIsOk && "factorize() should be called first");
    return m_scale;
  }

References eigen_assert, Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_factorizationIsOk, and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_scale.

setInitialShift()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::setInitialShift ( RealScalar  shift )

inline

Set the initial shift parameter \( \sigma \).

{ m_initialShift = shift; }

References Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_initialShift, and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::shift().

shift()

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

RealScalar Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::shift ( ) const

inline

Returns

the final shift parameter from the computation

{ return m_shift; }

References Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_shift.

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::setInitialShift().

updateList()

template<typename Scalar , int UpLo_, typename OrderingType >

void Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType >::updateList ( Ref< const VectorIx >  colPtr, Ref< VectorIx >  rowIdx, Ref< VectorSx >  vals, const Index &  col, const Index &  jk, VectorIx &  firstElt, VectorList &  listCol  )

inlineprivate

                                                                                                                 {
  if (jk < colPtr(col + 1)) {
    Index p = colPtr(col + 1) - jk;
    Index minpos;
    rowIdx.segment(jk, p).minCoeff(&minpos);
    minpos += jk;
    if (rowIdx(minpos) != rowIdx(jk)) {
      // Swap
      std::swap(rowIdx(jk), rowIdx(minpos));
      std::swap(vals(jk), vals(minpos));
    }
    firstElt(col) = internal::convert_index<StorageIndex, Index>(jk);
    listCol[rowIdx(jk)].push_back(internal::convert_index<StorageIndex, Index>(col));
  }
}

References col(), p, and swap().

Member Data Documentation

m_analysisIsOk

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

bool Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_analysisIsOk

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::permutationP().

m_factorizationIsOk

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

bool Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_factorizationIsOk

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::_solve_impl(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::matrixL(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::scalingS().

m_info

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

ComputationInfo Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_info

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::info().

m_initialShift

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

RealScalar Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_initialShift

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::setInitialShift().

m_isInitialized

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::info().

m_L

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

FactorType Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_L

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::_solve_impl(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::cols(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::matrixL(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::rows().

m_perm

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

PermutationType Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_perm

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::_solve_impl(), Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::analyzePattern(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::permutationP().

m_scale

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

VectorRx Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_scale

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::_solve_impl(), and Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::scalingS().

m_shift

template<typename Scalar , int UpLo_ = Lower, typename OrderingType_ = AMDOrdering<int>>

RealScalar Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::m_shift

protected

Referenced by Eigen::IncompleteCholesky< Scalar, UpLo_, OrderingType_ >::shift().

---

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

• IncompleteCholesky.h