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

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

#include <SparseLU.h>

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

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

Public Types
typedef _MatrixType	MatrixType
typedef _OrderingType	OrderingType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::Index	Index
typedef SparseMatrix< Scalar, ColMajor, Index >	NCMatrix
typedef internal::MappedSuperNodalMatrix< Scalar, Index >	SCMatrix
typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector
typedef Matrix< Index, Dynamic, 1 >	IndexVector
typedef PermutationMatrix< Dynamic, Dynamic, Index >	PermutationType
typedef internal::SparseLUImpl< Scalar, Index >	Base
Public Types inherited from Eigen::internal::SparseLUImpl< _MatrixType::Scalar, _MatrixType::Index >
typedef Matrix< _MatrixType::Scalar, Dynamic, 1 >	ScalarVector
typedef Matrix< _MatrixType::Index, Dynamic, 1 >	IndexVector
typedef ScalarVector::RealScalar	RealScalar
typedef Ref< Matrix< _MatrixType::Scalar, Dynamic, 1 > >	BlockScalarVector
typedef Ref< Matrix< _MatrixType::Index, Dynamic, 1 > >	BlockIndexVector
typedef LU_GlobalLU_t< IndexVector, ScalarVector >	GlobalLU_t
typedef SparseMatrix< _MatrixType::Scalar, ColMajor, _MatrixType::Index >	MatrixType

Public Member Functions
	SparseLU (const MatrixType &matrix)
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, Index > >	matrixU () const
const PermutationType &	rowsPermutation () const
const PermutationType &	colsPermutation () const
void	setPivotThreshold (const RealScalar &thresh)
template<typename Rhs >
const internal::solve_retval< SparseLU, Rhs >	solve (const MatrixBase< Rhs > &B) const
template<typename Rhs >
const internal::sparse_solve_retval< SparseLU, Rhs >	solve (const SparseMatrixBase< Rhs > &B) const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
std::string	lastErrorMessage () const
template<typename Rhs , typename Dest >
bool	_solve (const MatrixBase< Rhs > &B, MatrixBase< Dest > &_X) const
Scalar	absDeterminant ()
Scalar	logAbsDeterminant () const
Scalar	signDeterminant ()

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

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

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

See also

TutorialSparseDirectSolvers

OrderingMethods_Module

Definition at line 17 of file SparseLU.h.

Member Function Documentation

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

Definition at line 256 of file SparseLU.h.

    {
      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.row() < j) continue;
          if(it.row() == j)
          {
            det *= (std::abs)(it.value());
            break;
          }
        }
       }
       return det;
     }

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

Definition at line 369 of file SparseLU.h.

{
  
  //TODO  It is possible as in SuperLU to compute row and columns scaling vectors to equilibrate the matrix mat.
  
  OrderingType ord; 
  ord(mat,m_perm_c);
  
  // Apply the permutation to the column of the input  matrix
  //First copy the whole input matrix. 
  m_mat = mat;
  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
    const Index * outerIndexPtr;
    if (mat.isCompressed()) outerIndexPtr = mat.outerIndexPtr();
    else
    {
      Index *outerIndexPtr_t = new Index[mat.cols()+1];
      for(Index i = 0; i <= mat.cols(); i++) outerIndexPtr_t[i] = m_mat.outerIndexPtr()[i];
      outerIndexPtr = outerIndexPtr_t;
    }
    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];
    }
    if(!mat.isCompressed()) delete[] outerIndexPtr;
  }
  // 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(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; 
}

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

Definition at line 161 of file SparseLU.h.

    {
      return m_perm_c;
    }

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.

Definition at line 112 of file SparseLU.h.

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

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.  

Definition at line 452 of file SparseLU.h.

{
  using internal::emptyIdxLU;
  eigen_assert(m_analysisIsOk && "analyzePattern() should be called first"); 
  eigen_assert((matrix.rows() == matrix.cols()) && "Only for squared matrices");
  
  typedef typename IndexVector::Scalar Index; 
  
  
  // 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 Index * outerIndexPtr;
    if (matrix.isCompressed()) outerIndexPtr = matrix.outerIndexPtr();
    else
    {
      Index* outerIndexPtr_t = new Index[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(Index 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
      if (pivrow != jj) m_detPermR *= -1;

      // 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 
  
  // 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, Index> ( m, n, m_nnzU, m_glu.xusub.data(), m_glu.usub.data(), m_glu.ucol.data() ); 
  
  m_info = Success;
  m_factorizationIsOk = true;
}

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

Definition at line 207 of file SparseLU.h.

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

template<typename _MatrixType , typename _OrderingType >

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

inline

Indicate that the pattern of the input matrix is symmetric

Definition at line 123 of file SparseLU.h.

    {
      m_symmetricmode = sym;
    }

template<typename _MatrixType , typename _OrderingType >

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

inline

Returns

A string describing the type of error

Definition at line 216 of file SparseLU.h.

    {
      return m_lastError; 
    }

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

Definition at line 286 of file SparseLU.h.

     {
       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 += (std::log)((std::abs)(it.value()));
             break;
           }
         }
       }
       return det;
     }

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

Definition at line 134 of file SparseLU.h.

    {
      return SparseLUMatrixLReturnType<SCMatrix>(m_Lstore);
    }

template<typename _MatrixType , typename _OrderingType >

SparseLUMatrixUReturnType<SCMatrix,MappedSparseMatrix<Scalar,ColMajor,Index> > 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);

Definition at line 144 of file SparseLU.h.

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

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

Definition at line 153 of file SparseLU.h.

    {
      return m_perm_r;
    }

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.

Definition at line 166 of file SparseLU.h.

    {
      m_diagpivotthresh = thresh; 
    }

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

Definition at line 309 of file SparseLU.h.

     {
       eigen_assert(m_factorizationIsOk && "The matrix should be factorized first.");
       return Scalar(m_detPermR);
     }

template<typename _MatrixType , typename _OrderingType >

template<typename Rhs >

const internal::solve_retval<SparseLU, Rhs> Eigen::SparseLU< _MatrixType, _OrderingType >::solve ( const MatrixBase< Rhs > &  B ) const

inline

Returns

the solution X of using the current decomposition of A.

Warning

the destination matrix X in X = this->solve(B) must be colmun-major.

See also

compute()

Definition at line 178 of file SparseLU.h.

    {
      eigen_assert(m_factorizationIsOk && "SparseLU is not initialized."); 
      eigen_assert(rows()==B.rows()
                    && "SparseLU::solve(): invalid number of rows of the right hand side matrix B");
          return internal::solve_retval<SparseLU, Rhs>(*this, B.derived());
    }

template<typename _MatrixType , typename _OrderingType >

template<typename Rhs >

const internal::sparse_solve_retval<SparseLU, Rhs> Eigen::SparseLU< _MatrixType, _OrderingType >::solve ( const SparseMatrixBase< Rhs > &  B ) const

inline

Returns

the solution X of using the current decomposition of A.

See also

compute()

Definition at line 191 of file SparseLU.h.

    {
      eigen_assert(m_factorizationIsOk && "SparseLU is not initialized."); 
      eigen_assert(rows()==B.rows()
                    && "SparseLU::solve(): invalid number of rows of the right hand side matrix B");
          return internal::sparse_solve_retval<SparseLU, Rhs>(*this, B.derived());
    }

---

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

• C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/SparseLU/SparseLU.h