a class to manipulate the L supernodal factor from the SparseLU factorization More...

#include <SparseLU_SupernodalMatrix.h>

Classes
class	InnerIterator
	InnerIterator class to iterate over nonzero values of the current column in the supernodal matrix L. More...

Public Types
typedef Scalar_	Scalar

typedef StorageIndex_	StorageIndex

typedef Matrix< StorageIndex, Dynamic, 1 >	IndexVector

typedef Matrix< Scalar, Dynamic, 1 >	ScalarVector

Public Member Functions
	MappedSuperNodalMatrix ()

	MappedSuperNodalMatrix (Index m, Index n, ScalarVector &nzval, IndexVector &nzval_colptr, IndexVector &rowind, IndexVector &rowind_colptr, IndexVector &col_to_sup, IndexVector &sup_to_col)

	~MappedSuperNodalMatrix ()

void	setInfos (Index m, Index n, ScalarVector &nzval, IndexVector &nzval_colptr, IndexVector &rowind, IndexVector &rowind_colptr, IndexVector &col_to_sup, IndexVector &sup_to_col)

Index	rows () const

Index	cols () const

Scalar *	valuePtr ()

const Scalar *	valuePtr () const

StorageIndex *	colIndexPtr ()

const StorageIndex *	colIndexPtr () const

StorageIndex *	rowIndex ()

const StorageIndex *	rowIndex () const

StorageIndex *	rowIndexPtr ()

const StorageIndex *	rowIndexPtr () const

StorageIndex *	colToSup ()

const StorageIndex *	colToSup () const

StorageIndex *	supToCol ()

const StorageIndex *	supToCol () const

Index	nsuper () const

template<typename Dest >
void	solveInPlace (MatrixBase< Dest > &X) const
	Solve with the supernode triangular matrix. More...

template<bool Conjugate, typename Dest >
void	solveTransposedInPlace (MatrixBase< Dest > &X) const

Protected Attributes
Index	m_row

Index	m_col

Index	m_nsuper

Scalar *	m_nzval

StorageIndex *	m_nzval_colptr

StorageIndex *	m_rowind

StorageIndex *	m_rowind_colptr

StorageIndex *	m_col_to_sup

StorageIndex *	m_sup_to_col

Detailed Description

template<typename Scalar_, typename StorageIndex_>
class Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >

a class to manipulate the L supernodal factor from the SparseLU factorization

This class contain the data to easily store and manipulate the supernodes during the factorization and solution phase of Sparse LU. Only the lower triangular matrix has supernodes.

NOTE : This class corresponds to the SCformat structure in SuperLU

Member Typedef Documentation

◆ IndexVector

template<typename Scalar_ , typename StorageIndex_ >

typedef Matrix<StorageIndex, Dynamic, 1> Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::IndexVector

◆ Scalar

template<typename Scalar_ , typename StorageIndex_ >

typedef Scalar_ Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::Scalar

◆ ScalarVector

template<typename Scalar_ , typename StorageIndex_ >

typedef Matrix<Scalar, Dynamic, 1> Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::ScalarVector

◆ StorageIndex

template<typename Scalar_ , typename StorageIndex_ >

typedef StorageIndex_ Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::StorageIndex

Constructor & Destructor Documentation

◆ MappedSuperNodalMatrix() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::MappedSuperNodalMatrix ( )

inline

44 {}

◆ MappedSuperNodalMatrix() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::MappedSuperNodalMatrix	(	Index	m,
		Index	n,
		ScalarVector &	nzval,
		IndexVector &	nzval_colptr,
		IndexVector &	rowind,
		IndexVector &	rowind_colptr,
		IndexVector &	col_to_sup,
		IndexVector &	sup_to_col
	)

inline

                                                                                                        {
     setInfos(m, n, nzval, nzval_colptr, rowind, rowind_colptr, col_to_sup, sup_to_col);
   }

References m, n, and Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::setInfos().

◆ ~MappedSuperNodalMatrix()

template<typename Scalar_ , typename StorageIndex_ >

Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::~MappedSuperNodalMatrix ( )

inline

50 {}

Member Function Documentation

◆ colIndexPtr() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::colIndexPtr ( )

inline

Return the pointers to the beginning of each column in valuePtr()

91 { return m_nzval_colptr; }

Eigen::internal::MappedSuperNodalMatrix::m_nzval_colptr

StorageIndex * m_nzval_colptr

Definition: SparseLU_SupernodalMatrix.h:138

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_nzval_colptr.

◆ colIndexPtr() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

const StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::colIndexPtr ( ) const

inline

93 { return m_nzval_colptr; }

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_nzval_colptr.

◆ cols()

template<typename Scalar_ , typename StorageIndex_ >

Index Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::cols ( ) const

inline

Number of columns

