Eigen::SuperLU< _MatrixType > Class Template Reference

A sparse direct LU factorization and solver based on the SuperLU library. More...

#include <src/eigen/Eigen/src/SuperLUSupport/SuperLUSupport.h>

Inheritance diagram for Eigen::SuperLU< _MatrixType >:

Collaboration diagram for Eigen::SuperLU< _MatrixType >:

Public Types
typedef SuperLUBase< _MatrixType, SuperLU >	Base
typedef _MatrixType	MatrixType
typedef Base::Scalar	Scalar
typedef Base::RealScalar	RealScalar
typedef Base::StorageIndex	StorageIndex
typedef Base::IntRowVectorType	IntRowVectorType
typedef Base::IntColVectorType	IntColVectorType
typedef Base::PermutationMap	PermutationMap
typedef Base::LUMatrixType	LUMatrixType
typedef TriangularView< LUMatrixType, Lower|UnitDiag >	LMatrixType
typedef TriangularView< LUMatrixType, Upper >	UMatrixType
enum
typedef Matrix< Scalar, Dynamic, 1 >	Vector

Public Member Functions
	SuperLU ()
	SuperLU (const MatrixType &matrix)
	~SuperLU ()
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
const LMatrixType &	matrixL () const
const UMatrixType &	matrixU () const
const IntColVectorType &	permutationP () const
const IntRowVectorType &	permutationQ () const
Scalar	determinant () const
Index	rows () const
Index	cols () const
superlu_options_t &	options ()
ComputationInfo	info () const
	Reports whether previous computation was successful.
void	compute (const MatrixType &matrix)
void	dumpMemory (Stream &)
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
void	init ()
void	initFactorization (const MatrixType &a)
void	extractData () const
void	clearFactors ()
SuperLU< _MatrixType > &	derived ()
const SuperLU< _MatrixType > &	derived () const

Protected Attributes
LUMatrixType	m_matrix
superlu_options_t	m_sluOptions
SluMatrix	m_sluA
SluMatrix	m_sluB
SluMatrix	m_sluX
IntColVectorType	m_p
IntRowVectorType	m_q
std::vector< int >	m_sluEtree
char	m_sluEqued
Matrix< RealScalar, Dynamic, 1 >	m_sluRscale
Matrix< RealScalar, Dynamic, 1 >	m_sluCscale
SuperMatrix	m_sluL
SuperMatrix	m_sluU
SuperLUStat_t	m_sluStat
Matrix< RealScalar, Dynamic, 1 >	m_sluFerr
Matrix< RealScalar, Dynamic, 1 >	m_sluBerr
LUMatrixType	m_l
LUMatrixType	m_u
int	m_analysisIsOk
int	m_factorizationIsOk
bool	m_extractedDataAreDirty
bool	m_isInitialized
ComputationInfo	m_info

Private Member Functions
	SuperLU (SuperLU &)

Detailed Description

template<typename _MatrixType>
class Eigen::SuperLU< _MatrixType >

A sparse direct LU factorization and solver based on the SuperLU library.

This class allows to solve for A.X = B sparse linear problems via a direct LU factorization using the SuperLU library. The sparse matrix A must be squared and invertible. The vectors or matrices X and B can be either dense or sparse.

Template Parameters

_MatrixType

the type of the sparse matrix A, it must be a SparseMatrix<>

Warning

This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.

\implsparsesolverconcept

See also

TutorialSparseSolverConcept, class SparseLU

Member Typedef Documentation

Base

template<typename _MatrixType >

typedef SuperLUBase<_MatrixType,SuperLU> Eigen::SuperLU< _MatrixType >::Base

IntColVectorType

template<typename _MatrixType >

typedef Base::IntColVectorType Eigen::SuperLU< _MatrixType >::IntColVectorType

IntRowVectorType

template<typename _MatrixType >

typedef Base::IntRowVectorType Eigen::SuperLU< _MatrixType >::IntRowVectorType

LMatrixType

template<typename _MatrixType >

