Eigen::SparseLU< _MatrixType, _OrderingType > Class Template Reference

Sparse supernodal LU factorization for general matrices. More...

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

Inheritance diagram for Eigen::SparseLU< _MatrixType, _OrderingType >:

Collaboration diagram for Eigen::SparseLU< _MatrixType, _OrderingType >:

Public Types
enum	{ ColsAtCompileTime = MatrixType::ColsAtCompileTime , MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
typedef _MatrixType	MatrixType
typedef _OrderingType	OrderingType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::StorageIndex	StorageIndex
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	NCMatrix
typedef internal::MappedSuperNodalMatrix< Scalar, StorageIndex >	SCMatrix
typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector
typedef Matrix< StorageIndex, Dynamic, 1 >	IndexVector
typedef PermutationMatrix< Dynamic, Dynamic, StorageIndex >	PermutationType
typedef internal::SparseLUImpl< Scalar, StorageIndex >	Base
typedef Matrix< _MatrixType::Scalar, Dynamic, Dynamic, ColMajor >	ScalarMatrix
typedef Map< ScalarMatrix, 0, OuterStride<> >	MappedMatrixBlock
typedef Ref< Matrix< _MatrixType::Scalar, Dynamic, 1 > >	BlockScalarVector
typedef Ref< Matrix< _MatrixType::StorageIndex, Dynamic, 1 > >	BlockIndexVector
typedef LU_GlobalLU_t< IndexVector, ScalarVector >	GlobalLU_t

Public Member Functions
	SparseLU ()
	SparseLU (const MatrixType &matrix)
	~SparseLU ()
void	analyzePattern (const MatrixType &matrix)
void	factorize (const MatrixType &matrix)
void	simplicialfactorize (const MatrixType &matrix)
void	compute (const MatrixType &matrix)
Index	rows () const
Index	cols () const
void	isSymmetric (bool sym)
SparseLUMatrixLReturnType< SCMatrix >	matrixL () const
SparseLUMatrixUReturnType< SCMatrix, MappedSparseMatrix< Scalar, ColMajor, StorageIndex > >	matrixU () const
const PermutationType &	rowsPermutation () const
const PermutationType &	colsPermutation () const
void	setPivotThreshold (const RealScalar &thresh)
ComputationInfo	info () const
	Reports whether previous computation was successful.
std::string	lastErrorMessage () const
template<typename Rhs , typename Dest >
bool	_solve_impl (const MatrixBase< Rhs > &B, MatrixBase< Dest > &X_base) const
Scalar	absDeterminant ()
Scalar	logAbsDeterminant () const
Scalar	signDeterminant ()
Scalar	determinant ()
SparseLU< _MatrixType, _OrderingType > &	derived ()
const SparseLU< _MatrixType, _OrderingType > &	derived () const
const Solve< SparseLU< _MatrixType, _OrderingType >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< SparseLU< _MatrixType, _OrderingType >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >	APIBase

Protected Member Functions
void	initperfvalues ()
Index	expand (VectorType &vec, Index &length, Index nbElts, Index keep_prev, Index &num_expansions)
Index	memInit (Index m, Index n, Index annz, Index lwork, Index fillratio, Index panel_size, GlobalLU_t &glu)
	Allocate various working space for the numerical factorization phase.
Index	memXpand (VectorType &vec, Index &maxlen, Index nbElts, MemType memtype, Index &num_expansions)
	Expand the existing storage.
void	heap_relax_snode (const Index n, IndexVector &et, const Index relax_columns, IndexVector &descendants, IndexVector &relax_end)
	Identify the initial relaxed supernodes.
void	relax_snode (const Index n, IndexVector &et, const Index relax_columns, IndexVector &descendants, IndexVector &relax_end)
	Identify the initial relaxed supernodes.
Index	snode_dfs (const Index jcol, const Index kcol, const MatrixType &mat, IndexVector &xprune, IndexVector &marker, GlobalLU_t &glu)
Index	snode_bmod (const Index jcol, const Index fsupc, ScalarVector &dense, GlobalLU_t &glu)
Index	pivotL (const Index jcol, const RealScalar &diagpivotthresh, IndexVector &perm_r, IndexVector &iperm_c, Index &pivrow, GlobalLU_t &glu)
	Performs the numerical pivotin on the current column of L, and the CDIV operation.
void	dfs_kernel (const _MatrixType::StorageIndex jj, IndexVector &perm_r, Index &nseg, IndexVector &panel_lsub, IndexVector &segrep, Ref< IndexVector > repfnz_col, IndexVector &xprune, Ref< IndexVector > marker, IndexVector &parent, IndexVector &xplore, GlobalLU_t &glu, Index &nextl_col, Index krow, Traits &traits)
void	panel_dfs (const Index m, const Index w, const Index jcol, MatrixType &A, IndexVector &perm_r, Index &nseg, ScalarVector &dense, IndexVector &panel_lsub, IndexVector &segrep, IndexVector &repfnz, IndexVector &xprune, IndexVector &marker, IndexVector &parent, IndexVector &xplore, GlobalLU_t &glu)
	Performs a symbolic factorization on a panel of columns [jcol, jcol+w)
void	panel_bmod (const Index m, const Index w, const Index jcol, const Index nseg, ScalarVector &dense, ScalarVector &tempv, IndexVector &segrep, IndexVector &repfnz, GlobalLU_t &glu)
	Performs numeric block updates (sup-panel) in topological order.
Index	column_dfs (const Index m, const Index jcol, IndexVector &perm_r, Index maxsuper, Index &nseg, BlockIndexVector lsub_col, IndexVector &segrep, BlockIndexVector repfnz, IndexVector &xprune, IndexVector &marker, IndexVector &parent, IndexVector &xplore, GlobalLU_t &glu)
	Performs a symbolic factorization on column jcol and decide the supernode boundary.
Index	column_bmod (const Index jcol, const Index nseg, BlockScalarVector dense, ScalarVector &tempv, BlockIndexVector segrep, BlockIndexVector repfnz, Index fpanelc, GlobalLU_t &glu)
	Performs numeric block updates (sup-col) in topological order.
Index	copy_to_ucol (const Index jcol, const Index nseg, IndexVector &segrep, BlockIndexVector repfnz, IndexVector &perm_r, BlockScalarVector dense, GlobalLU_t &glu)
	Performs numeric block updates (sup-col) in topological order.
void	pruneL (const Index jcol, const IndexVector &perm_r, const Index pivrow, const Index nseg, const IndexVector &segrep, BlockIndexVector repfnz, IndexVector &xprune, GlobalLU_t &glu)
	Prunes the L-structure.
void	countnz (const Index n, Index &nnzL, Index &nnzU, GlobalLU_t &glu)
	Count Nonzero elements in the factors.
void	fixupL (const Index n, const IndexVector &perm_r, GlobalLU_t &glu)
	Fix up the data storage lsub for L-subscripts.

Protected Attributes
ComputationInfo	m_info
bool	m_factorizationIsOk
bool	m_analysisIsOk
std::string	m_lastError
NCMatrix	m_mat
SCMatrix	m_Lstore
MappedSparseMatrix< Scalar, ColMajor, StorageIndex >	m_Ustore
PermutationType	m_perm_c
PermutationType	m_perm_r
IndexVector	m_etree
Base::GlobalLU_t	m_glu
bool	m_symmetricmode
internal::perfvalues	m_perfv
RealScalar	m_diagpivotthresh
Index	m_nnzL
Index	m_nnzU
Index	m_detPermR
Index	m_detPermC
bool	m_isInitialized

Private Member Functions
	SparseLU (const SparseLU &)

Detailed Description

template<typename _MatrixType, typename _OrderingType>
class Eigen::SparseLU< _MatrixType, _OrderingType >

Sparse supernodal LU factorization for general matrices.

This class implements the supernodal LU factorization for general matrices. It uses the main techniques from the sequential SuperLU package (http://crd-legacy.lbl.gov/~xiaoye/SuperLU/). It handles transparently real and complex arithmetics with single and double precision, depending on the scalar type of your input matrix. The code has been optimized to provide BLAS-3 operations during supernode-panel updates. It benefits directly from the built-in high-performant Eigen BLAS routines. Moreover, when the size of a supernode is very small, the BLAS calls are avoided to enable a better optimization from the compiler. For best performance, you should compile it with NDEBUG flag to avoid the numerous bounds checking on vectors.

An important parameter of this class is the ordering method. It is used to reorder the columns (and eventually the rows) of the matrix to reduce the number of new elements that are created during numerical factorization. The cheapest method available is COLAMD. See the OrderingMethods module for the list of built-in and external ordering methods.

Simple example with key steps

VectorXd x(n), b(n);
SparseMatrix<double, ColMajor> A;
SparseLU<SparseMatrix<scalar, ColMajor>, COLAMDOrdering<Index> >   solver;
// fill A and b;
// Compute the ordering permutation vector from the structural pattern of A
solver.analyzePattern(A); 
// Compute the numerical factorization 
solver.factorize(A); 
//Use the factors to solve the linear system 
x = solver.solve(b); 

Warning

The input matrix A should be in a compressed and column-major form. Otherwise an expensive copy will be made. You can call the inexpensive makeCompressed() to get a compressed matrix.

Note

Unlike the initial SuperLU implementation, there is no step to equilibrate the matrix. For badly scaled matrices, this step can be useful to reduce the pivoting during factorization. If this is the case for your matrices, you can try the basic scaling method at "unsupported/Eigen/src/IterativeSolvers/Scaling.h"

Template Parameters

_MatrixType	The type of the sparse matrix. It must be a column-major SparseMatrix<>
_OrderingType	The ordering method to use, either AMD, COLAMD or METIS. Default is COLMAD

\implsparsesolverconcept

See also

TutorialSparseSolverConcept

OrderingMethods_Module

Member Typedef Documentation

APIBase

template<typename _MatrixType , typename _OrderingType >

typedef SparseSolverBase<SparseLU<_MatrixType,_OrderingType> > Eigen::SparseLU< _MatrixType, _OrderingType >::APIBase

protected

Base

template<typename _MatrixType , typename _OrderingType >

typedef internal::SparseLUImpl<Scalar, StorageIndex> Eigen::SparseLU< _MatrixType, _OrderingType >::Base

BlockIndexVector

typedef Ref<Matrix<_MatrixType::StorageIndex ,Dynamic,1> > Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::BlockIndexVector

inherited

BlockScalarVector

typedef Ref<Matrix<_MatrixType::Scalar ,Dynamic,1> > Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::BlockScalarVector

inherited

GlobalLU_t

typedef LU_GlobalLU_t<IndexVector, ScalarVector> Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::GlobalLU_t

inherited

IndexVector

template<typename _MatrixType , typename _OrderingType >

typedef Matrix<StorageIndex,Dynamic,1> Eigen::SparseLU< _MatrixType, _OrderingType >::IndexVector

MappedMatrixBlock

typedef Map<ScalarMatrix, 0, OuterStride<> > Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::MappedMatrixBlock

inherited

MatrixType

template<typename _MatrixType , typename _OrderingType >

typedef _MatrixType Eigen::SparseLU< _MatrixType, _OrderingType >::MatrixType

NCMatrix

template<typename _MatrixType , typename _OrderingType >

typedef SparseMatrix<Scalar,ColMajor,StorageIndex> Eigen::SparseLU< _MatrixType, _OrderingType >::NCMatrix

OrderingType

template<typename _MatrixType , typename _OrderingType >

typedef _OrderingType Eigen::SparseLU< _MatrixType, _OrderingType >::OrderingType

PermutationType

template<typename _MatrixType , typename _OrderingType >

typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> Eigen::SparseLU< _MatrixType, _OrderingType >::PermutationType

RealScalar

template<typename _MatrixType , typename _OrderingType >

typedef MatrixType::RealScalar Eigen::SparseLU< _MatrixType, _OrderingType >::RealScalar

Scalar

template<typename _MatrixType , typename _OrderingType >

typedef MatrixType::Scalar Eigen::SparseLU< _MatrixType, _OrderingType >::Scalar

ScalarMatrix

typedef Matrix<_MatrixType::Scalar ,Dynamic,Dynamic,ColMajor> Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::ScalarMatrix

inherited

ScalarVector

template<typename _MatrixType , typename _OrderingType >

typedef Matrix<Scalar,Dynamic,1> Eigen::SparseLU< _MatrixType, _OrderingType >::ScalarVector

SCMatrix

template<typename _MatrixType , typename _OrderingType >

typedef internal::MappedSuperNodalMatrix<Scalar, StorageIndex> Eigen::SparseLU< _MatrixType, _OrderingType >::SCMatrix

StorageIndex

template<typename _MatrixType , typename _OrderingType >

typedef MatrixType::StorageIndex Eigen::SparseLU< _MatrixType, _OrderingType >::StorageIndex

Member Enumeration Documentation

anonymous enum

template<typename _MatrixType , typename _OrderingType >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

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

Constructor & Destructor Documentation

SparseLU() [1/3]

template<typename _MatrixType , typename _OrderingType >

Eigen::SparseLU< _MatrixType, _OrderingType >::SparseLU ( )

inline

              :m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
    {
      initperfvalues(); 
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::initperfvalues().

Here is the call graph for this function:

SparseLU() [2/3]

template<typename _MatrixType , typename _OrderingType >

Eigen::SparseLU< _MatrixType, _OrderingType >::SparseLU ( const MatrixType &  matrix )

inlineexplicit

      : m_lastError(""),m_Ustore(0,0,0,0,0,0),m_symmetricmode(false),m_diagpivotthresh(1.0),m_detPermR(1)
    {
      initperfvalues(); 
      compute(matrix);
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::compute(), and Eigen::SparseLU< _MatrixType, _OrderingType >::initperfvalues().

Here is the call graph for this function:

~SparseLU()

template<typename _MatrixType , typename _OrderingType >

Eigen::SparseLU< _MatrixType, _OrderingType >::~SparseLU ( )

inline

    {
      // Free all explicit dynamic pointers 
    }

SparseLU() [3/3]

template<typename _MatrixType , typename _OrderingType >

Eigen::SparseLU< _MatrixType, _OrderingType >::SparseLU ( const SparseLU< _MatrixType, _OrderingType > &  )

private

Member Function Documentation

_solve_impl() [1/2]

template<typename _MatrixType , typename _OrderingType >

template<typename Rhs , typename Dest >

bool Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl ( const MatrixBase< Rhs > &  B, MatrixBase< Dest > &  X_base  ) const

inline

    {
      Dest& X(X_base.derived());
      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first");
      EIGEN_STATIC_ASSERT((Dest::Flags&RowMajorBit)==0,
                        THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
      
      // Permute the right hand side to form X = Pr*B
      // on return, X is overwritten by the computed solution
      X.resize(B.rows(),B.cols());
 
      // this ugly const_cast_derived() helps to detect aliasing when applying the permutations
      for(Index j = 0; j < B.cols(); ++j)
        X.col(j) = rowsPermutation() * B.const_cast_derived().col(j);
      
      //Forward substitution with L
      this->matrixL().solveInPlace(X);
      this->matrixU().solveInPlace(X);
      
      // Permute back the solution 
      for (Index j = 0; j < B.cols(); ++j)
        X.col(j) = colsPermutation().inverse() * X.col(j);
      
      return true; 
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::colsPermutation(), eigen_assert, EIGEN_STATIC_ASSERT, Eigen::PermutationBase< Derived >::inverse(), Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk, Eigen::SparseLU< _MatrixType, _OrderingType >::matrixL(), Eigen::SparseLU< _MatrixType, _OrderingType >::matrixU(), Eigen::RowMajorBit, and Eigen::SparseLU< _MatrixType, _OrderingType >::rowsPermutation().

Here is the call graph for this function:

_solve_impl() [2/2]

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

inlineinherited

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

absDeterminant()

template<typename _MatrixType , typename _OrderingType >

Scalar Eigen::SparseLU< _MatrixType, _OrderingType >::absDeterminant ( )

inline

Returns

the absolute value of the determinant of the matrix of which *this is the QR decomposition.

Warning

a determinant can be very big or small, so for matrices of large enough dimension, there is a risk of overflow/underflow. One way to work around that is to use logAbsDeterminant() instead.

See also

logAbsDeterminant(), signDeterminant()

    {
      using std::abs;
      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
      // Initialize with the determinant of the row matrix
      Scalar det = Scalar(1.);
      // Note that the diagonal blocks of U are stored in supernodes,
      // which are available in the  L part :)
      for (Index j = 0; j < this->cols(); ++j)
      {
        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
        {
          if(it.index() == j)
          {
            det *= abs(it.value());
            break;
          }
        }
      }
      return det;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::cols(), eigen_assert, Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk, and Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore.

Here is the call graph for this function:

analyzePattern()

template<typename MatrixType , typename OrderingType >

void Eigen::SparseLU< MatrixType, OrderingType >::analyzePattern

(

const MatrixType &

mat

)

Compute the column permutation to minimize the fill-in

• Apply this permutation to the input matrix -
• Compute the column elimination tree on the permuted matrix
• Postorder the elimination tree and the column permutation

{
  
  //TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
  
  // Firstly, copy the whole input matrix. 
  m_mat = mat;
  
  // Compute fill-in ordering
  OrderingType ord; 
  ord(m_mat,m_perm_c);
  
  // Apply the permutation to the column of the input  matrix
  if (m_perm_c.size())
  {
    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers. FIXME : This vector is filled but not subsequently used.  
    // Then, permute only the column pointers
    ei_declare_aligned_stack_constructed_variable(StorageIndex,outerIndexPtr,mat.cols()+1,mat.isCompressed()?const_cast<StorageIndex*>(mat.outerIndexPtr()):0);
    
    // If the input matrix 'mat' is uncompressed, then the outer-indices do not match the ones of m_mat, and a copy is thus needed.
    if(!mat.isCompressed()) 
      IndexVector::Map(outerIndexPtr, mat.cols()+1) = IndexVector::Map(m_mat.outerIndexPtr(),mat.cols()+1);
    
    // Apply the permutation and compute the nnz per column.
    for (Index i = 0; i < mat.cols(); i++)
    {
      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
    }
  }
  
  // Compute the column elimination tree of the permuted matrix 
  IndexVector firstRowElt;
  internal::coletree(m_mat, m_etree,firstRowElt); 
     
  // In symmetric mode, do not do postorder here
  if (!m_symmetricmode) {
    IndexVector post, iwork; 
    // Post order etree
    internal::treePostorder(StorageIndex(m_mat.cols()), m_etree, post); 
      
   
    // Renumber etree in postorder 
    Index m = m_mat.cols(); 
    iwork.resize(m+1);
    for (Index i = 0; i < m; ++i) iwork(post(i)) = post(m_etree(i));
    m_etree = iwork;
    
    // Postmultiply A*Pc by post, i.e reorder the matrix according to the postorder of the etree
    PermutationType post_perm(m); 
    for (Index i = 0; i < m; i++) 
      post_perm.indices()(i) = post(i); 
        
    // Combine the two permutations : postorder the permutation for future use
    if(m_perm_c.size()) {
      m_perm_c = post_perm * m_perm_c;
    }
    
  } // end postordering 
  
  m_analysisIsOk = true; 
}

References Eigen::internal::coletree(), ei_declare_aligned_stack_constructed_variable, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >::indices(), Eigen::PlainObjectBase< Derived >::resize(), and Eigen::internal::treePostorder().

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

cols()

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::cols ( ) const

inline

{ return m_mat.cols(); }

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), and Eigen::SparseLU< _MatrixType, _OrderingType >::m_mat.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::absDeterminant(), Eigen::SparseLU< _MatrixType, _OrderingType >::determinant(), Eigen::SparseLU< _MatrixType, _OrderingType >::logAbsDeterminant(), and Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant().

Here is the call graph for this function:

Here is the caller graph for this function:

colsPermutation()

template<typename _MatrixType , typename _OrderingType >

const PermutationType & Eigen::SparseLU< _MatrixType, _OrderingType >::colsPermutation ( ) const

inline

Returns

a reference to the column matrix permutation such that

See also

rowsPermutation()

    {
      return m_perm_c;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_perm_c.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl().

Here is the caller graph for this function:

column_bmod()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::column_bmod ( const Index  jcol, const Index  nseg, BlockScalarVector  dense, ScalarVector &  tempv, BlockIndexVector  segrep, BlockIndexVector  repfnz, Index  fpanelc, GlobalLU_t &  glu  )

protectedinherited

Performs numeric block updates (sup-col) in topological order.

Parameters

jcol	current column to update
nseg	Number of segments in the U part
dense	Store the full representation of the column
tempv	working array
segrep	segment representative ...
repfnz	??? First nonzero column in each row ??? ...
fpanelc	First column in the current panel
glu	Global LU data.

Returns

0 - successful return > 0 - number of bytes allocated when run out of space

{
  Index  jsupno, k, ksub, krep, ksupno; 
  Index lptr, nrow, isub, irow, nextlu, new_next, ufirst; 
  Index fsupc, nsupc, nsupr, luptr, kfnz, no_zeros; 
  /* krep = representative of current k-th supernode
    * fsupc =  first supernodal column
    * nsupc = number of columns in a supernode
    * nsupr = number of rows in a supernode
    * luptr = location of supernodal LU-block in storage
    * kfnz = first nonz in the k-th supernodal segment
    * no_zeros = no lf leading zeros in a supernodal U-segment
    */
  
  jsupno = glu.supno(jcol);
  // For each nonzero supernode segment of U[*,j] in topological order 
  k = nseg - 1; 
  Index d_fsupc; // distance between the first column of the current panel and the 
               // first column of the current snode
  Index fst_col; // First column within small LU update
  Index segsize; 
  for (ksub = 0; ksub < nseg; ksub++)
  {
    krep = segrep(k); k--; 
    ksupno = glu.supno(krep); 
    if (jsupno != ksupno )
    {
      // outside the rectangular supernode 
      fsupc = glu.xsup(ksupno); 
      fst_col = (std::max)(fsupc, fpanelc); 
      
      // Distance from the current supernode to the current panel; 
      // d_fsupc = 0 if fsupc > fpanelc
      d_fsupc = fst_col - fsupc; 
      
      luptr = glu.xlusup(fst_col) + d_fsupc; 
      lptr = glu.xlsub(fsupc) + d_fsupc; 
      
      kfnz = repfnz(krep); 
      kfnz = (std::max)(kfnz, fpanelc); 
      
      segsize = krep - kfnz + 1; 
      nsupc = krep - fst_col + 1; 
      nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
      nrow = nsupr - d_fsupc - nsupc;
      Index lda = glu.xlusup(fst_col+1) - glu.xlusup(fst_col);
      
      
      // Perform a triangular solver and block update, 
      // then scatter the result of sup-col update to dense
      no_zeros = kfnz - fst_col; 
      if(segsize==1)
        LU_kernel_bmod<1>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
      else
        LU_kernel_bmod<Dynamic>::run(segsize, dense, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
    } // end if jsupno 
  } // end for each segment
  
  // Process the supernodal portion of  L\U[*,j]
  nextlu = glu.xlusup(jcol); 
  fsupc = glu.xsup(jsupno);
  
  // copy the SPA dense into L\U[*,j]
  Index mem; 
  new_next = nextlu + glu.xlsub(fsupc + 1) - glu.xlsub(fsupc); 
  Index offset = internal::first_multiple<Index>(new_next, internal::packet_traits<Scalar>::size) - new_next;
  if(offset)
    new_next += offset;
  while (new_next > glu.nzlumax )
  {
    mem = memXpand<ScalarVector>(glu.lusup, glu.nzlumax, nextlu, LUSUP, glu.num_expansions);  
    if (mem) return mem; 
  }
  
  for (isub = glu.xlsub(fsupc); isub < glu.xlsub(fsupc+1); isub++)
  {
    irow = glu.lsub(isub);
    glu.lusup(nextlu) = dense(irow);
    dense(irow) = Scalar(0.0); 
    ++nextlu; 
  }
  
  if(offset)
  {
    glu.lusup.segment(nextlu,offset).setZero();
    nextlu += offset;
  }
  glu.xlusup(jcol + 1) = StorageIndex(nextlu);  // close L\U(*,jcol); 
  
  /* For more updates within the panel (also within the current supernode),
   * should start from the first column of the panel, or the first column
   * of the supernode, whichever is bigger. There are two cases:
   *  1) fsupc < fpanelc, then fst_col <-- fpanelc
   *  2) fsupc >= fpanelc, then fst_col <-- fsupc
   */
  fst_col = (std::max)(fsupc, fpanelc); 
  
  if (fst_col  < jcol)
  {
    // Distance between the current supernode and the current panel
    // d_fsupc = 0 if fsupc >= fpanelc
    d_fsupc = fst_col - fsupc; 
    
    lptr = glu.xlsub(fsupc) + d_fsupc; 
    luptr = glu.xlusup(fst_col) + d_fsupc; 
    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); // leading dimension
    nsupc = jcol - fst_col; // excluding jcol 
    nrow = nsupr - d_fsupc - nsupc; 
    
    // points to the beginning of jcol in snode L\U(jsupno) 
    ufirst = glu.xlusup(jcol) + d_fsupc; 
    Index lda = glu.xlusup(jcol+1) - glu.xlusup(jcol);
    MappedMatrixBlock A( &(glu.lusup.data()[luptr]), nsupc, nsupc, OuterStride<>(lda) );
    VectorBlock<ScalarVector> u(glu.lusup, ufirst, nsupc); 
    u = A.template triangularView<UnitLower>().solve(u); 
    
    new (&A) MappedMatrixBlock ( &(glu.lusup.data()[luptr+nsupc]), nrow, nsupc, OuterStride<>(lda) );
    VectorBlock<ScalarVector> l(glu.lusup, ufirst+nsupc, nrow); 
    l.noalias() -= A * u;
    
  } // End if fst_col
  return 0; 
}

column_dfs()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::column_dfs ( const Index  m, const Index  jcol, IndexVector &  perm_r, Index  maxsuper, Index &  nseg, BlockIndexVector  lsub_col, IndexVector &  segrep, BlockIndexVector  repfnz, IndexVector &  xprune, IndexVector &  marker, IndexVector &  parent, IndexVector &  xplore, GlobalLU_t &  glu  )

protectedinherited

Performs a symbolic factorization on column jcol and decide the supernode boundary.

A supernode representative is the last column of a supernode. The nonzeros in U[*,j] are segments that end at supernodes representatives. The routine returns a list of the supernodal representatives in topological order of the dfs that generates them. The location of the first nonzero in each supernodal segment (supernodal entry location) is also returned.

Parameters

	m	number of rows in the matrix
	jcol	Current column
	perm_r	Row permutation
	maxsuper	Maximum number of column allowed in a supernode
[in,out]	nseg	Number of segments in current U[*,j] - new segments appended
	lsub_col	defines the rhs vector to start the dfs
[in,out]	segrep	Segment representatives - new segments appended
	repfnz	First nonzero location in each row
	xprune
	marker	marker[i] == jj, if i was visited during dfs of current column jj;
	parent
	xplore	working array
	glu	global LU data

Returns

0 success > 0 number of bytes allocated when run out of space

{
  
  Index jsuper = glu.supno(jcol); 
  Index nextl = glu.xlsub(jcol); 
  VectorBlock<IndexVector> marker2(marker, 2*m, m); 
  
  
  column_dfs_traits<IndexVector, ScalarVector> traits(jcol, jsuper, glu, *this);
  
  // For each nonzero in A(*,jcol) do dfs 
  for (Index k = 0; ((k < m) ? lsub_col[k] != emptyIdxLU : false) ; k++)
  {
    Index krow = lsub_col(k); 
    lsub_col(k) = emptyIdxLU; 
    Index kmark = marker2(krow); 
    
    // krow was visited before, go to the next nonz; 
    if (kmark == jcol) continue;
    
    dfs_kernel(StorageIndex(jcol), perm_r, nseg, glu.lsub, segrep, repfnz, xprune, marker2, parent,
                   xplore, glu, nextl, krow, traits);
  } // for each nonzero ... 
  
  Index fsupc;
  StorageIndex nsuper = glu.supno(jcol);
  StorageIndex jcolp1 = StorageIndex(jcol) + 1;
  Index jcolm1 = jcol - 1;
  
  // check to see if j belongs in the same supernode as j-1
  if ( jcol == 0 )
  { // Do nothing for column 0 
    nsuper = glu.supno(0) = 0 ;
  }
  else 
  {
    fsupc = glu.xsup(nsuper); 
    StorageIndex jptr = glu.xlsub(jcol); // Not yet compressed
    StorageIndex jm1ptr = glu.xlsub(jcolm1); 
    
    // Use supernodes of type T2 : see SuperLU paper
    if ( (nextl-jptr != jptr-jm1ptr-1) ) jsuper = emptyIdxLU;
    
    // Make sure the number of columns in a supernode doesn't
    // exceed threshold
    if ( (jcol - fsupc) >= maxsuper) jsuper = emptyIdxLU; 
    
    /* If jcol starts a new supernode, reclaim storage space in
     * glu.lsub from previous supernode. Note we only store 
     * the subscript set of the first and last columns of 
     * a supernode. (first for num values, last for pruning)
     */
    if (jsuper == emptyIdxLU)
    { // starts a new supernode 
      if ( (fsupc < jcolm1-1) ) 
      { // >= 3 columns in nsuper
        StorageIndex ito = glu.xlsub(fsupc+1);
        glu.xlsub(jcolm1) = ito; 
        StorageIndex istop = ito + jptr - jm1ptr; 
        xprune(jcolm1) = istop; // intialize xprune(jcol-1)
        glu.xlsub(jcol) = istop; 
        
        for (StorageIndex ifrom = jm1ptr; ifrom < nextl; ++ifrom, ++ito)
          glu.lsub(ito) = glu.lsub(ifrom); 
        nextl = ito;  // = istop + length(jcol)
      }
      nsuper++; 
      glu.supno(jcol) = nsuper; 
    } // if a new supernode 
  } // end else:  jcol > 0
  
  // Tidy up the pointers before exit
  glu.xsup(nsuper+1) = jcolp1; 
  glu.supno(jcolp1) = nsuper; 
  xprune(jcol) = StorageIndex(nextl);  // Intialize upper bound for pruning
  glu.xlsub(jcolp1) = StorageIndex(nextl); 
  
  return 0; 
}

compute()

template<typename _MatrixType , typename _OrderingType >

void Eigen::SparseLU< _MatrixType, _OrderingType >::compute ( const MatrixType &  matrix )

inline

Compute the symbolic and numeric factorization of the input sparse matrix. The input matrix should be in column-major storage.

    {
      // Analyze 
      analyzePattern(matrix); 
      //Factorize
      factorize(matrix);
    } 

References Eigen::SparseLU< _MatrixType, _OrderingType >::analyzePattern(), and Eigen::SparseLU< _MatrixType, _OrderingType >::factorize().

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::SparseLU(), and igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric().

Here is the call graph for this function:

Here is the caller graph for this function:

copy_to_ucol()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::copy_to_ucol ( const Index  jcol, const Index  nseg, IndexVector &  segrep, BlockIndexVector  repfnz, IndexVector &  perm_r, BlockScalarVector  dense, GlobalLU_t &  glu  )

protectedinherited

Performs numeric block updates (sup-col) in topological order.

Parameters

jcol	current column to update
nseg	Number of segments in the U part
segrep	segment representative ...
repfnz	First nonzero column in each row ...
perm_r	Row permutation
dense	Store the full representation of the column
glu	Global LU data.

Returns

0 - successful return > 0 - number of bytes allocated when run out of space

{  
  Index ksub, krep, ksupno; 
    
  Index jsupno = glu.supno(jcol);
  
  // For each nonzero supernode segment of U[*,j] in topological order 
  Index k = nseg - 1, i; 
  StorageIndex nextu = glu.xusub(jcol); 
  Index kfnz, isub, segsize; 
  Index new_next,irow; 
  Index fsupc, mem; 
  for (ksub = 0; ksub < nseg; ksub++)
  {
    krep = segrep(k); k--; 
    ksupno = glu.supno(krep); 
    if (jsupno != ksupno ) // should go into ucol(); 
    {
      kfnz = repfnz(krep); 
      if (kfnz != emptyIdxLU)
      { // Nonzero U-segment 
        fsupc = glu.xsup(ksupno); 
        isub = glu.xlsub(fsupc) + kfnz - fsupc; 
        segsize = krep - kfnz + 1; 
        new_next = nextu + segsize; 
        while (new_next > glu.nzumax) 
        {
          mem = memXpand<ScalarVector>(glu.ucol, glu.nzumax, nextu, UCOL, glu.num_expansions); 
          if (mem) return mem; 
          mem = memXpand<IndexVector>(glu.usub, glu.nzumax, nextu, USUB, glu.num_expansions); 
          if (mem) return mem; 
          
        }
        
        for (i = 0; i < segsize; i++)
        {
          irow = glu.lsub(isub); 
          glu.usub(nextu) = perm_r(irow); // Unlike the L part, the U part is stored in its final order
          glu.ucol(nextu) = dense(irow); 
          dense(irow) = Scalar(0.0); 
          nextu++;
          isub++;
        }
        
      } // end nonzero U-segment 
      
    } // end if jsupno 
    
  } // end for each segment
  glu.xusub(jcol + 1) = nextu; // close U(*,jcol)
  return 0; 
}

countnz()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::countnz ( const Index  n, Index &  nnzL, Index &  nnzU, GlobalLU_t &  glu  )

protectedinherited

Count Nonzero elements in the factors.

{
 nnzL = 0; 
 nnzU = (glu.xusub)(n); 
 Index nsuper = (glu.supno)(n); 
 Index jlen; 
 Index i, j, fsupc;
 if (n <= 0 ) return; 
 // For each supernode
 for (i = 0; i <= nsuper; i++)
 {
   fsupc = glu.xsup(i); 
   jlen = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
   
   for (j = fsupc; j < glu.xsup(i+1); j++)
   {
     nnzL += jlen; 
     nnzU += j - fsupc + 1; 
     jlen--; 
   }
 }
}

derived() [1/2]

SparseLU< _MatrixType, _OrderingType > & Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::derived ( )

inlineinherited

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

derived() [2/2]

const SparseLU< _MatrixType, _OrderingType > & Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::derived ( ) const

inlineinherited

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

determinant()

template<typename _MatrixType , typename _OrderingType >

Scalar Eigen::SparseLU< _MatrixType, _OrderingType >::determinant ( )

inline

Returns

The determinant of the matrix.

See also

absDeterminant(), logAbsDeterminant()

    {
      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
      // Initialize with the determinant of the row matrix
      Scalar det = Scalar(1.);
      // Note that the diagonal blocks of U are stored in supernodes,
      // which are available in the  L part :)
      for (Index j = 0; j < this->cols(); ++j)
      {
        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
        {
          if(it.index() == j)
          {
            det *= it.value();
            break;
          }
        }
      }
      return (m_detPermR * m_detPermC) > 0 ? det : -det;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::cols(), eigen_assert, Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermC, Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermR, Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk, and Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore.

Here is the call graph for this function:

dfs_kernel()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::dfs_kernel ( const _MatrixType::StorageIndex  jj, IndexVector &  perm_r, Index &  nseg, IndexVector &  panel_lsub, IndexVector &  segrep, Ref< IndexVector >  repfnz_col, IndexVector &  xprune, Ref< IndexVector >  marker, IndexVector &  parent, IndexVector &  xplore, GlobalLU_t &  glu, Index &  nextl_col, Index  krow, Traits &  traits  )

protectedinherited

{
  
  StorageIndex kmark = marker(krow);
      
  // For each unmarked krow of jj
  marker(krow) = jj; 
  StorageIndex kperm = perm_r(krow); 
  if (kperm == emptyIdxLU ) {
    // krow is in L : place it in structure of L(*, jj)
    panel_lsub(nextl_col++) = StorageIndex(krow);  // krow is indexed into A
    
    traits.mem_expand(panel_lsub, nextl_col, kmark);
  }
  else 
  {
    // krow is in U : if its supernode-representative krep
    // has been explored, update repfnz(*)
    // krep = supernode representative of the current row
    StorageIndex krep = glu.xsup(glu.supno(kperm)+1) - 1; 
    // First nonzero element in the current column:
    StorageIndex myfnz = repfnz_col(krep); 
    
    if (myfnz != emptyIdxLU )
    {
      // Representative visited before
      if (myfnz > kperm ) repfnz_col(krep) = kperm; 
      
    }
    else 
    {
      // Otherwise, perform dfs starting at krep
      StorageIndex oldrep = emptyIdxLU; 
      parent(krep) = oldrep; 
      repfnz_col(krep) = kperm; 
      StorageIndex xdfs =  glu.xlsub(krep); 
      Index maxdfs = xprune(krep); 
      
      StorageIndex kpar;
      do 
      {
        // For each unmarked kchild of krep
        while (xdfs < maxdfs) 
        {
          StorageIndex kchild = glu.lsub(xdfs); 
          xdfs++; 
          StorageIndex chmark = marker(kchild); 
          
          if (chmark != jj ) 
          {
            marker(kchild) = jj; 
            StorageIndex chperm = perm_r(kchild); 
            
            if (chperm == emptyIdxLU) 
            {
              // case kchild is in L: place it in L(*, j)
              panel_lsub(nextl_col++) = kchild;
              traits.mem_expand(panel_lsub, nextl_col, chmark);
            }
            else
            {
              // case kchild is in U :
              // chrep = its supernode-rep. If its rep has been explored, 
              // update its repfnz(*)
              StorageIndex chrep = glu.xsup(glu.supno(chperm)+1) - 1; 
              myfnz = repfnz_col(chrep); 
              
              if (myfnz != emptyIdxLU) 
              { // Visited before 
                if (myfnz > chperm) 
                  repfnz_col(chrep) = chperm; 
              }
              else 
              { // Cont. dfs at snode-rep of kchild
                xplore(krep) = xdfs; 
                oldrep = krep; 
                krep = chrep; // Go deeper down G(L)
                parent(krep) = oldrep; 
                repfnz_col(krep) = chperm; 
                xdfs = glu.xlsub(krep); 
                maxdfs = xprune(krep); 
                
              } // end if myfnz != -1
            } // end if chperm == -1 
                
          } // end if chmark !=jj
        } // end while xdfs < maxdfs
        
        // krow has no more unexplored nbrs :
        //    Place snode-rep krep in postorder DFS, if this 
        //    segment is seen for the first time. (Note that 
        //    "repfnz(krep)" may change later.)
        //    Baktrack dfs to its parent
        if(traits.update_segrep(krep,jj))
        //if (marker1(krep) < jcol )
        {
          segrep(nseg) = krep; 
          ++nseg; 
          //marker1(krep) = jj; 
        }
        
        kpar = parent(krep); // Pop recursion, mimic recursion 
        if (kpar == emptyIdxLU) 
          break; // dfs done 
        krep = kpar; 
        xdfs = xplore(krep); 
        maxdfs = xprune(krep); 
 
      } while (kpar != emptyIdxLU); // Do until empty stack 
      
    } // end if (myfnz = -1)
 
  } // end if (kperm == -1)   
}

expand()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::expand ( VectorType &  vec, Index &  length, Index  nbElts, Index  keep_prev, Index &  num_expansions  )

protectedinherited

Expand the existing storage to accomodate more fill-ins

Parameters

	vec	Valid pointer to the vector to allocate or expand
[in,out]	length	At input, contain the current length of the vector that is to be increased. At output, length of the newly allocated vector
[in]	nbElts	Current number of elements in the factors
	keep_prev	1: use length and do not expand the vector; 0: compute new_len and expand
[in,out]	num_expansions	Number of times the memory has been expanded

{
  
  float alpha = 1.5; // Ratio of the memory increase 
  Index new_len; // New size of the allocated memory
  
  if(num_expansions == 0 || keep_prev) 
    new_len = length ; // First time allocate requested
  else 
    new_len = (std::max)(length+1,Index(alpha * length));
  
  VectorType old_vec; // Temporary vector to hold the previous values   
  if (nbElts > 0 )
    old_vec = vec.segment(0,nbElts); 
  
  //Allocate or expand the current vector
#ifdef EIGEN_EXCEPTIONS
  try
#endif
  {
    vec.resize(new_len); 
  }
#ifdef EIGEN_EXCEPTIONS
  catch(std::bad_alloc& )
#else
  if(!vec.size())
#endif
  {
    if (!num_expansions)
    {
      // First time to allocate from LUMemInit()
      // Let LUMemInit() deals with it.
      return -1;
    }
    if (keep_prev)
    {
      // In this case, the memory length should not not be reduced
      return new_len;
    }
    else 
    {
      // Reduce the size and increase again 
      Index tries = 0; // Number of attempts
      do 
      {
        alpha = (alpha + 1)/2;
        new_len = (std::max)(length+1,Index(alpha * length));
#ifdef EIGEN_EXCEPTIONS
        try
#endif
        {
          vec.resize(new_len); 
        }
#ifdef EIGEN_EXCEPTIONS
        catch(std::bad_alloc& )
#else
        if (!vec.size())
#endif
        {
          tries += 1; 
          if ( tries > 10) return new_len; 
        }
      } while (!vec.size());
    }
  }
  //Copy the previous values to the newly allocated space 
  if (nbElts > 0)
    vec.segment(0, nbElts) = old_vec;   
   
  
  length  = new_len;
  if(num_expansions) ++num_expansions;
  return 0; 
}

factorize()

template<typename MatrixType , typename OrderingType >

void Eigen::SparseLU< MatrixType, OrderingType >::factorize

(

const MatrixType &

matrix

)

• Numerical factorization

• Interleaved with the symbolic factorization On exit, info is

  = 0: successful factorization

‍0: if info = i, and i is

<= A->ncol: U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

> A->ncol: number of bytes allocated when memory allocation failure occurred, plus A->ncol. If lwork = -1, it is the estimated amount of space needed, plus A->ncol.

{
  using internal::emptyIdxLU;
  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
  eigen_assert((matrix.rows() == matrix.cols()) && "Only for squared matrices");
  
  m_isInitialized = true;
  
  
  // Apply the column permutation computed in analyzepattern()
  //   m_mat = matrix * m_perm_c.inverse(); 
  m_mat = matrix;
  if (m_perm_c.size()) 
  {
    m_mat.uncompress(); //NOTE: The effect of this command is only to create the InnerNonzeros pointers.
    //Then, permute only the column pointers
    const StorageIndex * outerIndexPtr;
    if (matrix.isCompressed()) outerIndexPtr = matrix.outerIndexPtr();
    else
    {
      StorageIndex* outerIndexPtr_t = new StorageIndex[matrix.cols()+1];
      for(Index i = 0; i <= matrix.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
      outerIndexPtr = outerIndexPtr_t;
    }
    for (Index i = 0; i < matrix.cols(); i++)
    {
      m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
      m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i+1] - outerIndexPtr[i];
    }
    if(!matrix.isCompressed()) delete[] outerIndexPtr;
  } 
  else 
  { //FIXME This should not be needed if the empty permutation is handled transparently
    m_perm_c.resize(matrix.cols());
    for(StorageIndex i = 0; i < matrix.cols(); ++i) m_perm_c.indices()(i) = i;
  }
  
  Index m = m_mat.rows();
  Index n = m_mat.cols();
  Index nnz = m_mat.nonZeros();
  Index maxpanel = m_perfv.panel_size * m;
  // Allocate working storage common to the factor routines
  Index lwork = 0;
  Index info = Base::memInit(m, n, nnz, lwork, m_perfv.fillfactor, m_perfv.panel_size, m_glu); 
  if (info) 
  {
    m_lastError = "UNABLE TO ALLOCATE WORKING MEMORY\n\n" ;
    m_factorizationIsOk = false;
    return ; 
  }
  
  // Set up pointers for integer working arrays 
  IndexVector segrep(m); segrep.setZero();
  IndexVector parent(m); parent.setZero();
  IndexVector xplore(m); xplore.setZero();
  IndexVector repfnz(maxpanel);
  IndexVector panel_lsub(maxpanel);
  IndexVector xprune(n); xprune.setZero();
  IndexVector marker(m*internal::LUNoMarker); marker.setZero();
  
  repfnz.setConstant(-1); 
  panel_lsub.setConstant(-1);
  
  // Set up pointers for scalar working arrays 
  ScalarVector dense; 
  dense.setZero(maxpanel);
  ScalarVector tempv; 
  tempv.setZero(internal::LUnumTempV(m, m_perfv.panel_size, m_perfv.maxsuper, /*m_perfv.rowblk*/m) );
  
  // Compute the inverse of perm_c
  PermutationType iperm_c(m_perm_c.inverse()); 
  
  // Identify initial relaxed snodes
  IndexVector relax_end(n);
  if ( m_symmetricmode == true ) 
    Base::heap_relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
  else
    Base::relax_snode(n, m_etree, m_perfv.relax, marker, relax_end);
  
  
  m_perm_r.resize(m); 
  m_perm_r.indices().setConstant(-1);
  marker.setConstant(-1);
  m_detPermR = 1; // Record the determinant of the row permutation
  
  m_glu.supno(0) = emptyIdxLU; m_glu.xsup.setConstant(0);
  m_glu.xsup(0) = m_glu.xlsub(0) = m_glu.xusub(0) = m_glu.xlusup(0) = Index(0);
  
  // Work on one 'panel' at a time. A panel is one of the following :
  //  (a) a relaxed supernode at the bottom of the etree, or
  //  (b) panel_size contiguous columns, <panel_size> defined by the user
  Index jcol; 
  IndexVector panel_histo(n);
  Index pivrow; // Pivotal row number in the original row matrix
  Index nseg1; // Number of segments in U-column above panel row jcol
  Index nseg; // Number of segments in each U-column 
  Index irep; 
  Index i, k, jj; 
  for (jcol = 0; jcol < n; )
  {
    // Adjust panel size so that a panel won't overlap with the next relaxed snode. 
    Index panel_size = m_perfv.panel_size; // upper bound on panel width
    for (k = jcol + 1; k < (std::min)(jcol+panel_size, n); k++)
    {
      if (relax_end(k) != emptyIdxLU) 
      {
        panel_size = k - jcol; 
        break; 
      }
    }
    if (k == n) 
      panel_size = n - jcol; 
      
    // Symbolic outer factorization on a panel of columns 
    Base::panel_dfs(m, panel_size, jcol, m_mat, m_perm_r.indices(), nseg1, dense, panel_lsub, segrep, repfnz, xprune, marker, parent, xplore, m_glu); 
    
    // Numeric sup-panel updates in topological order 
    Base::panel_bmod(m, panel_size, jcol, nseg1, dense, tempv, segrep, repfnz, m_glu); 
    
    // Sparse LU within the panel, and below the panel diagonal 
    for ( jj = jcol; jj< jcol + panel_size; jj++) 
    {
      k = (jj - jcol) * m; // Column index for w-wide arrays 
      
      nseg = nseg1; // begin after all the panel segments
      //Depth-first-search for the current column
      VectorBlock<IndexVector> panel_lsubk(panel_lsub, k, m);
      VectorBlock<IndexVector> repfnz_k(repfnz, k, m); 
      info = Base::column_dfs(m, jj, m_perm_r.indices(), m_perfv.maxsuper, nseg, panel_lsubk, segrep, repfnz_k, xprune, marker, parent, xplore, m_glu); 
      if ( info ) 
      {
        m_lastError =  "UNABLE TO EXPAND MEMORY IN COLUMN_DFS() ";
        m_info = NumericalIssue; 
        m_factorizationIsOk = false; 
        return; 
      }
      // Numeric updates to this column 
      VectorBlock<ScalarVector> dense_k(dense, k, m); 
      VectorBlock<IndexVector> segrep_k(segrep, nseg1, m-nseg1); 
      info = Base::column_bmod(jj, (nseg - nseg1), dense_k, tempv, segrep_k, repfnz_k, jcol, m_glu); 
      if ( info ) 
      {
        m_lastError = "UNABLE TO EXPAND MEMORY IN COLUMN_BMOD() ";
        m_info = NumericalIssue; 
        m_factorizationIsOk = false; 
        return; 
      }
      
      // Copy the U-segments to ucol(*)
      info = Base::copy_to_ucol(jj, nseg, segrep, repfnz_k ,m_perm_r.indices(), dense_k, m_glu); 
      if ( info ) 
      {
        m_lastError = "UNABLE TO EXPAND MEMORY IN COPY_TO_UCOL() ";
        m_info = NumericalIssue; 
        m_factorizationIsOk = false; 
        return; 
      }
      
      // Form the L-segment 
      info = Base::pivotL(jj, m_diagpivotthresh, m_perm_r.indices(), iperm_c.indices(), pivrow, m_glu);
      if ( info ) 
      {
        m_lastError = "THE MATRIX IS STRUCTURALLY SINGULAR ... ZERO COLUMN AT ";
        std::ostringstream returnInfo;
        returnInfo << info; 
        m_lastError += returnInfo.str();
        m_info = NumericalIssue; 
        m_factorizationIsOk = false; 
        return; 
      }
      
      // Update the determinant of the row permutation matrix
      // FIXME: the following test is not correct, we should probably take iperm_c into account and pivrow is not directly the row pivot.
      if (pivrow != jj) m_detPermR = -m_detPermR;
 
      // Prune columns (0:jj-1) using column jj
      Base::pruneL(jj, m_perm_r.indices(), pivrow, nseg, segrep, repfnz_k, xprune, m_glu); 
      
      // Reset repfnz for this column 
      for (i = 0; i < nseg; i++)
      {
        irep = segrep(i); 
        repfnz_k(irep) = emptyIdxLU; 
      }
    } // end SparseLU within the panel  
    jcol += panel_size;  // Move to the next panel
  } // end for -- end elimination 
  
  m_detPermR = m_perm_r.determinant();
  m_detPermC = m_perm_c.determinant();
  
  // Count the number of nonzeros in factors 
  Base::countnz(n, m_nnzL, m_nnzU, m_glu); 
  // Apply permutation  to the L subscripts 
  Base::fixupL(n, m_perm_r.indices(), m_glu);
  
  // Create supernode matrix L 
  m_Lstore.setInfos(m, n, m_glu.lusup, m_glu.xlusup, m_glu.lsub, m_glu.xlsub, m_glu.supno, m_glu.xsup); 
  // Create the column major upper sparse matrix  U; 
  new (&m_Ustore) MappedSparseMatrix<Scalar, ColMajor, StorageIndex> ( m, n, m_nnzU, m_glu.xusub.data(), m_glu.usub.data(), m_glu.ucol.data() );
  
  m_info = Success;
  m_factorizationIsOk = true;
}

References eigen_assert, Eigen::internal::emptyIdxLU, Eigen::PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, _StorageIndex >::indices(), Eigen::internal::LUNoMarker, Eigen::internal::LUnumTempV(), Eigen::NumericalIssue, Eigen::PlainObjectBase< Derived >::setConstant(), Eigen::PlainObjectBase< Derived >::setZero(), and Eigen::Success.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::compute().

Here is the call graph for this function:

Here is the caller graph for this function:

fixupL()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::fixupL ( const Index  n, const IndexVector &  perm_r, GlobalLU_t &  glu  )

protectedinherited

Fix up the data storage lsub for L-subscripts.

It removes the subscripts sets for structural pruning, and applies permutation to the remaining subscripts

{
  Index fsupc, i, j, k, jstart; 
  
  StorageIndex nextl = 0; 
  Index nsuper = (glu.supno)(n); 
  
  // For each supernode 
  for (i = 0; i <= nsuper; i++)
  {
    fsupc = glu.xsup(i); 
    jstart = glu.xlsub(fsupc); 
    glu.xlsub(fsupc) = nextl; 
    for (j = jstart; j < glu.xlsub(fsupc + 1); j++)
    {
      glu.lsub(nextl) = perm_r(glu.lsub(j)); // Now indexed into P*A
      nextl++;
    }
    for (k = fsupc+1; k < glu.xsup(i+1); k++)
      glu.xlsub(k) = nextl; // other columns in supernode i
  }
  
  glu.xlsub(n) = nextl; 
}

heap_relax_snode()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::heap_relax_snode ( const Index  n, IndexVector &  et, const Index  relax_columns, IndexVector &  descendants, IndexVector &  relax_end  )

protectedinherited

Identify the initial relaxed supernodes.

This routine applied to a symmetric elimination tree. It assumes that the matrix has been reordered according to the postorder of the etree

Parameters

n	The number of columns
et	elimination tree
relax_columns	Maximum number of columns allowed in a relaxed snode
descendants	Number of descendants of each node in the etree
relax_end	last column in a supernode

{
  
  // The etree may not be postordered, but its heap ordered  
  IndexVector post;
  internal::treePostorder(StorageIndex(n), et, post); // Post order etree
  IndexVector inv_post(n+1); 
  for (StorageIndex i = 0; i < n+1; ++i) inv_post(post(i)) = i; // inv_post = post.inverse()???
  
  // Renumber etree in postorder 
  IndexVector iwork(n);
  IndexVector et_save(n+1);
  for (Index i = 0; i < n; ++i)
  {
    iwork(post(i)) = post(et(i));
  }
  et_save = et; // Save the original etree
  et = iwork; 
  
  // compute the number of descendants of each node in the etree
  relax_end.setConstant(emptyIdxLU);
  Index j, parent; 
  descendants.setZero();
  for (j = 0; j < n; j++) 
  {
    parent = et(j);
    if (parent != n) // not the dummy root
      descendants(parent) += descendants(j) + 1;
  }
  // Identify the relaxed supernodes by postorder traversal of the etree
  Index snode_start; // beginning of a snode 
  StorageIndex k;
  Index nsuper_et_post = 0; // Number of relaxed snodes in postordered etree 
  Index nsuper_et = 0; // Number of relaxed snodes in the original etree 
  StorageIndex l; 
  for (j = 0; j < n; )
  {
    parent = et(j);
    snode_start = j; 
    while ( parent != n && descendants(parent) < relax_columns ) 
    {
      j = parent; 
      parent = et(j);
    }
    // Found a supernode in postordered etree, j is the last column 
    ++nsuper_et_post;
    k = StorageIndex(n);
    for (Index i = snode_start; i <= j; ++i)
      k = (std::min)(k, inv_post(i));
    l = inv_post(j);
    if ( (l - k) == (j - snode_start) )  // Same number of columns in the snode
    {
      // This is also a supernode in the original etree
      relax_end(k) = l; // Record last column 
      ++nsuper_et; 
    }
    else 
    {
      for (Index i = snode_start; i <= j; ++i) 
      {
        l = inv_post(i);
        if (descendants(i) == 0) 
        {
          relax_end(l) = l;
          ++nsuper_et;
        }
      }
    }
    j++;
    // Search for a new leaf
    while (descendants(j) != 0 && j < n) j++;
  } // End postorder traversal of the etree
  
  // Recover the original etree
  et = et_save; 
}

info()

template<typename _MatrixType , typename _OrderingType >

ComputationInfo Eigen::SparseLU< _MatrixType, _OrderingType >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

Success if computation was succesful, NumericalIssue if the LU factorization reports a problem, zero diagonal for instance InvalidInput if the input matrix is invalid

See also

iparm()

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

References eigen_assert, Eigen::SparseLU< _MatrixType, _OrderingType >::m_info, and Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::m_isInitialized.

Referenced by igl::copyleft::comiso::FrameInterpolator::interpolateSymmetric().

Here is the caller graph for this function:

initperfvalues()

template<typename _MatrixType , typename _OrderingType >

void Eigen::SparseLU< _MatrixType, _OrderingType >::initperfvalues ( )

inlineprotected

    {
      m_perfv.panel_size = 16;
      m_perfv.relax = 1; 
      m_perfv.maxsuper = 128; 
      m_perfv.rowblk = 16; 
      m_perfv.colblk = 8; 
      m_perfv.fillfactor = 20;  
    }

References Eigen::internal::perfvalues::colblk, Eigen::internal::perfvalues::fillfactor, Eigen::SparseLU< _MatrixType, _OrderingType >::m_perfv, Eigen::internal::perfvalues::maxsuper, Eigen::internal::perfvalues::panel_size, Eigen::internal::perfvalues::relax, and Eigen::internal::perfvalues::rowblk.

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

Here is the caller graph for this function:

isSymmetric()

template<typename _MatrixType , typename _OrderingType >

void Eigen::SparseLU< _MatrixType, _OrderingType >::isSymmetric ( bool  sym )

inline

Indicate that the pattern of the input matrix is symmetric

    {
      m_symmetricmode = sym;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_symmetricmode.

lastErrorMessage()

template<typename _MatrixType , typename _OrderingType >

std::string Eigen::SparseLU< _MatrixType, _OrderingType >::lastErrorMessage ( ) const

inline

Returns

A string describing the type of error

    {
      return m_lastError; 
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_lastError.

logAbsDeterminant()

template<typename _MatrixType , typename _OrderingType >

Scalar Eigen::SparseLU< _MatrixType, _OrderingType >::logAbsDeterminant ( ) const

inline

Returns

the natural log of the absolute value of the determinant of the matrix of which **this is the QR decomposition

Note

This method is useful to work around the risk of overflow/underflow that's inherent to the determinant computation.

See also

absDeterminant(), signDeterminant()

    {
      using std::log;
      using std::abs;
 
      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
      Scalar det = Scalar(0.);
      for (Index j = 0; j < this->cols(); ++j)
      {
        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
        {
          if(it.row() < j) continue;
          if(it.row() == j)
          {
            det += log(abs(it.value()));
            break;
          }
        }
      }
      return det;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::cols(), eigen_assert, log(), Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk, and Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore.

Here is the call graph for this function:

matrixL()

template<typename _MatrixType , typename _OrderingType >

SparseLUMatrixLReturnType< SCMatrix > Eigen::SparseLU< _MatrixType, _OrderingType >::matrixL ( ) const

inline

Returns

an expression of the matrix L, internally stored as supernodes The only operation available with this expression is the triangular solve

y = b; matrixL().solveInPlace(y);

    {
      return SparseLUMatrixLReturnType<SCMatrix>(m_Lstore);
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl().

Here is the caller graph for this function:

matrixU()

template<typename _MatrixType , typename _OrderingType >

SparseLUMatrixUReturnType< SCMatrix, MappedSparseMatrix< Scalar, ColMajor, StorageIndex > > Eigen::SparseLU< _MatrixType, _OrderingType >::matrixU ( ) const

inline

Returns

an expression of the matrix U, The only operation available with this expression is the triangular solve

y = b; matrixU().solveInPlace(y);

    {
      return SparseLUMatrixUReturnType<SCMatrix, MappedSparseMatrix<Scalar,ColMajor,StorageIndex> >(m_Lstore, m_Ustore);
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore, and Eigen::SparseLU< _MatrixType, _OrderingType >::m_Ustore.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl().

Here is the caller graph for this function:

memInit()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::memInit ( Index  m, Index  n, Index  annz, Index  lwork, Index  fillratio, Index  panel_size, GlobalLU_t &  glu  )

protectedinherited

Allocate various working space for the numerical factorization phase.

Parameters

m	number of rows of the input matrix
n	number of columns
annz	number of initial nonzeros in the matrix
lwork	if lwork=-1, this routine returns an estimated size of the required memory
glu	persistent data to facilitate multiple factors : will be deleted later ??
fillratio	estimated ratio of fill in the factors
panel_size	Size of a panel

Returns

an estimated size of the required memory if lwork = -1; otherwise, return the size of actually allocated memory when allocation failed, and 0 on success

Note

Unlike SuperLU, this routine does not support successive factorization with the same pattern and the same row permutation

{
  Index& num_expansions = glu.num_expansions; //No memory expansions so far
  num_expansions = 0;
  glu.nzumax = glu.nzlumax = (std::min)(fillratio * (annz+1) / n, m) * n; // estimated number of nonzeros in U 
  glu.nzlmax = (std::max)(Index(4), fillratio) * (annz+1) / 4; // estimated  nnz in L factor
  // Return the estimated size to the user if necessary
  Index tempSpace;
  tempSpace = (2*panel_size + 4 + LUNoMarker) * m * sizeof(Index) + (panel_size + 1) * m * sizeof(Scalar);
  if (lwork == emptyIdxLU) 
  {
    Index estimated_size;
    estimated_size = (5 * n + 5) * sizeof(Index)  + tempSpace
                    + (glu.nzlmax + glu.nzumax) * sizeof(Index) + (glu.nzlumax+glu.nzumax) *  sizeof(Scalar) + n; 
    return estimated_size;
  }
  
  // Setup the required space 
  
  // First allocate Integer pointers for L\U factors
  glu.xsup.resize(n+1);
  glu.supno.resize(n+1);
  glu.xlsub.resize(n+1);
  glu.xlusup.resize(n+1);
  glu.xusub.resize(n+1);
 
  // Reserve memory for L/U factors
  do 
  {
    if(     (expand<ScalarVector>(glu.lusup, glu.nzlumax, 0, 0, num_expansions)<0)
        ||  (expand<ScalarVector>(glu.ucol,  glu.nzumax,  0, 0, num_expansions)<0)
        ||  (expand<IndexVector> (glu.lsub,  glu.nzlmax,  0, 0, num_expansions)<0)
        ||  (expand<IndexVector> (glu.usub,  glu.nzumax,  0, 1, num_expansions)<0) )
    {
      //Reduce the estimated size and retry
      glu.nzlumax /= 2;
      glu.nzumax /= 2;
      glu.nzlmax /= 2;
      if (glu.nzlumax < annz ) return glu.nzlumax; 
    }
  } while (!glu.lusup.size() || !glu.ucol.size() || !glu.lsub.size() || !glu.usub.size());
  
  ++num_expansions;
  return 0;
  
} // end LuMemInit

memXpand()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::memXpand ( VectorType &  vec, Index &  maxlen, Index  nbElts, MemType  memtype, Index &  num_expansions  )

protectedinherited

Expand the existing storage.

Parameters

	vec	vector to expand
[in,out]	maxlen	On input, previous size of vec (Number of elements to copy ). on output, new size
	nbElts	current number of elements in the vector.
	memtype	Type of the element to expand
	num_expansions	Number of expansions

Returns

0 on success, > 0 size of the memory allocated so far

{
  Index failed_size; 
  if (memtype == USUB)
     failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 1, num_expansions);
  else
    failed_size = this->expand<VectorType>(vec, maxlen, nbElts, 0, num_expansions);
 
  if (failed_size)
    return failed_size; 
  
  return 0 ;  
}

panel_bmod()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::panel_bmod ( const Index  m, const Index  w, const Index  jcol, const Index  nseg, ScalarVector &  dense, ScalarVector &  tempv, IndexVector &  segrep, IndexVector &  repfnz, GlobalLU_t &  glu  )

protectedinherited

Performs numeric block updates (sup-panel) in topological order.

Before entering this routine, the original nonzeros in the panel were already copied i nto the spa[m,w]

Parameters

m	number of rows in the matrix
w	Panel size
jcol	Starting column of the panel
nseg	Number of segments in the U part
dense	Store the full representation of the panel
tempv	working array
segrep	segment representative... first row in the segment
repfnz	First nonzero rows
glu	Global LU data.

{
  
  Index ksub,jj,nextl_col; 
  Index fsupc, nsupc, nsupr, nrow; 
  Index krep, kfnz; 
  Index lptr; // points to the row subscripts of a supernode 
  Index luptr; // ...
  Index segsize,no_zeros ; 
  // For each nonz supernode segment of U[*,j] in topological order
  Index k = nseg - 1; 
  const Index PacketSize = internal::packet_traits<Scalar>::size;
  
  for (ksub = 0; ksub < nseg; ksub++)
  { // For each updating supernode
    /* krep = representative of current k-th supernode
     * fsupc =  first supernodal column
     * nsupc = number of columns in a supernode
     * nsupr = number of rows in a supernode
     */
    krep = segrep(k); k--; 
    fsupc = glu.xsup(glu.supno(krep)); 
    nsupc = krep - fsupc + 1; 
    nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); 
    nrow = nsupr - nsupc; 
    lptr = glu.xlsub(fsupc); 
    
    // loop over the panel columns to detect the actual number of columns and rows
    Index u_rows = 0;
    Index u_cols = 0;
    for (jj = jcol; jj < jcol + w; jj++)
    {
      nextl_col = (jj-jcol) * m; 
      VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
      
      kfnz = repfnz_col(krep); 
      if ( kfnz == emptyIdxLU ) 
        continue; // skip any zero segment
      
      segsize = krep - kfnz + 1;
      u_cols++;
      u_rows = (std::max)(segsize,u_rows);
    }
    
    if(nsupc >= 2)
    { 
      Index ldu = internal::first_multiple<Index>(u_rows, PacketSize);
      Map<ScalarMatrix, Aligned,  OuterStride<> > U(tempv.data(), u_rows, u_cols, OuterStride<>(ldu));
      
      // gather U
      Index u_col = 0;
      for (jj = jcol; jj < jcol + w; jj++)
      {
        nextl_col = (jj-jcol) * m; 
        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
        
        kfnz = repfnz_col(krep); 
        if ( kfnz == emptyIdxLU ) 
          continue; // skip any zero segment
        
        segsize = krep - kfnz + 1;
        luptr = glu.xlusup(fsupc);    
        no_zeros = kfnz - fsupc; 
        
        Index isub = lptr + no_zeros;
        Index off = u_rows-segsize;
        for (Index i = 0; i < off; i++) U(i,u_col) = 0;
        for (Index i = 0; i < segsize; i++)
        {
          Index irow = glu.lsub(isub); 
          U(i+off,u_col) = dense_col(irow); 
          ++isub; 
        }
        u_col++;
      }
      // solve U = A^-1 U
      luptr = glu.xlusup(fsupc);
      Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc);
      no_zeros = (krep - u_rows + 1) - fsupc;
      luptr += lda * no_zeros + no_zeros;
      MappedMatrixBlock A(glu.lusup.data()+luptr, u_rows, u_rows, OuterStride<>(lda) );
      U = A.template triangularView<UnitLower>().solve(U);
      
      // update
      luptr += u_rows;
      MappedMatrixBlock B(glu.lusup.data()+luptr, nrow, u_rows, OuterStride<>(lda) );
      eigen_assert(tempv.size()>w*ldu + nrow*w + 1);
      
      Index ldl = internal::first_multiple<Index>(nrow, PacketSize);
      Index offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize)) % PacketSize;
      MappedMatrixBlock L(tempv.data()+w*ldu+offset, nrow, u_cols, OuterStride<>(ldl));
      
      L.setZero();
      internal::sparselu_gemm<Scalar>(L.rows(), L.cols(), B.cols(), B.data(), B.outerStride(), U.data(), U.outerStride(), L.data(), L.outerStride());
      
      // scatter U and L
      u_col = 0;
      for (jj = jcol; jj < jcol + w; jj++)
      {
        nextl_col = (jj-jcol) * m; 
        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
        
        kfnz = repfnz_col(krep); 
        if ( kfnz == emptyIdxLU ) 
          continue; // skip any zero segment
        
        segsize = krep - kfnz + 1;
        no_zeros = kfnz - fsupc; 
        Index isub = lptr + no_zeros;
        
        Index off = u_rows-segsize;
        for (Index i = 0; i < segsize; i++)
        {
          Index irow = glu.lsub(isub++); 
          dense_col(irow) = U.coeff(i+off,u_col);
          U.coeffRef(i+off,u_col) = 0;
        }
        
        // Scatter l into SPA dense[]
        for (Index i = 0; i < nrow; i++)
        {
          Index irow = glu.lsub(isub++); 
          dense_col(irow) -= L.coeff(i,u_col);
          L.coeffRef(i,u_col) = 0;
        }
        u_col++;
      }
    }
    else // level 2 only
    {
      // Sequence through each column in the panel
      for (jj = jcol; jj < jcol + w; jj++)
      {
        nextl_col = (jj-jcol) * m; 
        VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row
        VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here
        
        kfnz = repfnz_col(krep); 
        if ( kfnz == emptyIdxLU ) 
          continue; // skip any zero segment
        
        segsize = krep - kfnz + 1;
        luptr = glu.xlusup(fsupc);
        
        Index lda = glu.xlusup(fsupc+1)-glu.xlusup(fsupc);// nsupr
        
        // Perform a trianglar solve and block update, 
        // then scatter the result of sup-col update to dense[]
        no_zeros = kfnz - fsupc; 
              if(segsize==1)  LU_kernel_bmod<1>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
        else  if(segsize==2)  LU_kernel_bmod<2>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
        else  if(segsize==3)  LU_kernel_bmod<3>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros);
        else                  LU_kernel_bmod<Dynamic>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); 
      } // End for each column in the panel 
    }
    
  } // End for each updating supernode
} // end panel bmod

panel_dfs()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::panel_dfs ( const Index  m, const Index  w, const Index  jcol, MatrixType &  A, IndexVector &  perm_r, Index &  nseg, ScalarVector &  dense, IndexVector &  panel_lsub, IndexVector &  segrep, IndexVector &  repfnz, IndexVector &  xprune, IndexVector &  marker, IndexVector &  parent, IndexVector &  xplore, GlobalLU_t &  glu  )

protectedinherited

Performs a symbolic factorization on a panel of columns [jcol, jcol+w)

A supernode representative is the last column of a supernode. The nonzeros in U[*,j] are segments that end at supernodes representatives

The routine returns a list of the supernodal representatives in topological order of the dfs that generates them. This list is a superset of the topological order of each individual column within the panel. The location of the first nonzero in each supernodal segment (supernodal entry location) is also returned. Each column has a separate list for this purpose.

Two markers arrays are used for dfs : marker[i] == jj, if i was visited during dfs of current column jj; marker1[i] >= jcol, if i was visited by earlier columns in this panel;

Parameters

[in]	m	number of rows in the matrix
[in]	w	Panel size
[in]	jcol	Starting column of the panel
[in]	A	Input matrix in column-major storage
[in]	perm_r	Row permutation
[out]	nseg	Number of U segments
[out]	dense	Accumulate the column vectors of the panel
[out]	panel_lsub	Subscripts of the row in the panel
[out]	segrep	Segment representative i.e first nonzero row of each segment
[out]	repfnz	First nonzero location in each row
[out]	xprune	The pruned elimination tree
[out]	marker	work vector
	parent	The elimination tree
	xplore	work vector
	glu	The global data structure

{
  Index nextl_col; // Next available position in panel_lsub[*,jj] 
  
  // Initialize pointers 
  VectorBlock<IndexVector> marker1(marker, m, m); 
  nseg = 0; 
  
  panel_dfs_traits<IndexVector> traits(jcol, marker1.data());
  
  // For each column in the panel 
  for (StorageIndex jj = StorageIndex(jcol); jj < jcol + w; jj++) 
  {
    nextl_col = (jj - jcol) * m; 
    
    VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero location in each row
    VectorBlock<ScalarVector> dense_col(dense,nextl_col, m); // Accumulate a column vector here
    
    
    // For each nnz in A[*, jj] do depth first search
    for (typename MatrixType::InnerIterator it(A, jj); it; ++it)
    {
      Index krow = it.row(); 
      dense_col(krow) = it.value();
      
      StorageIndex kmark = marker(krow); 
      if (kmark == jj) 
        continue; // krow visited before, go to the next nonzero
      
      dfs_kernel(jj, perm_r, nseg, panel_lsub, segrep, repfnz_col, xprune, marker, parent,
                   xplore, glu, nextl_col, krow, traits);
    }// end for nonzeros in column jj
    
  } // end for column jj
}

pivotL()

Index SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::pivotL ( const Index  jcol, const RealScalar &  diagpivotthresh, IndexVector &  perm_r, IndexVector &  iperm_c, Index &  pivrow, GlobalLU_t &  glu  )

protectedinherited

Performs the numerical pivotin on the current column of L, and the CDIV operation.

Pivot policy : (1) Compute thresh = u * max_(i>=j) abs(A_ij); (2) IF user specifies pivot row k and abs(A_kj) >= thresh THEN pivot row = k; ELSE IF abs(A_jj) >= thresh THEN pivot row = j; ELSE pivot row = m;

Note: If you absolutely want to use a given pivot order, then set u=0.0.

Parameters

	jcol	The current column of L
	diagpivotthresh	diagonal pivoting threshold
[in,out]	perm_r	Row permutation (threshold pivoting)
[in]	iperm_c	column permutation - used to finf diagonal of Pc*A*Pc'
[out]	pivrow	The pivot row
	glu	Global LU data

Returns

0 if success, i > 0 if U(i,i) is exactly zero

{
  
  Index fsupc = (glu.xsup)((glu.supno)(jcol)); // First column in the supernode containing the column jcol
  Index nsupc = jcol - fsupc; // Number of columns in the supernode portion, excluding jcol; nsupc >=0
  Index lptr = glu.xlsub(fsupc); // pointer to the starting location of the row subscripts for this supernode portion
  Index nsupr = glu.xlsub(fsupc+1) - lptr; // Number of rows in the supernode
  Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); // leading dimension
  Scalar* lu_sup_ptr = &(glu.lusup.data()[glu.xlusup(fsupc)]); // Start of the current supernode
  Scalar* lu_col_ptr = &(glu.lusup.data()[glu.xlusup(jcol)]); // Start of jcol in the supernode
  StorageIndex* lsub_ptr = &(glu.lsub.data()[lptr]); // Start of row indices of the supernode
  
  // Determine the largest abs numerical value for partial pivoting 
  Index diagind = iperm_c(jcol); // diagonal index 
  RealScalar pivmax(-1.0);
  Index pivptr = nsupc; 
  Index diag = emptyIdxLU; 
  RealScalar rtemp;
  Index isub, icol, itemp, k; 
  for (isub = nsupc; isub < nsupr; ++isub) {
    using std::abs;
    rtemp = abs(lu_col_ptr[isub]);
    if (rtemp > pivmax) {
      pivmax = rtemp; 
      pivptr = isub;
    } 
    if (lsub_ptr[isub] == diagind) diag = isub;
  }
  
  // Test for singularity
  if ( pivmax <= RealScalar(0.0) ) {
    // if pivmax == -1, the column is structurally empty, otherwise it is only numerically zero
    pivrow = pivmax < RealScalar(0.0) ? diagind : lsub_ptr[pivptr];
    perm_r(pivrow) = StorageIndex(jcol);
    return (jcol+1);
  }
  
  RealScalar thresh = diagpivotthresh * pivmax; 
  
  // Choose appropriate pivotal element 
  
  {
    // Test if the diagonal element can be used as a pivot (given the threshold value)
    if (diag >= 0 ) 
    {
      // Diagonal element exists
      using std::abs;
      rtemp = abs(lu_col_ptr[diag]);
      if (rtemp != RealScalar(0.0) && rtemp >= thresh) pivptr = diag;
    }
    pivrow = lsub_ptr[pivptr];
  }
  
  // Record pivot row
  perm_r(pivrow) = StorageIndex(jcol);
  // Interchange row subscripts
  if (pivptr != nsupc )
  {
    std::swap( lsub_ptr[pivptr], lsub_ptr[nsupc] );
    // Interchange numerical values as well, for the two rows in the whole snode
    // such that L is indexed the same way as A
    for (icol = 0; icol <= nsupc; icol++)
    {
      itemp = pivptr + icol * lda; 
      std::swap(lu_sup_ptr[itemp], lu_sup_ptr[nsupc + icol * lda]);
    }
  }
  // cdiv operations
  Scalar temp = Scalar(1.0) / lu_col_ptr[nsupc];
  for (k = nsupc+1; k < nsupr; k++)
    lu_col_ptr[k] *= temp; 
  return 0;
}

pruneL()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::pruneL ( const Index  jcol, const IndexVector &  perm_r, const Index  pivrow, const Index  nseg, const IndexVector &  segrep, BlockIndexVector  repfnz, IndexVector &  xprune, GlobalLU_t &  glu  )

protectedinherited

Prunes the L-structure.

It prunes the L-structure of supernodes whose L-structure contains the current pivot row "pivrow"

Parameters

	jcol	The current column of L
[in]	perm_r	Row permutation
[out]	pivrow	The pivot row
	nseg	Number of segments
	segrep
	repfnz
[out]	xprune
	glu	Global LU data

{
  // For each supernode-rep irep in U(*,j]
  Index jsupno = glu.supno(jcol); 
  Index i,irep,irep1; 
  bool movnum, do_prune = false; 
  Index kmin = 0, kmax = 0, minloc, maxloc,krow; 
  for (i = 0; i < nseg; i++)
  {
    irep = segrep(i); 
    irep1 = irep + 1; 
    do_prune = false; 
    
    // Don't prune with a zero U-segment 
    if (repfnz(irep) == emptyIdxLU) continue; 
    
    // If a snode overlaps with the next panel, then the U-segment
    // is fragmented into two parts -- irep and irep1. We should let 
    // pruning occur at the rep-column in irep1s snode. 
    if (glu.supno(irep) == glu.supno(irep1) ) continue; // don't prune 
    
    // If it has not been pruned & it has a nonz in row L(pivrow,i)
    if (glu.supno(irep) != jsupno )
    {
      if ( xprune (irep) >= glu.xlsub(irep1) )
      {
        kmin = glu.xlsub(irep);
        kmax = glu.xlsub(irep1) - 1; 
        for (krow = kmin; krow <= kmax; krow++)
        {
          if (glu.lsub(krow) == pivrow) 
          {
            do_prune = true; 
            break; 
          }
        }
      }
      
      if (do_prune) 
      {
        // do a quicksort-type partition
        // movnum=true means that the num values have to be exchanged
        movnum = false; 
        if (irep == glu.xsup(glu.supno(irep)) ) // Snode of size 1 
          movnum = true; 
        
        while (kmin <= kmax)
        {
          if (perm_r(glu.lsub(kmax)) == emptyIdxLU)
            kmax--; 
          else if ( perm_r(glu.lsub(kmin)) != emptyIdxLU)
            kmin++;
          else 
          {
            // kmin below pivrow (not yet pivoted), and kmax
            // above pivrow: interchange the two suscripts
            std::swap(glu.lsub(kmin), glu.lsub(kmax)); 
            
            // If the supernode has only one column, then we 
            // only keep one set of subscripts. For any subscript
            // intercnahge performed, similar interchange must be 
            // done on the numerical values. 
            if (movnum) 
            {
              minloc = glu.xlusup(irep) + ( kmin - glu.xlsub(irep) ); 
              maxloc = glu.xlusup(irep) + ( kmax - glu.xlsub(irep) ); 
              std::swap(glu.lusup(minloc), glu.lusup(maxloc)); 
            }
            kmin++;
            kmax--;
          }
        } // end while 
        
        xprune(irep) = StorageIndex(kmin);  //Pruning 
      } // end if do_prune 
    } // end pruning 
  } // End for each U-segment
}

relax_snode()

void SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::relax_snode ( const Index  n, IndexVector &  et, const Index  relax_columns, IndexVector &  descendants, IndexVector &  relax_end  )

protectedinherited

Identify the initial relaxed supernodes.

This routine is applied to a column elimination tree. It assumes that the matrix has been reordered according to the postorder of the etree

Parameters

n	the number of columns
et	elimination tree
relax_columns	Maximum number of columns allowed in a relaxed snode
descendants	Number of descendants of each node in the etree
relax_end	last column in a supernode

{
  
  // compute the number of descendants of each node in the etree
  Index parent; 
  relax_end.setConstant(emptyIdxLU);
  descendants.setZero();
  for (Index j = 0; j < n; j++) 
  {
    parent = et(j);
    if (parent != n) // not the dummy root
      descendants(parent) += descendants(j) + 1;
  }
  // Identify the relaxed supernodes by postorder traversal of the etree
  Index snode_start; // beginning of a snode 
  for (Index j = 0; j < n; )
  {
    parent = et(j);
    snode_start = j; 
    while ( parent != n && descendants(parent) < relax_columns ) 
    {
      j = parent; 
      parent = et(j);
    }
    // Found a supernode in postordered etree, j is the last column 
    relax_end(snode_start) = StorageIndex(j); // Record last column
    j++;
    // Search for a new leaf
    while (descendants(j) != 0 && j < n) j++;
  } // End postorder traversal of the etree
  
}

rows()

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::rows ( ) const

inline

{ return m_mat.rows(); }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_mat, and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows().

Here is the call graph for this function:

rowsPermutation()

template<typename _MatrixType , typename _OrderingType >

const PermutationType & Eigen::SparseLU< _MatrixType, _OrderingType >::rowsPermutation ( ) const

inline

Returns

a reference to the row matrix permutation such that

See also

colsPermutation()

    {
      return m_perm_r;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_perm_r.

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl().

Here is the caller graph for this function:

setPivotThreshold()

template<typename _MatrixType , typename _OrderingType >

void Eigen::SparseLU< _MatrixType, _OrderingType >::setPivotThreshold ( const RealScalar &  thresh )

inline

Set the threshold used for a diagonal entry to be an acceptable pivot.

    {
      m_diagpivotthresh = thresh; 
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::m_diagpivotthresh.

signDeterminant()

template<typename _MatrixType , typename _OrderingType >

Scalar Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant ( )

inline

Returns

A number representing the sign of the determinant

See also

absDeterminant(), logAbsDeterminant()

    {
      eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
      // Initialize with the determinant of the row matrix
      Index det = 1;
      // Note that the diagonal blocks of U are stored in supernodes,
      // which are available in the  L part :)
      for (Index j = 0; j < this->cols(); ++j)
      {
        for (typename SCMatrix::InnerIterator it(m_Lstore, j); it; ++it)
        {
          if(it.index() == j)
          {
            if(it.value()<0)
              det = -det;
            else if(it.value()==0)
              return 0;
            break;
          }
        }
      }
      return det * m_detPermR * m_detPermC;
    }

References Eigen::SparseLU< _MatrixType, _OrderingType >::cols(), eigen_assert, Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermC, Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermR, Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk, and Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore.

Here is the call graph for this function:

simplicialfactorize()

template<typename _MatrixType , typename _OrderingType >

void Eigen::SparseLU< _MatrixType, _OrderingType >::simplicialfactorize

(

const MatrixType &

matrix

)

snode_bmod()

Index Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::snode_bmod ( const Index  jcol, const Index  fsupc, ScalarVector &  dense, GlobalLU_t &  glu  )

protectedinherited

snode_dfs()

Index Eigen::internal::SparseLUImpl< _MatrixType::Scalar , _MatrixType::StorageIndex >::snode_dfs ( const Index  jcol, const Index  kcol, const MatrixType &  mat, IndexVector &  xprune, IndexVector &  marker, GlobalLU_t &  glu  )

protectedinherited

solve() [1/2]

const Solve< SparseLU< _MatrixType, _OrderingType > , Rhs > Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::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());
    }

solve() [2/2]

const Solve< SparseLU< _MatrixType, _OrderingType > , Rhs > Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::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 , typename _OrderingType >

bool Eigen::SparseLU< _MatrixType, _OrderingType >::m_analysisIsOk

protected

m_detPermC

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermC

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::determinant(), and Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant().

m_detPermR

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::m_detPermR

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::determinant(), and Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant().

m_diagpivotthresh

template<typename _MatrixType , typename _OrderingType >

RealScalar Eigen::SparseLU< _MatrixType, _OrderingType >::m_diagpivotthresh

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::setPivotThreshold().

m_etree

template<typename _MatrixType , typename _OrderingType >

IndexVector Eigen::SparseLU< _MatrixType, _OrderingType >::m_etree

protected

m_factorizationIsOk

template<typename _MatrixType , typename _OrderingType >

bool Eigen::SparseLU< _MatrixType, _OrderingType >::m_factorizationIsOk

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::_solve_impl(), Eigen::SparseLU< _MatrixType, _OrderingType >::absDeterminant(), Eigen::SparseLU< _MatrixType, _OrderingType >::determinant(), Eigen::SparseLU< _MatrixType, _OrderingType >::logAbsDeterminant(), and Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant().

m_glu

template<typename _MatrixType , typename _OrderingType >

Base::GlobalLU_t Eigen::SparseLU< _MatrixType, _OrderingType >::m_glu

protected

m_info

template<typename _MatrixType , typename _OrderingType >

ComputationInfo Eigen::SparseLU< _MatrixType, _OrderingType >::m_info

mutableprotected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::info().

m_isInitialized

bool Eigen::SparseSolverBase< SparseLU< _MatrixType, _OrderingType > >::m_isInitialized

mutableprotectedinherited

m_lastError

template<typename _MatrixType , typename _OrderingType >

std::string Eigen::SparseLU< _MatrixType, _OrderingType >::m_lastError

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::lastErrorMessage().

m_Lstore

template<typename _MatrixType , typename _OrderingType >

SCMatrix Eigen::SparseLU< _MatrixType, _OrderingType >::m_Lstore

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::absDeterminant(), Eigen::SparseLU< _MatrixType, _OrderingType >::determinant(), Eigen::SparseLU< _MatrixType, _OrderingType >::logAbsDeterminant(), Eigen::SparseLU< _MatrixType, _OrderingType >::matrixL(), Eigen::SparseLU< _MatrixType, _OrderingType >::matrixU(), and Eigen::SparseLU< _MatrixType, _OrderingType >::signDeterminant().

m_mat

template<typename _MatrixType , typename _OrderingType >

NCMatrix Eigen::SparseLU< _MatrixType, _OrderingType >::m_mat

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::cols(), and Eigen::SparseLU< _MatrixType, _OrderingType >::rows().

m_nnzL

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::m_nnzL

protected

m_nnzU

template<typename _MatrixType , typename _OrderingType >

Index Eigen::SparseLU< _MatrixType, _OrderingType >::m_nnzU

protected

m_perfv

template<typename _MatrixType , typename _OrderingType >

internal::perfvalues Eigen::SparseLU< _MatrixType, _OrderingType >::m_perfv

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::initperfvalues().

m_perm_c

template<typename _MatrixType , typename _OrderingType >

PermutationType Eigen::SparseLU< _MatrixType, _OrderingType >::m_perm_c

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::colsPermutation().

m_perm_r

template<typename _MatrixType , typename _OrderingType >

PermutationType Eigen::SparseLU< _MatrixType, _OrderingType >::m_perm_r

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::rowsPermutation().

m_symmetricmode

template<typename _MatrixType , typename _OrderingType >

bool Eigen::SparseLU< _MatrixType, _OrderingType >::m_symmetricmode

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::isSymmetric().

m_Ustore

template<typename _MatrixType , typename _OrderingType >

MappedSparseMatrix<Scalar,ColMajor,StorageIndex> Eigen::SparseLU< _MatrixType, _OrderingType >::m_Ustore

protected

Referenced by Eigen::SparseLU< _MatrixType, _OrderingType >::matrixU().

---

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

• src/eigen/Eigen/src/SparseLU/SparseLU.h