78 { return m_col; }

Eigen::internal::MappedSuperNodalMatrix::m_col

Index m_col

Definition: SparseLU_SupernodalMatrix.h:135

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_col.

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

◆ colToSup() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::colToSup ( )

inline

Return the array of column-to-supernode mapping

112 { return m_col_to_sup; }

Eigen::internal::MappedSuperNodalMatrix::m_col_to_sup

StorageIndex * m_col_to_sup

Definition: SparseLU_SupernodalMatrix.h:141

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_col_to_sup.

◆ colToSup() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

const StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::colToSup ( ) const

inline

114 { return m_col_to_sup; }

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_col_to_sup.

◆ nsuper()

template<typename Scalar_ , typename StorageIndex_ >

Index Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::nsuper ( ) const

inline

Return the number of supernodes

125 { return m_nsuper; }

Eigen::internal::MappedSuperNodalMatrix::m_nsuper

Index m_nsuper

Definition: SparseLU_SupernodalMatrix.h:136

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_nsuper.

◆ rowIndex() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::rowIndex ( )

inline

Return the array of compressed row indices of all supernodes

98 { return m_rowind; }

Eigen::internal::MappedSuperNodalMatrix::m_rowind

StorageIndex * m_rowind

Definition: SparseLU_SupernodalMatrix.h:139

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_rowind.

◆ rowIndex() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

const StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::rowIndex ( ) const

inline

100 { return m_rowind; }

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_rowind.

◆ rowIndexPtr() [1/2]

template<typename Scalar_ , typename StorageIndex_ >

StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::rowIndexPtr ( )

inline

Return the location in rowvaluePtr() which starts each column

105 { return m_rowind_colptr; }

Eigen::internal::MappedSuperNodalMatrix::m_rowind_colptr

StorageIndex * m_rowind_colptr

Definition: SparseLU_SupernodalMatrix.h:140

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_rowind_colptr.

◆ rowIndexPtr() [2/2]

template<typename Scalar_ , typename StorageIndex_ >

const StorageIndex* Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::rowIndexPtr ( ) const

inline

107 { return m_rowind_colptr; }

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_rowind_colptr.

◆ rows()

template<typename Scalar_ , typename StorageIndex_ >

Index Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::rows ( ) const

inline

Number of rows

73 { return m_row; }

Eigen::internal::MappedSuperNodalMatrix::m_row

Index m_row

Definition: SparseLU_SupernodalMatrix.h:134

References Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::m_row.

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

◆ setInfos()

template<typename Scalar_ , typename StorageIndex_ >

void Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::setInfos	(	Index	m,
		Index	n,
		ScalarVector &	nzval,
		IndexVector &	nzval_colptr,
		IndexVector &	rowind,
		IndexVector &	rowind_colptr,
		IndexVector &	col_to_sup,
		IndexVector &	sup_to_col
	)

inline

Set appropriate pointers for the lower triangular supernodal matrix These infos are available at the end of the numerical factorization FIXME This class will be modified such that it can be use in the course of the factorization.

                                                                                               {
     m_row = m;
     m_col = n;
     m_nzval = nzval.data();
     m_nzval_colptr = nzval_colptr.data();
     m_rowind = rowind.data();
     m_rowind_colptr = rowind_colptr.data();
     m_nsuper = col_to_sup(n);
     m_col_to_sup = col_to_sup.data();
     m_sup_to_col = sup_to_col.data();
   }

Referenced by Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::MappedSuperNodalMatrix().

◆ solveInPlace()

template<typename Scalar , typename Index_ >

template<typename Dest >

void Eigen::internal::MappedSuperNodalMatrix< Scalar, Index_ >::solveInPlace ( MatrixBase< Dest > & X ) const