typedef TriangularView<LUMatrixType, Lower|UnitDiag> Eigen::SuperLU< _MatrixType >::LMatrixType

LUMatrixType

template<typename _MatrixType >

typedef Base::LUMatrixType Eigen::SuperLU< _MatrixType >::LUMatrixType

MatrixType

template<typename _MatrixType >

typedef _MatrixType Eigen::SuperLU< _MatrixType >::MatrixType

PermutationMap

template<typename _MatrixType >

typedef Base::PermutationMap Eigen::SuperLU< _MatrixType >::PermutationMap

RealScalar

template<typename _MatrixType >

typedef Base::RealScalar Eigen::SuperLU< _MatrixType >::RealScalar

Scalar

template<typename _MatrixType >

typedef Base::Scalar Eigen::SuperLU< _MatrixType >::Scalar

StorageIndex

template<typename _MatrixType >

typedef Base::StorageIndex Eigen::SuperLU< _MatrixType >::StorageIndex

UMatrixType

template<typename _MatrixType >

typedef TriangularView<LUMatrixType, Upper> Eigen::SuperLU< _MatrixType >::UMatrixType

Vector

typedef Matrix<Scalar,Dynamic,1> Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::Vector

inherited

Member Enumeration Documentation

anonymous enum

anonymous enum

inherited

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

Constructor & Destructor Documentation

SuperLU() [1/3]

template<typename _MatrixType >

Eigen::SuperLU< _MatrixType >::SuperLU ( )

inline

: Base() { init(); }

References Eigen::SuperLU< _MatrixType >::init().

Here is the call graph for this function:

SuperLU() [2/3]

template<typename _MatrixType >

Eigen::SuperLU< _MatrixType >::SuperLU ( const MatrixType &  matrix )

inlineexplicit

                                               : Base()
    {
      init();
      Base::compute(matrix);
    }

References Eigen::SuperLUBase< _MatrixType, Derived >::compute(), and Eigen::SuperLU< _MatrixType >::init().

Here is the call graph for this function:

~SuperLU()

template<typename _MatrixType >

Eigen::SuperLU< _MatrixType >::~SuperLU ( )

inline

    {
    }

SuperLU() [3/3]

template<typename _MatrixType >

Eigen::SuperLU< _MatrixType >::SuperLU ( SuperLU< _MatrixType > &  )

inlineprivate

{ }

Member Function Documentation

_solve_impl() [1/2]

template<typename MatrixType >

template<typename Rhs , typename Dest >

void Eigen::SuperLU< MatrixType >::_solve_impl	(	const MatrixBase< Rhs > &	b,
		MatrixBase< Dest > &	dest
	)		const

{
  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for solving, you must first call either compute() or analyzePattern()/factorize()");
 
  const Index size = m_matrix.rows();
  const Index rhsCols = b.cols();
  eigen_assert(size==b.rows());
 
  m_sluOptions.Trans = NOTRANS;
  m_sluOptions.Fact = FACTORED;
  m_sluOptions.IterRefine = NOREFINE;
  
 
  m_sluFerr.resize(rhsCols);
  m_sluBerr.resize(rhsCols);
  
  Ref<const Matrix<typename Rhs::Scalar,Dynamic,Dynamic,ColMajor> > b_ref(b);
  Ref<const Matrix<typename Dest::Scalar,Dynamic,Dynamic,ColMajor> > x_ref(x);
  
  m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
  m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
  
  typename Rhs::PlainObject b_cpy;
  if(m_sluEqued!='N')
  {
    b_cpy = b;
    m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());  
  }
 
  StatInit(&m_sluStat);
  int info = 0;
  RealScalar recip_pivot_growth, rcond;
  SuperLU_gssvx(&m_sluOptions, &m_sluA,
                m_q.data(), m_p.data(),
                &m_sluEtree[0], &m_sluEqued,
                &m_sluRscale[0], &m_sluCscale[0],
                &m_sluL, &m_sluU,
                NULL, 0,
                &m_sluB, &m_sluX,
                &recip_pivot_growth, &rcond,
                &m_sluFerr[0], &m_sluBerr[0],
                &m_sluStat, &info, Scalar());
  StatFree(&m_sluStat);
  
  if(x.derived().data() != x_ref.data())
    x = x_ref;
  
  m_info = info==0 ? Success : NumericalIssue;
}

