Eigen::SimplicialCholeskyBase< Derived > Class Template Reference

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

#include <SimplicialCholesky.h>

Inheritance 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 internal::traits< Derived >::DiagonalScalar	DiagonalScalar
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. More...
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationP () const
const PermutationMatrix< Dynamic, Dynamic, StorageIndex > &	permutationPinv () const
Derived &	setShift (const DiagonalScalar &offset, const DiagonalScalar &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
Public Member Functions inherited from Eigen::SparseSolverBase< Derived >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
Derived &	derived ()
const Derived &	derived () const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const MatrixBase< Rhs > &b) const
template<typename Rhs >
const Solve< Derived, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
template<typename Rhs , typename Dest >
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

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

Protected Attributes
ComputationInfo	m_info
bool	m_factorizationIsOk
bool	m_analysisIsOk
CholMatrixType	m_matrix
VectorType	m_diag
VectorI	m_parent
VectorI	m_workSpace
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_P
PermutationMatrix< Dynamic, Dynamic, StorageIndex >	m_Pinv
DiagonalScalar	m_shiftOffset
DiagonalScalar	m_shiftScale
Protected Attributes inherited from Eigen::SparseSolverBase< Derived >
bool	m_isInitialized

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

DiagonalScalar

template<typename Derived >

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

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_factorizationIsOk(false), m_analysisIsOk(false), m_shiftOffset(0), m_shiftScale(1) {}

SimplicialCholeskyBase() [2/2]

template<typename Derived >

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

inlineexplicit

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

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

~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 b, 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.

_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 b, Eigen::SimplicialCholeskyBase< Derived >::derived(), and Eigen::internal::solve_sparse_through_dense_panels().

analyzePattern()

template<typename Derived >

template<bool DoLDLT, bool NonHermitian>

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

inlineprotected

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

References a, Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered(), eigen_assert, size, and tmp.

analyzePattern_preordered()

template<typename Derived >

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

protected

                                                                                                     {
  using Helper = internal::simpl_chol_helper<Scalar, StorageIndex>;
 
  eigen_assert(ap.innerSize() == ap.outerSize());
  const StorageIndex size = internal::convert_index<StorageIndex>(ap.outerSize());
 
  Helper::run(size, ap, m_matrix, m_parent, m_workSpace, doLDLT);
 
  m_isInitialized = true;
  m_info = Success;
  m_analysisIsOk = true;
  m_factorizationIsOk = false;
}

References ap, eigen_assert, run(), size, and Eigen::Success.

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

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.

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

template<bool DoLDLT, bool NonHermitian>

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<NonHermitian>(matrix, pmat, tmp);
    analyzePattern_preordered(*pmat, DoLDLT);
    factorize_preordered<DoLDLT, NonHermitian>(*pmat);
  }

References Eigen::SimplicialCholeskyBase< Derived >::analyzePattern_preordered(), eigen_assert, matrix(), size, and tmp.

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 >::_solve_impl(), Eigen::SimplicialCholeskyBase< Derived >::setShift(), and Eigen::SimplicialCholeskyBase< Derived >::SimplicialCholeskyBase().

derived() [3/4]

template<typename Derived >

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

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_workSpace.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(), int(), Eigen::SimplicialCholeskyBase< Derived >::m_diag, Eigen::SimplicialCholeskyBase< Derived >::m_matrix, Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::SimplicialCholeskyBase< Derived >::m_parent, Eigen::SimplicialCholeskyBase< Derived >::m_Pinv, Eigen::SimplicialCholeskyBase< Derived >::m_workSpace, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), s, and Eigen::PermutationBase< Derived >::size().

factorize()

template<typename Derived >