Solve with the supernode triangular matrix.

                                                                                    {
   /* Explicit type conversion as the Index type of MatrixBase<Dest> may be wider than Index */
   //    eigen_assert(X.rows() <= NumTraits<Index>::highest());
   //    eigen_assert(X.cols() <= NumTraits<Index>::highest());
   Index n = int(X.rows());
   Index nrhs = Index(X.cols());
   const Scalar* Lval = valuePtr();                                           // Nonzero values
   Matrix<Scalar, Dynamic, Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);  // working vector
   work.setZero();
   for (Index k = 0; k <= nsuper(); k++) {
     Index fsupc = supToCol()[k];                      // First column of the current supernode
     Index istart = rowIndexPtr()[fsupc];              // Pointer index to the subscript of the current column
     Index nsupr = rowIndexPtr()[fsupc + 1] - istart;  // Number of rows in the current supernode
     Index nsupc = supToCol()[k + 1] - fsupc;          // Number of columns in the current supernode
     Index nrow = nsupr - nsupc;                       // Number of rows in the non-diagonal part of the supernode
     Index irow;                                       // Current index row
  
     if (nsupc == 1) {
       for (Index j = 0; j < nrhs; j++) {
         InnerIterator it(*this, fsupc);
         ++it;  // Skip the diagonal element
         for (; it; ++it) {
           irow = it.row();
           X(irow, j) -= X(fsupc, j) * it.value();
         }
       }
     } else {
       // The supernode has more than one column
       Index luptr = colIndexPtr()[fsupc];
       Index lda = colIndexPtr()[fsupc + 1] - luptr;
  
       // Triangular solve
       Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> > A(&(Lval[luptr]), nsupc, nsupc,
                                                                                  OuterStride<>(lda));
       typename Dest::RowsBlockXpr U = X.derived().middleRows(fsupc, nsupc);
       U = A.template triangularView<UnitLower>().solve(U);
       // Matrix-vector product
       new (&A) Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> >(&(Lval[luptr + nsupc]), nrow,
                                                                                         nsupc, OuterStride<>(lda));
       work.topRows(nrow).noalias() = A * U;
  
       // Begin Scatter
       for (Index j = 0; j < nrhs; j++) {
         Index iptr = istart + nsupc;
         for (Index i = 0; i < nrow; i++) {
           irow = rowIndex()[iptr];
           X(irow, j) -= work(i, j);  // Scatter operation
           work(i, j) = Scalar(0);
           iptr++;
         }
       }
     }
   }
 }

References i, int(), j, k, lda, n, Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::InnerIterator::row(), Eigen::PlainObjectBase< Derived >::setZero(), RachelsAdvectionDiffusion::U, Eigen::internal::MappedSuperNodalMatrix< Scalar_, StorageIndex_ >::InnerIterator::value(), and X.

◆ solveTransposedInPlace()

template<typename Scalar , typename Index_ >

template<bool Conjugate, typename Dest >

void Eigen::internal::MappedSuperNodalMatrix< Scalar, Index_ >::solveTransposedInPlace ( MatrixBase< Dest > & X ) const

                                                                                              {
   using numext::conj;
   Index n = int(X.rows());
   Index nrhs = Index(X.cols());
   const Scalar* Lval = valuePtr();                                           // Nonzero values
   Matrix<Scalar, Dynamic, Dest::ColsAtCompileTime, ColMajor> work(n, nrhs);  // working vector
   work.setZero();
   for (Index k = nsuper(); k >= 0; k--) {
     Index fsupc = supToCol()[k];                      // First column of the current supernode
     Index istart = rowIndexPtr()[fsupc];              // Pointer index to the subscript of the current column
     Index nsupr = rowIndexPtr()[fsupc + 1] - istart;  // Number of rows in the current supernode
     Index nsupc = supToCol()[k + 1] - fsupc;          // Number of columns in the current supernode
     Index nrow = nsupr - nsupc;                       // Number of rows in the non-diagonal part of the supernode
     Index irow;                                       // Current index row
  
     if (nsupc == 1) {
       for (Index j = 0; j < nrhs; j++) {
         InnerIterator it(*this, fsupc);
         ++it;  // Skip the diagonal element
         for (; it; ++it) {
           irow = it.row();
           X(fsupc, j) -= X(irow, j) * (Conjugate ? conj(it.value()) : it.value());
         }
       }
     } else {
       // The supernode has more than one column
       Index luptr = colIndexPtr()[fsupc];
       Index lda = colIndexPtr()[fsupc + 1] - luptr;
  
       // Begin Gather
       for (Index j = 0; j < nrhs; j++) {
         Index iptr = istart + nsupc;
         for (Index i = 0; i < nrow; i++) {
           irow = rowIndex()[iptr];
           work.topRows(nrow)(i, j) = X(irow, j);  // Gather operation
           iptr++;
         }
       }
  
       // Matrix-vector product with transposed submatrix
       Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> > A(&(Lval[luptr + nsupc]), nrow, nsupc,
                                                                                  OuterStride<>(lda));
       typename Dest::RowsBlockXpr U = X.derived().middleRows(fsupc, nsupc);
       if (Conjugate)
         U = U - A.adjoint() * work.topRows(nrow);
       else
         U = U - A.transpose() * work.topRows(nrow);
  
       // Triangular solve (of transposed diagonal block)
       new (&A) Map<const Matrix<Scalar, Dynamic, Dynamic, ColMajor>, 0, OuterStride<> >(&(Lval[luptr]), nsupc, nsupc,
                                                                                         OuterStride<>(lda));
       if (Conjugate)
         U = A.adjoint().template triangularView<UnitUpper>().solve(U);
       else
         U = A.transpose().template triangularView<UnitUpper>().solve(U);
     }
   }
 }