References eigen_assert, Eigen::SluMatrix::Map(), Eigen::NumericalIssue, and Eigen::Success.

Here is the call graph for this function:

_solve_impl() [2/2]

template<typename Derived >

template<typename Rhs , typename Dest >

void Eigen::SparseSolverBase< Derived >::_solve_impl ( const SparseMatrixBase< Rhs > &  b, SparseMatrixBase< Dest > &  dest  ) const

inlineinherited

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

References Eigen::SparseSolverBase< Derived >::derived(), Eigen::SparseMatrixBase< Derived >::derived(), and Eigen::internal::solve_sparse_through_dense_panels().

Here is the call graph for this function:

analyzePattern()

template<typename _MatrixType >

void Eigen::SuperLU< _MatrixType >::analyzePattern ( const MatrixType &  matrix )

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

    {
      m_info = InvalidInput;
      m_isInitialized = false;
      Base::analyzePattern(matrix);
    }

References Eigen::SuperLUBase< _MatrixType, Derived >::analyzePattern(), Eigen::InvalidInput, Eigen::SuperLU< _MatrixType >::m_info, and Eigen::SuperLU< _MatrixType >::m_isInitialized.

Here is the call graph for this function:

clearFactors()

void Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::clearFactors ( )

inlineprotectedinherited

    {
      if(m_sluL.Store)
        Destroy_SuperNode_Matrix(&m_sluL);
      if(m_sluU.Store)
        Destroy_CompCol_Matrix(&m_sluU);
 
      m_sluL.Store = 0;
      m_sluU.Store = 0;
 
      memset(&m_sluL,0,sizeof m_sluL);
      memset(&m_sluU,0,sizeof m_sluU);
    }

cols()

Index Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::cols ( ) const

inlineinherited

{ return m_matrix.cols(); }

compute()

void Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::compute ( const MatrixType &  matrix )

inlineinherited

Computes the sparse Cholesky decomposition of matrix

    {
      derived().analyzePattern(matrix);
      derived().factorize(matrix);
    }

derived() [1/2]

SuperLU< _MatrixType > & Eigen::SparseSolverBase< SuperLU< _MatrixType > >::derived ( )

inlineprotectedinherited

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

derived() [2/2]

const SuperLU< _MatrixType > & Eigen::SparseSolverBase< SuperLU< _MatrixType > >::derived ( ) const

inlineprotectedinherited

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

determinant()

template<typename MatrixType >

SuperLU< MatrixType >::Scalar Eigen::SuperLU< MatrixType >::determinant

{
  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for computing the determinant, you must first call either compute() or analyzePattern()/factorize()");
  
  if (m_extractedDataAreDirty)
    this->extractData();
 
  Scalar det = Scalar(1);
  for (int j=0; j<m_u.cols(); ++j)
  {
    if (m_u.outerIndexPtr()[j+1]-m_u.outerIndexPtr()[j] > 0)
    {
      int lastId = m_u.outerIndexPtr()[j+1]-1;
      eigen_assert(m_u.innerIndexPtr()[lastId]<=j);
      if (m_u.innerIndexPtr()[lastId]==j)
        det *= m_u.valuePtr()[lastId];
    }
  }
  if(PermutationMap(m_p.data(),m_p.size()).determinant()*PermutationMap(m_q.data(),m_q.size()).determinant()<0)
    det = -det;
  if(m_sluEqued!='N')
    return det/m_sluRscale.prod()/m_sluCscale.prod();
  else
    return det;
}

References eigen_assert.

dumpMemory()

void Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::dumpMemory ( Stream &  )

inlineinherited

    {}

extractData()

void Eigen::SuperLUBase< MatrixType, SuperLU< _MatrixType > >::extractData

protectedinherited

