Eigen::SluMatrix Struct Reference

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

Inheritance diagram for Eigen::SluMatrix:

Collaboration 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

Detailed Description

Constructor & Destructor Documentation

SluMatrix() [1/2]

Eigen::SluMatrix::SluMatrix ( )

inline

  {
    Store = &storage;
  }

References storage.

SluMatrix() [2/2]

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

inline

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

References storage.

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_assert, Eigen::RowMajorBit, setScalarType(), setStorageType(), and storage.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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 (MatrixType::Flags & Upper)
      res.Mtype = SLU_TRU;
    if (MatrixType::Flags & Lower)
      res.Mtype = SLU_TRL;
 
    eigen_assert(((MatrixType::Flags & SelfAdjoint)==0) && "SelfAdjoint matrix shape not supported by SuperLU");
 
    return res;
  }

References Eigen::SparseMatrixBase< Derived >::derived(), eigen_assert, Eigen::Lower, Eigen::RowMajorBit, Eigen::SelfAdjoint, setScalarType(), setStorageType(), storage, and Eigen::Upper.

Here is the call graph for this function:

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.

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 eigen_assert.

Referenced by Eigen::SuperLUBase< _MatrixType, Derived >::initFactorization(), Map(), Map(), Eigen::SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >::run(), and Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run().

Here is the caller graph for this function:

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, and storage.

Referenced by Eigen::SuperLUBase< _MatrixType, Derived >::initFactorization(), Map(), Map(), Eigen::SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >::run(), and Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run().

Here is the caller graph for this function:

Member Data Documentation

[struct]

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

Referenced by SluMatrix(), SluMatrix(), Eigen::SuperLUBase< _MatrixType, Derived >::initFactorization(), Map(), Map(), Eigen::internal::map_superlu(), operator=(), Eigen::SluMatrixMapHelper< Matrix< Scalar, Rows, Cols, Options, MRows, MCols > >::run(), Eigen::SluMatrixMapHelper< SparseMatrixBase< Derived > >::run(), and setStorageType().

---

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

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