Eigen::SluMatrix Struct Reference

#include <SuperLUSupport.h>

Inheritance diagram for Eigen::SluMatrix:

Public Member Functions
	SluMatrix ()
	SluMatrix (const SluMatrix &other)
SluMatrix &	operator= (const SluMatrix &other)
void	setStorageType (Stype_t t)
template<typename Scalar >
void	setScalarType ()

Static Public Member Functions
template<typename MatrixType >
static SluMatrix	Map (MatrixBase< MatrixType > &_mat)
template<typename MatrixType >
static SluMatrix	Map (SparseMatrixBase< MatrixType > &a_mat)

Public Attributes
struct {
union {
int   nnz
int   lda
}
void *   values
int *   innerInd
int *   outerInd
}	storage
Public Attributes inherited from SuperMatrix
Stype_t	Stype
Dtype_t	Dtype
Mtype_t	Mtype
int_t	nrow
int_t	ncol
void *	Store

Detailed Description

A wrapper class for SuperLU matrices. It supports only compressed sparse matrices and dense matrices. Supernodal and other fancy format are not supported by this wrapper.

This wrapper class mainly aims to avoids the need of dynamic allocation of the storage structure.

Constructor & Destructor Documentation

SluMatrix() [1/2]

Eigen::SluMatrix::SluMatrix ( )

inline

{ Store = &storage; }

References storage, and SuperMatrix::Store.

SluMatrix() [2/2]

Eigen::SluMatrix::SluMatrix ( const SluMatrix &  other )

inline

                                    : SuperMatrix(other) {
    Store = &storage;
    storage = other.storage;
  }

References storage, and SuperMatrix::Store.

Member Function Documentation

Map() [1/2]

template<typename MatrixType >

static SluMatrix Eigen::SluMatrix::Map ( MatrixBase< MatrixType > &  _mat )

inlinestatic

                                                     {
    MatrixType &mat(_mat.derived());
    eigen_assert(((MatrixType::Flags & RowMajorBit) != RowMajorBit) &&
                 "row-major dense matrices are not supported by SuperLU");
    SluMatrix res;
    res.setStorageType(SLU_DN);
    res.setScalarType<typename MatrixType::Scalar>();
    res.Mtype = SLU_GE;
 
    res.nrow = internal::convert_index<int>(mat.rows());
    res.ncol = internal::convert_index<int>(mat.cols());
 
    res.storage.lda = internal::convert_index<int>(MatrixType::IsVectorAtCompileTime ? mat.size() : mat.outerStride());
    res.storage.values = (void *)(mat.data());
    return res;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::data(), eigen_assert, res, Eigen::RowMajorBit, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), Eigen::SparseMatrixBase< Derived >::size(), SLU_DN, and SLU_GE.

Referenced by Eigen::SuperLU< MatrixType_ >::_solve_impl(), and Eigen::internal::asSluMatrix().

Map() [2/2]

template<typename MatrixType >

static SluMatrix Eigen::SluMatrix::Map ( SparseMatrixBase< MatrixType > &  a_mat )

inlinestatic

                                                            {
    MatrixType &mat(a_mat.derived());
    SluMatrix res;
    if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
      res.setStorageType(SLU_NR);
      res.nrow = internal::convert_index<int>(mat.cols());
      res.ncol = internal::convert_index<int>(mat.rows());
    } else {
      res.setStorageType(SLU_NC);
      res.nrow = internal::convert_index<int>(mat.rows());
      res.ncol = internal::convert_index<int>(mat.cols());
    }
 
    res.Mtype = SLU_GE;
 
    res.storage.nnz = internal::convert_index<int>(mat.nonZeros());
    res.storage.values = mat.valuePtr();
    res.storage.innerInd = mat.innerIndexPtr();
    res.storage.outerInd = mat.outerIndexPtr();
 
    res.setScalarType<typename MatrixType::Scalar>();
 
    // FIXME the following is not very accurate
    if (int(MatrixType::Flags) & int(Upper)) res.Mtype = SLU_TRU;
    if (int(MatrixType::Flags) & int(Lower)) res.Mtype = SLU_TRL;
 
    eigen_assert(((int(MatrixType::Flags) & int(SelfAdjoint)) == 0) &&
                 "SelfAdjoint matrix shape not supported by SuperLU");
 
    return res;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::SparseMatrixBase< Derived >::derived(), eigen_assert, if(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::innerIndexPtr(), int(), Eigen::Lower, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::nonZeros(), Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::outerIndexPtr(), res, Eigen::RowMajorBit, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), Eigen::SelfAdjoint, SLU_GE, SLU_NC, SLU_NR, SLU_TRL, SLU_TRU, Eigen::Upper, and Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::valuePtr().

operator=()

SluMatrix& Eigen::SluMatrix::operator= ( const SluMatrix &  other )

inline

                                               {
    SuperMatrix::operator=(static_cast<const SuperMatrix &>(other));
    Store = &storage;
    storage = other.storage;
    return *this;
  }

References storage, and SuperMatrix::Store.

setScalarType()

template<typename Scalar >

void Eigen::SluMatrix::setScalarType ( )

inline

                       {
    if (internal::is_same<Scalar, float>::value)
      Dtype = SLU_S;
    else if (internal::is_same<Scalar, double>::value)
      Dtype = SLU_D;
    else if (internal::is_same<Scalar, std::complex<float> >::value)
      Dtype = SLU_C;
    else if (internal::is_same<Scalar, std::complex<double> >::value)
      Dtype = SLU_Z;
    else {
      eigen_assert(false && "Scalar type not supported by SuperLU");
    }
  }

References SuperMatrix::Dtype, eigen_assert, SLU_C, SLU_D, SLU_S, SLU_Z, and Eigen::value.

Referenced by Eigen::SuperLUBase< MatrixType_, Derived >::initFactorization().

setStorageType()

void Eigen::SluMatrix::setStorageType ( Stype_t  t )

inline

                                 {
    Stype = t;
    if (t == SLU_NC || t == SLU_NR || t == SLU_DN)
      Store = &storage;
    else {
      eigen_assert(false && "storage type not supported");
      Store = 0;
    }
  }

References eigen_assert, SLU_DN, SLU_NC, SLU_NR, storage, SuperMatrix::Store, SuperMatrix::Stype, and plotPSD::t.

Referenced by Eigen::SuperLUBase< MatrixType_, Derived >::initFactorization().

Member Data Documentation

innerInd

int* Eigen::SluMatrix::innerInd

Referenced by Eigen::internal::map_superlu().

lda

int Eigen::SluMatrix::lda

Referenced by Eigen::SuperLUBase< MatrixType_, Derived >::initFactorization().

nnz

int Eigen::SluMatrix::nnz

outerInd

int* Eigen::SluMatrix::outerInd

Referenced by Eigen::internal::map_superlu().

struct { ... } Eigen::SluMatrix::storage

Referenced by Eigen::SuperLUBase< MatrixType_, Derived >::initFactorization(), Eigen::internal::map_superlu(), operator=(), setStorageType(), and SluMatrix().

values

void* Eigen::SluMatrix::values

Referenced by Eigen::SuperLUBase< MatrixType_, Derived >::initFactorization(), and Eigen::internal::map_superlu().

---

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

• SuperLUSupport.h