{
  eigen_assert(m_factorizationIsOk && "The decomposition is not in a valid state for extracting factors, you must first call either compute() or analyzePattern()/factorize()");
  if (m_extractedDataAreDirty)
  {
    int         upper;
    int         fsupc, istart, nsupr;
    int         lastl = 0, lastu = 0;
    SCformat    *Lstore = static_cast<SCformat*>(m_sluL.Store);
    NCformat    *Ustore = static_cast<NCformat*>(m_sluU.Store);
    Scalar      *SNptr;
 
    const Index size = m_matrix.rows();
    m_l.resize(size,size);
    m_l.resizeNonZeros(Lstore->nnz);
    m_u.resize(size,size);
    m_u.resizeNonZeros(Ustore->nnz);
 
    int* Lcol = m_l.outerIndexPtr();
    int* Lrow = m_l.innerIndexPtr();
    Scalar* Lval = m_l.valuePtr();
 
    int* Ucol = m_u.outerIndexPtr();
    int* Urow = m_u.innerIndexPtr();
    Scalar* Uval = m_u.valuePtr();
 
    Ucol[0] = 0;
    Ucol[0] = 0;
 
    /* for each supernode */
    for (int k = 0; k <= Lstore->nsuper; ++k)
    {
      fsupc   = L_FST_SUPC(k);
      istart  = L_SUB_START(fsupc);
      nsupr   = L_SUB_START(fsupc+1) - istart;
      upper   = 1;
 
      /* for each column in the supernode */
      for (int j = fsupc; j < L_FST_SUPC(k+1); ++j)
      {
        SNptr = &((Scalar*)Lstore->nzval)[L_NZ_START(j)];
 
        /* Extract U */
        for (int i = U_NZ_START(j); i < U_NZ_START(j+1); ++i)
        {
          Uval[lastu] = ((Scalar*)Ustore->nzval)[i];
          /* Matlab doesn't like explicit zero. */
          if (Uval[lastu] != 0.0)
            Urow[lastu++] = U_SUB(i);
        }
        for (int i = 0; i < upper; ++i)
        {
          /* upper triangle in the supernode */
          Uval[lastu] = SNptr[i];
          /* Matlab doesn't like explicit zero. */
          if (Uval[lastu] != 0.0)
            Urow[lastu++] = L_SUB(istart+i);
        }
        Ucol[j+1] = lastu;
 
        /* Extract L */
        Lval[lastl] = 1.0; /* unit diagonal */
        Lrow[lastl++] = L_SUB(istart + upper - 1);
        for (int i = upper; i < nsupr; ++i)
        {
          Lval[lastl] = SNptr[i];
          /* Matlab doesn't like explicit zero. */
          if (Lval[lastl] != 0.0)
            Lrow[lastl++] = L_SUB(istart+i);
        }
        Lcol[j+1] = lastl;
 
        ++upper;
      } /* for j ... */
 
    } /* for k ... */
 
    // squeeze the matrices :
    m_l.resizeNonZeros(lastl);
    m_u.resizeNonZeros(lastu);
 
    m_extractedDataAreDirty = false;
  }
}

factorize()

template<typename MatrixType >

void Eigen::SuperLU< MatrixType >::factorize

(

const MatrixType &

matrix

)

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

{
  eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
  if(!m_analysisIsOk)
  {
    m_info = InvalidInput;
    return;
  }
  
  this->initFactorization(a);
  
  m_sluOptions.ColPerm = COLAMD;
  int info = 0;
  RealScalar recip_pivot_growth, rcond;
  RealScalar ferr, berr;
 
  StatInit(&m_sluStat);
  SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0],
                &m_sluEqued, &m_sluRscale[0], &m_sluCscale[0],
                &m_sluL, &m_sluU,
                NULL, 0,
                &m_sluB, &m_sluX,
                &recip_pivot_growth, &rcond,
                &ferr, &berr,
                &m_sluStat, &info, Scalar());
  StatFree(&m_sluStat);
 
  m_extractedDataAreDirty = true;
 
  // FIXME how to better check for errors ???
  m_info = info == 0 ? Success : NumericalIssue;
  m_factorizationIsOk = true;
}

