Eigen::IncompleteLU< Scalar_ > Class Template Reference

#include <IncompleteLU.h>

Inheritance diagram for Eigen::IncompleteLU< Scalar_ >:

Public Types
typedef Matrix< Scalar, Dynamic, Dynamic >	MatrixType

Public Member Functions
	IncompleteLU ()
template<typename MatrixType >
	IncompleteLU (const MatrixType &mat)
Index	rows () const
Index	cols () const
template<typename MatrixType >
IncompleteLU &	compute (const MatrixType &mat)
template<typename Rhs , typename Dest >
void	_solve_impl (const Rhs &b, Dest &x) const
Public Member Functions inherited from Eigen::SparseSolverBase< IncompleteLU< Scalar_ > >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
IncompleteLU< Scalar_ > &	derived ()
const IncompleteLU< Scalar_ > &	derived () const
const Solve< IncompleteLU< Scalar_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< IncompleteLU< Scalar_ >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< IncompleteLU< Scalar_ > >	Base
typedef Scalar_	Scalar
typedef Matrix< Scalar, Dynamic, 1 >	Vector
typedef Vector::Index	Index
typedef SparseMatrix< Scalar, RowMajor >	FactorType

Protected Attributes
FactorType	m_lu
Protected Attributes inherited from Eigen::SparseSolverBase< IncompleteLU< Scalar_ > >
bool	m_isInitialized

Member Typedef Documentation

Base

template<typename Scalar_ >

typedef SparseSolverBase<IncompleteLU<Scalar_> > Eigen::IncompleteLU< Scalar_ >::Base

protected

FactorType

template<typename Scalar_ >

typedef SparseMatrix<Scalar, RowMajor> Eigen::IncompleteLU< Scalar_ >::FactorType

protected

Index

template<typename Scalar_ >

typedef Vector::Index Eigen::IncompleteLU< Scalar_ >::Index

protected

MatrixType

template<typename Scalar_ >

typedef Matrix<Scalar, Dynamic, Dynamic> Eigen::IncompleteLU< Scalar_ >::MatrixType

Scalar

template<typename Scalar_ >

typedef Scalar_ Eigen::IncompleteLU< Scalar_ >::Scalar

protected

Vector

template<typename Scalar_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::IncompleteLU< Scalar_ >::Vector

protected

Constructor & Destructor Documentation

IncompleteLU() [1/2]

template<typename Scalar_ >

Eigen::IncompleteLU< Scalar_ >::IncompleteLU ( )

inline

{}

IncompleteLU() [2/2]

template<typename Scalar_ >

template<typename MatrixType >

Eigen::IncompleteLU< Scalar_ >::IncompleteLU ( const MatrixType &  mat )

inline

                                      {
    compute(mat);
  }

References Eigen::IncompleteLU< Scalar_ >::compute().

Member Function Documentation

_solve_impl()

template<typename Scalar_ >

template<typename Rhs , typename Dest >

void Eigen::IncompleteLU< Scalar_ >::_solve_impl ( const Rhs &  b, Dest &  x  ) const

inline

                                                {
    x = m_lu.template triangularView<UnitLower>().solve(b);
    x = m_lu.template triangularView<Upper>().solve(x);
  }

References b, Eigen::IncompleteLU< Scalar_ >::m_lu, and plotDoE::x.

cols()

template<typename Scalar_ >

Index Eigen::IncompleteLU< Scalar_ >::cols ( ) const

inline

{ return m_lu.cols(); }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), and Eigen::IncompleteLU< Scalar_ >::m_lu.

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

template<typename MatrixType >

IncompleteLU& Eigen::IncompleteLU< Scalar_ >::compute ( const MatrixType &  mat )

inline

                                               {
    m_lu = mat;
    int size = mat.cols();
    Vector diag(size);
    for (int i = 0; i < size; ++i) {
      typename FactorType::InnerIterator k_it(m_lu, i);
      for (; k_it && k_it.index() < i; ++k_it) {
        int k = k_it.index();
        k_it.valueRef() /= diag(k);
 
        typename FactorType::InnerIterator j_it(k_it);
        typename FactorType::InnerIterator kj_it(m_lu, k);
        while (kj_it && kj_it.index() <= k) ++kj_it;
        for (++j_it; j_it;) {
          if (kj_it.index() == j_it.index()) {
            j_it.valueRef() -= k_it.value() * kj_it.value();
            ++j_it;
            ++kj_it;
          } else if (kj_it.index() < j_it.index())
            ++kj_it;
          else
            ++j_it;
        }
      }
      if (k_it && k_it.index() == i)
        diag(i) = k_it.value();
      else
        diag(i) = 1;
    }
    m_isInitialized = true;
    return *this;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), diag, i, k, Eigen::SparseSolverBase< IncompleteLU< Scalar_ > >::m_isInitialized, Eigen::IncompleteLU< Scalar_ >::m_lu, and size.

Referenced by Eigen::IncompleteLU< Scalar_ >::IncompleteLU().

rows()

template<typename Scalar_ >

Index Eigen::IncompleteLU< Scalar_ >::rows ( ) const

inline

{ return m_lu.rows(); }

References Eigen::IncompleteLU< Scalar_ >::m_lu, 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().

Member Data Documentation

m_lu

template<typename Scalar_ >

FactorType Eigen::IncompleteLU< Scalar_ >::m_lu

protected

Referenced by Eigen::IncompleteLU< Scalar_ >::_solve_impl(), Eigen::IncompleteLU< Scalar_ >::cols(), Eigen::IncompleteLU< Scalar_ >::compute(), and Eigen::IncompleteLU< Scalar_ >::rows().

---

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

• IncompleteLU.h