template<bool DoLDLT, bool NonHermitian>

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 && (int(UpLo) & int(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 {
      internal::permute_symm_to_symm<UpLo, Upper, NonHermitian>(a, tmp, m_P.indices().data());
      pmat = &tmp;
    }
 
    factorize_preordered<DoLDLT, NonHermitian>(*pmat);
  }

References a, eigen_assert, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, StorageIndex_ >::indices(), Eigen::SimplicialCholeskyBase< Derived >::m_P, Eigen::internal::simplicial_cholesky_grab_input< CholMatrixType, InputMatrixType >::run(), size, Eigen::PermutationBase< Derived >::size(), tmp, Eigen::SimplicialCholeskyBase< Derived >::UpLo, and Eigen::Upper.

factorize_preordered()

template<typename Derived >

template<bool DoLDLT, bool NonHermitian>

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

protected

                                                                                   {
  using std::sqrt;
  const StorageIndex size = StorageIndex(ap.rows());
 
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  eigen_assert(ap.rows() == ap.cols());
  eigen_assert(m_parent.size() == size);
  eigen_assert(m_workSpace.size() >= 3 * size);
 
  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);
  StorageIndex* nonZerosPerCol = m_workSpace.data();
  StorageIndex* pattern = m_workSpace.data() + size;
  StorageIndex* tags = m_workSpace.data() + 2 * size;
 
  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] = Scalar(0);         // Y(0:k) is now all zero
    StorageIndex top = size;  // stack for pattern is empty
    tags[k] = k;              // mark node k as visited
    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] += getSymm(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) */
 
    DiagonalScalar d =
        getDiag(y[k]) * m_shiftScale + m_shiftOffset;  // get D(k,k), apply the shift function, and clear Y(k)
    y[k] = Scalar(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] = Scalar(0);
 
      /* the nonzero entry L(k,i) */
      Scalar l_ki;
      if (DoLDLT)
        l_ki = yi / getDiag(m_diag[i]);
      else
        yi = l_ki = yi / Lx[Lp[i]];
 
      Index p2 = Lp[i] + nonZerosPerCol[i];
      Index p;
      for (p = Lp[i] + (DoLDLT ? 0 : 1); p < p2; ++p) y[Li[p]] -= getSymm(Lx[p]) * yi;
      d -= getDiag(l_ki * getSymm(yi));
      Li[p] = k; /* store L(k,i) in column form of L */
      Lx[p] = l_ki;
      ++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] + nonZerosPerCol[k]++;
      Li[p] = k; /* store L(k,k) = sqrt (d) in column k */
      if (NonHermitian ? d == RealScalar(0) : numext::real(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 ap, ei_declare_aligned_stack_constructed_variable, eigen_assert, i, k, Global_Parameters::Lx, Eigen::NumericalIssue, p, size, sqrt(), Eigen::Success, and y.

getDiag()

template<typename Derived >

DiagonalScalar Eigen::SimplicialCholeskyBase< Derived >::getDiag ( Scalar  x )

inlineprotected

{ return internal::traits<Derived>::getDiag(x); }

References plotDoE::x.

getSymm()

template<typename Derived >

Scalar Eigen::SimplicialCholeskyBase< Derived >::getSymm ( Scalar  x )

inlineprotected

{ return internal::traits<Derived>::getSymm(x); }

References plotDoE::x.

info()

template<typename Derived >

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

inline

Reports whether previous computation was successful.

Returns

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

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

References eigen_assert, Eigen::SimplicialCholeskyBase< Derived >::m_info, and Eigen::SimplicialCholeskyBase< Derived >::m_isInitialized.

ordering()

template<typename Derived >

template<bool NonHermitian>

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<StorageIndex> >::value) {
    {
      CholMatrixType C;
      internal::permute_symm_to_fullsymm<UpLo, NonHermitian>(a, C, NULL);
 
      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);
    internal::permute_symm_to_symm<UpLo, Upper, NonHermitian>(a, ap, m_P.indices().data());
  } 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);
      internal::permute_symm_to_symm<UpLo, Upper, NonHermitian>(a, ap, NULL);
    } else
      internal::simplicial_cholesky_grab_input<CholMatrixType, MatrixType>::run(a, pmat, ap);
  }
}

References a, ap, eigen_assert, Eigen::Lower, Eigen::internal::simplicial_cholesky_grab_input< CholMatrixType, InputMatrixType >::run(), size, and Eigen::value.

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

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

setShift()

template<typename Derived >

Derived& Eigen::SimplicialCholeskyBase< Derived >::setShift ( const DiagonalScalar &  offset, const DiagonalScalar &  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, and Eigen::SimplicialCholeskyBase< Derived >::m_shiftScale.

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::SimplicialNonHermitianLDLT< MatrixType_, UpLo_, Ordering_ >::determinant(), Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::determinant(), Eigen::SimplicialCholeskyBase< Derived >::dumpMemory(), Eigen::SimplicialLDLT< MatrixType_, UpLo_, Ordering_ >::vectorD(), Eigen::SimplicialNonHermitianLDLT< 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::SimplicialNonHermitianLLT< MatrixType_, UpLo_, Ordering_ >::matrixL(), Eigen::SimplicialNonHermitianLDLT< MatrixType_, UpLo_, Ordering_ >::matrixL(), Eigen::SimplicialLLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialLDLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialNonHermitianLLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialNonHermitianLDLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::rawMatrix(), Eigen::SimplicialLDLT< MatrixType_, UpLo_, Ordering_ >::vectorD(), Eigen::SimplicialNonHermitianLDLT< 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::SimplicialNonHermitianLLT< 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::SimplicialNonHermitianLLT< MatrixType_, UpLo_, Ordering_ >::matrixL(), Eigen::SimplicialNonHermitianLDLT< MatrixType_, UpLo_, Ordering_ >::matrixL(), Eigen::SimplicialLLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialLDLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialNonHermitianLLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialNonHermitianLDLT< MatrixType_, UpLo_, Ordering_ >::matrixU(), Eigen::SimplicialCholesky< MatrixType_, UpLo_, Ordering_ >::rawMatrix(), and Eigen::SimplicialCholeskyBase< Derived >::rows().

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 >

DiagonalScalar Eigen::SimplicialCholeskyBase< Derived >::m_shiftOffset

protected

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

m_shiftScale

template<typename Derived >

DiagonalScalar Eigen::SimplicialCholeskyBase< Derived >::m_shiftScale

protected

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

m_workSpace

template<typename Derived >

VectorI Eigen::SimplicialCholeskyBase< Derived >::m_workSpace

protected

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

---

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

• SimplicialCholesky.h
• SimplicialCholesky_impl.h