References eigen_assert, Eigen::InvalidInput, Eigen::NumericalIssue, and Eigen::Success.

info()

ComputationInfo Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::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;
    }

init()

template<typename _MatrixType >

void Eigen::SuperLU< _MatrixType >::init ( )

inlineprotected

    {
      Base::init();
      
      set_default_options(&this->m_sluOptions);
      m_sluOptions.PrintStat        = NO;
      m_sluOptions.ConditionNumber  = NO;
      m_sluOptions.Trans            = NOTRANS;
      m_sluOptions.ColPerm          = COLAMD;
    }

References Eigen::SuperLUBase< _MatrixType, Derived >::init(), and Eigen::SuperLU< _MatrixType >::m_sluOptions.

Referenced by Eigen::SuperLU< _MatrixType >::SuperLU(), and Eigen::SuperLU< _MatrixType >::SuperLU().

Here is the call graph for this function:

Here is the caller graph for this function:

initFactorization()

void Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::initFactorization ( const MatrixType &  a )

inlineprotectedinherited

    {
      set_default_options(&this->m_sluOptions);
      
      const Index size = a.rows();
      m_matrix = a;
 
      m_sluA = internal::asSluMatrix(m_matrix);
      clearFactors();
 
      m_p.resize(size);
      m_q.resize(size);
      m_sluRscale.resize(size);
      m_sluCscale.resize(size);
      m_sluEtree.resize(size);
 
      // set empty B and X
      m_sluB.setStorageType(SLU_DN);
      m_sluB.setScalarType<Scalar>();
      m_sluB.Mtype          = SLU_GE;
      m_sluB.storage.values = 0;
      m_sluB.nrow           = 0;
      m_sluB.ncol           = 0;
      m_sluB.storage.lda    = internal::convert_index<int>(size);
      m_sluX                = m_sluB;
      
      m_extractedDataAreDirty = true;
    }

matrixL()

template<typename _MatrixType >

const LMatrixType & Eigen::SuperLU< _MatrixType >::matrixL ( ) const

inline

    {
      if (m_extractedDataAreDirty) this->extractData();
      return m_l;
    }

References Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::extractData(), Eigen::SuperLU< _MatrixType >::m_extractedDataAreDirty, and Eigen::SuperLU< _MatrixType >::m_l.

Here is the call graph for this function:

matrixU()

template<typename _MatrixType >

const UMatrixType & Eigen::SuperLU< _MatrixType >::matrixU ( ) const

inline

    {
      if (m_extractedDataAreDirty) this->extractData();
      return m_u;
    }

References Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::extractData(), Eigen::SuperLU< _MatrixType >::m_extractedDataAreDirty, and Eigen::SuperLU< _MatrixType >::m_u.

Here is the call graph for this function:

options()

superlu_options_t & Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::options ( )

inlineinherited

Returns

a reference to the Super LU option object to configure the Super LU algorithms.

{ return m_sluOptions; }

permutationP()

template<typename _MatrixType >

const IntColVectorType & Eigen::SuperLU< _MatrixType >::permutationP ( ) const

inline

    {
      if (m_extractedDataAreDirty) this->extractData();
      return m_p;
    }

References Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::extractData(), Eigen::SuperLU< _MatrixType >::m_extractedDataAreDirty, and Eigen::SuperLU< _MatrixType >::m_p.

Here is the call graph for this function:

permutationQ()

template<typename _MatrixType >

const IntRowVectorType & Eigen::SuperLU< _MatrixType >::permutationQ ( ) const

inline

    {
      if (m_extractedDataAreDirty) this->extractData();
      return m_q;
    }

References Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::extractData(), Eigen::SuperLU< _MatrixType >::m_extractedDataAreDirty, and Eigen::SuperLU< _MatrixType >::m_q.

Here is the call graph for this function:

rows()

Index Eigen::SuperLUBase< _MatrixType, SuperLU< _MatrixType > >::rows ( ) const

inlineinherited

{ return m_matrix.rows(); }

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

template<typename _MatrixType >

int Eigen::SuperLUBase< _MatrixType, Derived >::m_analysisIsOk

protected

m_extractedDataAreDirty

template<typename _MatrixType >

bool Eigen::SuperLUBase< _MatrixType, Derived >::m_extractedDataAreDirty

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::matrixL(), Eigen::SuperLU< _MatrixType >::matrixU(), Eigen::SuperLU< _MatrixType >::permutationP(), and Eigen::SuperLU< _MatrixType >::permutationQ().

m_factorizationIsOk

template<typename _MatrixType >

int Eigen::SuperLUBase< _MatrixType, Derived >::m_factorizationIsOk

protected

m_info

template<typename _MatrixType >

ComputationInfo Eigen::SuperLUBase< _MatrixType, Derived >::m_info

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::analyzePattern().

m_isInitialized

template<typename _MatrixType >

bool Eigen::SparseSolverBase< Derived >::m_isInitialized

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::analyzePattern().

m_l

template<typename _MatrixType >

LUMatrixType Eigen::SuperLUBase< _MatrixType, Derived >::m_l

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::matrixL().

m_matrix

template<typename _MatrixType >

LUMatrixType Eigen::SuperLUBase< _MatrixType, Derived >::m_matrix

mutableprotected

m_p

template<typename _MatrixType >

IntColVectorType Eigen::SuperLUBase< _MatrixType, Derived >::m_p

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::permutationP().

m_q

template<typename _MatrixType >

IntRowVectorType Eigen::SuperLUBase< _MatrixType, Derived >::m_q

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::permutationQ().

m_sluA

template<typename _MatrixType >

SluMatrix Eigen::SuperLUBase< _MatrixType, Derived >::m_sluA

mutableprotected

m_sluB

template<typename _MatrixType >

SluMatrix Eigen::SuperLUBase< _MatrixType, Derived >::m_sluB

mutableprotected

m_sluBerr

template<typename _MatrixType >

Matrix<RealScalar,Dynamic,1> Eigen::SuperLUBase< _MatrixType, Derived >::m_sluBerr

protected

m_sluCscale

template<typename _MatrixType >

Matrix<RealScalar,Dynamic,1> Eigen::SuperLUBase< _MatrixType, Derived >::m_sluCscale

protected

m_sluEqued

template<typename _MatrixType >

char Eigen::SuperLUBase< _MatrixType, Derived >::m_sluEqued

mutableprotected

m_sluEtree

template<typename _MatrixType >

std::vector<int> Eigen::SuperLUBase< _MatrixType, Derived >::m_sluEtree

mutableprotected

m_sluFerr

template<typename _MatrixType >

Matrix<RealScalar,Dynamic,1> Eigen::SuperLUBase< _MatrixType, Derived >::m_sluFerr

mutableprotected

m_sluL

template<typename _MatrixType >

SuperMatrix Eigen::SuperLUBase< _MatrixType, Derived >::m_sluL

mutableprotected

m_sluOptions

template<typename _MatrixType >

superlu_options_t Eigen::SuperLUBase< _MatrixType, Derived >::m_sluOptions

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::init().

m_sluRscale

template<typename _MatrixType >

Matrix<RealScalar,Dynamic,1> Eigen::SuperLUBase< _MatrixType, Derived >::m_sluRscale

mutableprotected

m_sluStat

template<typename _MatrixType >

SuperLUStat_t Eigen::SuperLUBase< _MatrixType, Derived >::m_sluStat

mutableprotected

m_sluU

template<typename _MatrixType >

SuperMatrix Eigen::SuperLUBase< _MatrixType, Derived >::m_sluU

protected

m_sluX

template<typename _MatrixType >

SluMatrix Eigen::SuperLUBase< _MatrixType, Derived >::m_sluX

protected

m_u

template<typename _MatrixType >

LUMatrixType Eigen::SuperLUBase< _MatrixType, Derived >::m_u

mutableprotected

Referenced by Eigen::SuperLU< _MatrixType >::matrixU().

---

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

• src/eigen/Eigen/src/SuperLUSupport/SuperLUSupport.h