Initial Commit
This commit is contained in:
commit
6088fc29ed
978 changed files with 353647 additions and 0 deletions
3
include/Eigen/src/SuperLUSupport/InternalHeaderCheck.h
Normal file
3
include/Eigen/src/SuperLUSupport/InternalHeaderCheck.h
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
#ifndef EIGEN_SUPERLUSUPPORT_MODULE_H
|
||||
#error "Please include Eigen/SuperLUSupport instead of including headers inside the src directory directly."
|
||||
#endif
|
||||
908
include/Eigen/src/SuperLUSupport/SuperLUSupport.h
Normal file
908
include/Eigen/src/SuperLUSupport/SuperLUSupport.h
Normal file
|
|
@ -0,0 +1,908 @@
|
|||
// This file is part of Eigen, a lightweight C++ template library
|
||||
// for linear algebra.
|
||||
//
|
||||
// Copyright (C) 2008-2015 Gael Guennebaud <gael.guennebaud@inria.fr>
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the Mozilla
|
||||
// Public License v. 2.0. If a copy of the MPL was not distributed
|
||||
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
|
||||
#ifndef EIGEN_SUPERLUSUPPORT_H
|
||||
#define EIGEN_SUPERLUSUPPORT_H
|
||||
|
||||
// IWYU pragma: private
|
||||
#include "./InternalHeaderCheck.h"
|
||||
|
||||
namespace Eigen {
|
||||
|
||||
#if defined(SUPERLU_MAJOR_VERSION) && (SUPERLU_MAJOR_VERSION >= 5)
|
||||
#define DECL_GSSVX(PREFIX, FLOATTYPE, KEYTYPE) \
|
||||
extern "C" { \
|
||||
extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *, char *, FLOATTYPE *, FLOATTYPE *, \
|
||||
SuperMatrix *, SuperMatrix *, void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, \
|
||||
FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, GlobalLU_t *, mem_usage_t *, SuperLUStat_t *, \
|
||||
int *); \
|
||||
} \
|
||||
inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A, int *perm_c, int *perm_r, int *etree, \
|
||||
char *equed, FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L, SuperMatrix *U, void *work, \
|
||||
int lwork, SuperMatrix *B, SuperMatrix *X, FLOATTYPE *recip_pivot_growth, \
|
||||
FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr, SuperLUStat_t *stats, int *info, \
|
||||
KEYTYPE) { \
|
||||
mem_usage_t mem_usage; \
|
||||
GlobalLU_t gLU; \
|
||||
PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work, lwork, B, X, recip_pivot_growth, rcond, \
|
||||
ferr, berr, &gLU, &mem_usage, stats, info); \
|
||||
return mem_usage.for_lu; /* bytes used by the factor storage */ \
|
||||
}
|
||||
#else // version < 5.0
|
||||
#define DECL_GSSVX(PREFIX, FLOATTYPE, KEYTYPE) \
|
||||
extern "C" { \
|
||||
extern void PREFIX##gssvx(superlu_options_t *, SuperMatrix *, int *, int *, int *, char *, FLOATTYPE *, FLOATTYPE *, \
|
||||
SuperMatrix *, SuperMatrix *, void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, \
|
||||
FLOATTYPE *, FLOATTYPE *, FLOATTYPE *, mem_usage_t *, SuperLUStat_t *, int *); \
|
||||
} \
|
||||
inline float SuperLU_gssvx(superlu_options_t *options, SuperMatrix *A, int *perm_c, int *perm_r, int *etree, \
|
||||
char *equed, FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L, SuperMatrix *U, void *work, \
|
||||
int lwork, SuperMatrix *B, SuperMatrix *X, FLOATTYPE *recip_pivot_growth, \
|
||||
FLOATTYPE *rcond, FLOATTYPE *ferr, FLOATTYPE *berr, SuperLUStat_t *stats, int *info, \
|
||||
KEYTYPE) { \
|
||||
mem_usage_t mem_usage; \
|
||||
PREFIX##gssvx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work, lwork, B, X, recip_pivot_growth, rcond, \
|
||||
ferr, berr, &mem_usage, stats, info); \
|
||||
return mem_usage.for_lu; /* bytes used by the factor storage */ \
|
||||
}
|
||||
#endif
|
||||
|
||||
DECL_GSSVX(s, float, float)
|
||||
DECL_GSSVX(c, float, std::complex<float>)
|
||||
DECL_GSSVX(d, double, double)
|
||||
DECL_GSSVX(z, double, std::complex<double>)
|
||||
|
||||
#ifdef MILU_ALPHA
|
||||
#define EIGEN_SUPERLU_HAS_ILU
|
||||
#endif
|
||||
|
||||
#ifdef EIGEN_SUPERLU_HAS_ILU
|
||||
|
||||
// similarly for the incomplete factorization using gsisx
|
||||
#define DECL_GSISX(PREFIX, FLOATTYPE, KEYTYPE) \
|
||||
extern "C" { \
|
||||
extern void PREFIX##gsisx(superlu_options_t *, SuperMatrix *, int *, int *, int *, char *, FLOATTYPE *, FLOATTYPE *, \
|
||||
SuperMatrix *, SuperMatrix *, void *, int, SuperMatrix *, SuperMatrix *, FLOATTYPE *, \
|
||||
FLOATTYPE *, mem_usage_t *, SuperLUStat_t *, int *); \
|
||||
} \
|
||||
inline float SuperLU_gsisx(superlu_options_t *options, SuperMatrix *A, int *perm_c, int *perm_r, int *etree, \
|
||||
char *equed, FLOATTYPE *R, FLOATTYPE *C, SuperMatrix *L, SuperMatrix *U, void *work, \
|
||||
int lwork, SuperMatrix *B, SuperMatrix *X, FLOATTYPE *recip_pivot_growth, \
|
||||
FLOATTYPE *rcond, SuperLUStat_t *stats, int *info, KEYTYPE) { \
|
||||
mem_usage_t mem_usage; \
|
||||
PREFIX##gsisx(options, A, perm_c, perm_r, etree, equed, R, C, L, U, work, lwork, B, X, recip_pivot_growth, rcond, \
|
||||
&mem_usage, stats, info); \
|
||||
return mem_usage.for_lu; /* bytes used by the factor storage */ \
|
||||
}
|
||||
|
||||
DECL_GSISX(s, float, float)
|
||||
DECL_GSISX(c, float, std::complex<float>)
|
||||
DECL_GSISX(d, double, double)
|
||||
DECL_GSISX(z, double, std::complex<double>)
|
||||
|
||||
#endif
|
||||
|
||||
template <typename MatrixType>
|
||||
struct SluMatrixMapHelper;
|
||||
|
||||
/** \internal
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
struct SluMatrix : SuperMatrix {
|
||||
SluMatrix() { Store = &storage; }
|
||||
|
||||
SluMatrix(const SluMatrix &other) : SuperMatrix(other) {
|
||||
Store = &storage;
|
||||
storage = other.storage;
|
||||
}
|
||||
|
||||
SluMatrix &operator=(const SluMatrix &other) {
|
||||
SuperMatrix::operator=(static_cast<const SuperMatrix &>(other));
|
||||
Store = &storage;
|
||||
storage = other.storage;
|
||||
return *this;
|
||||
}
|
||||
|
||||
struct {
|
||||
union {
|
||||
int nnz;
|
||||
int lda;
|
||||
};
|
||||
void *values;
|
||||
int *innerInd;
|
||||
int *outerInd;
|
||||
} storage;
|
||||
|
||||
void setStorageType(Stype_t t) {
|
||||
Stype = t;
|
||||
if (t == SLU_NC || t == SLU_NR || t == SLU_DN)
|
||||
Store = &storage;
|
||||
else {
|
||||
eigen_assert(false && "storage type not supported");
|
||||
Store = 0;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Scalar>
|
||||
void setScalarType() {
|
||||
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");
|
||||
}
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
static SluMatrix Map(MatrixBase<MatrixType> &_mat) {
|
||||
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;
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
static SluMatrix Map(SparseMatrixBase<MatrixType> &a_mat) {
|
||||
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;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Scalar, int Rows, int Cols, int Options, int MRows, int MCols>
|
||||
struct SluMatrixMapHelper<Matrix<Scalar, Rows, Cols, Options, MRows, MCols> > {
|
||||
typedef Matrix<Scalar, Rows, Cols, Options, MRows, MCols> MatrixType;
|
||||
static void run(MatrixType &mat, SluMatrix &res) {
|
||||
eigen_assert(((Options & RowMajor) != RowMajor) && "row-major dense matrices is not supported by SuperLU");
|
||||
res.setStorageType(SLU_DN);
|
||||
res.setScalarType<Scalar>();
|
||||
res.Mtype = SLU_GE;
|
||||
|
||||
res.nrow = mat.rows();
|
||||
res.ncol = mat.cols();
|
||||
|
||||
res.storage.lda = mat.outerStride();
|
||||
res.storage.values = mat.data();
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Derived>
|
||||
struct SluMatrixMapHelper<SparseMatrixBase<Derived> > {
|
||||
typedef Derived MatrixType;
|
||||
static void run(MatrixType &mat, SluMatrix &res) {
|
||||
if ((MatrixType::Flags & RowMajorBit) == RowMajorBit) {
|
||||
res.setStorageType(SLU_NR);
|
||||
res.nrow = mat.cols();
|
||||
res.ncol = mat.rows();
|
||||
} else {
|
||||
res.setStorageType(SLU_NC);
|
||||
res.nrow = mat.rows();
|
||||
res.ncol = mat.cols();
|
||||
}
|
||||
|
||||
res.Mtype = SLU_GE;
|
||||
|
||||
res.storage.nnz = 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");
|
||||
}
|
||||
};
|
||||
|
||||
namespace internal {
|
||||
|
||||
template <typename MatrixType>
|
||||
SluMatrix asSluMatrix(MatrixType &mat) {
|
||||
return SluMatrix::Map(mat);
|
||||
}
|
||||
|
||||
/** View a Super LU matrix as an Eigen expression */
|
||||
template <typename Scalar, int Flags, typename Index>
|
||||
Map<SparseMatrix<Scalar, Flags, Index> > map_superlu(SluMatrix &sluMat) {
|
||||
eigen_assert(((Flags & RowMajor) == RowMajor && sluMat.Stype == SLU_NR) ||
|
||||
((Flags & ColMajor) == ColMajor && sluMat.Stype == SLU_NC));
|
||||
|
||||
Index outerSize = (Flags & RowMajor) == RowMajor ? sluMat.ncol : sluMat.nrow;
|
||||
|
||||
return Map<SparseMatrix<Scalar, Flags, Index> >(sluMat.nrow, sluMat.ncol, sluMat.storage.outerInd[outerSize],
|
||||
sluMat.storage.outerInd, sluMat.storage.innerInd,
|
||||
reinterpret_cast<Scalar *>(sluMat.storage.values));
|
||||
}
|
||||
|
||||
} // end namespace internal
|
||||
|
||||
/** \ingroup SuperLUSupport_Module
|
||||
* \class SuperLUBase
|
||||
* \brief The base class for the direct and incomplete LU factorization of SuperLU
|
||||
*/
|
||||
template <typename MatrixType_, typename Derived>
|
||||
class SuperLUBase : public SparseSolverBase<Derived> {
|
||||
protected:
|
||||
typedef SparseSolverBase<Derived> Base;
|
||||
using Base::derived;
|
||||
using Base::m_isInitialized;
|
||||
|
||||
public:
|
||||
typedef MatrixType_ MatrixType;
|
||||
typedef typename MatrixType::Scalar Scalar;
|
||||
typedef typename MatrixType::RealScalar RealScalar;
|
||||
typedef typename MatrixType::StorageIndex StorageIndex;
|
||||
typedef Matrix<Scalar, Dynamic, 1> Vector;
|
||||
typedef Matrix<int, 1, MatrixType::ColsAtCompileTime> IntRowVectorType;
|
||||
typedef Matrix<int, MatrixType::RowsAtCompileTime, 1> IntColVectorType;
|
||||
typedef Map<PermutationMatrix<Dynamic, Dynamic, int> > PermutationMap;
|
||||
typedef SparseMatrix<Scalar> LUMatrixType;
|
||||
enum { ColsAtCompileTime = MatrixType::ColsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime };
|
||||
|
||||
public:
|
||||
SuperLUBase() {}
|
||||
|
||||
~SuperLUBase() { clearFactors(); }
|
||||
|
||||
inline Index rows() const { return m_matrix.rows(); }
|
||||
inline Index cols() const { return m_matrix.cols(); }
|
||||
|
||||
/** \returns a reference to the Super LU option object to configure the Super LU algorithms. */
|
||||
inline superlu_options_t &options() { return m_sluOptions; }
|
||||
|
||||
/** \brief Reports whether previous computation was successful.
|
||||
*
|
||||
* \returns \c Success if computation was successful,
|
||||
* \c NumericalIssue if the matrix.appears to be negative.
|
||||
*/
|
||||
ComputationInfo info() const {
|
||||
eigen_assert(m_isInitialized && "Decomposition is not initialized.");
|
||||
return m_info;
|
||||
}
|
||||
|
||||
/** Computes the sparse Cholesky decomposition of \a matrix */
|
||||
void compute(const MatrixType &matrix) {
|
||||
derived().analyzePattern(matrix);
|
||||
derived().factorize(matrix);
|
||||
}
|
||||
|
||||
/** Performs a symbolic decomposition on the sparcity of \a matrix.
|
||||
*
|
||||
* This function is particularly useful when solving for several problems having the same structure.
|
||||
*
|
||||
* \sa factorize()
|
||||
*/
|
||||
void analyzePattern(const MatrixType & /*matrix*/) {
|
||||
m_isInitialized = true;
|
||||
m_info = Success;
|
||||
m_analysisIsOk = true;
|
||||
m_factorizationIsOk = false;
|
||||
}
|
||||
|
||||
template <typename Stream>
|
||||
void dumpMemory(Stream & /*s*/) {}
|
||||
|
||||
protected:
|
||||
void initFactorization(const MatrixType &a) {
|
||||
set_default_options(&this->m_sluOptions);
|
||||
|
||||
const Index size = a.rows();
|
||||
m_matrix = a;
|
||||
|
||||
m_sluA = internal::asSluMatrix(m_matrix);
|
||||
clearFactors();
|
||||
|
||||
m_p.resize(size);
|
||||
m_q.resize(size);
|
||||
m_sluRscale.resize(size);
|
||||
m_sluCscale.resize(size);
|
||||
m_sluEtree.resize(size);
|
||||
|
||||
// set empty B and X
|
||||
m_sluB.setStorageType(SLU_DN);
|
||||
m_sluB.setScalarType<Scalar>();
|
||||
m_sluB.Mtype = SLU_GE;
|
||||
m_sluB.storage.values = 0;
|
||||
m_sluB.nrow = 0;
|
||||
m_sluB.ncol = 0;
|
||||
m_sluB.storage.lda = internal::convert_index<int>(size);
|
||||
m_sluX = m_sluB;
|
||||
|
||||
m_extractedDataAreDirty = true;
|
||||
}
|
||||
|
||||
void init() {
|
||||
m_info = InvalidInput;
|
||||
m_isInitialized = false;
|
||||
m_sluL.Store = 0;
|
||||
m_sluU.Store = 0;
|
||||
}
|
||||
|
||||
void extractData() const;
|
||||
|
||||
void clearFactors() {
|
||||
if (m_sluL.Store) Destroy_SuperNode_Matrix(&m_sluL);
|
||||
if (m_sluU.Store) Destroy_CompCol_Matrix(&m_sluU);
|
||||
|
||||
m_sluL.Store = 0;
|
||||
m_sluU.Store = 0;
|
||||
|
||||
memset(&m_sluL, 0, sizeof m_sluL);
|
||||
memset(&m_sluU, 0, sizeof m_sluU);
|
||||
}
|
||||
|
||||
// cached data to reduce reallocation, etc.
|
||||
mutable LUMatrixType m_l;
|
||||
mutable LUMatrixType m_u;
|
||||
mutable IntColVectorType m_p;
|
||||
mutable IntRowVectorType m_q;
|
||||
|
||||
mutable LUMatrixType m_matrix; // copy of the factorized matrix
|
||||
mutable SluMatrix m_sluA;
|
||||
mutable SuperMatrix m_sluL, m_sluU;
|
||||
mutable SluMatrix m_sluB, m_sluX;
|
||||
mutable SuperLUStat_t m_sluStat;
|
||||
mutable superlu_options_t m_sluOptions;
|
||||
mutable std::vector<int> m_sluEtree;
|
||||
mutable Matrix<RealScalar, Dynamic, 1> m_sluRscale, m_sluCscale;
|
||||
mutable Matrix<RealScalar, Dynamic, 1> m_sluFerr, m_sluBerr;
|
||||
mutable char m_sluEqued;
|
||||
|
||||
mutable ComputationInfo m_info;
|
||||
int m_factorizationIsOk;
|
||||
int m_analysisIsOk;
|
||||
mutable bool m_extractedDataAreDirty;
|
||||
|
||||
private:
|
||||
SuperLUBase(SuperLUBase &) {}
|
||||
};
|
||||
|
||||
/** \ingroup SuperLUSupport_Module
|
||||
* \class SuperLU
|
||||
* \brief A sparse direct LU factorization and solver based on the SuperLU library
|
||||
*
|
||||
* This class allows to solve for A.X = B sparse linear problems via a direct LU factorization
|
||||
* using the SuperLU library. The sparse matrix A must be squared and invertible. The vectors or matrices
|
||||
* X and B can be either dense or sparse.
|
||||
*
|
||||
* \tparam MatrixType_ the type of the sparse matrix A, it must be a SparseMatrix<>
|
||||
*
|
||||
* \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
|
||||
*
|
||||
* \implsparsesolverconcept
|
||||
*
|
||||
* \sa \ref TutorialSparseSolverConcept, class SparseLU
|
||||
*/
|
||||
template <typename MatrixType_>
|
||||
class SuperLU : public SuperLUBase<MatrixType_, SuperLU<MatrixType_> > {
|
||||
public:
|
||||
typedef SuperLUBase<MatrixType_, SuperLU> Base;
|
||||
typedef MatrixType_ MatrixType;
|
||||
typedef typename Base::Scalar Scalar;
|
||||
typedef typename Base::RealScalar RealScalar;
|
||||
typedef typename Base::StorageIndex StorageIndex;
|
||||
typedef typename Base::IntRowVectorType IntRowVectorType;
|
||||
typedef typename Base::IntColVectorType IntColVectorType;
|
||||
typedef typename Base::PermutationMap PermutationMap;
|
||||
typedef typename Base::LUMatrixType LUMatrixType;
|
||||
typedef TriangularView<LUMatrixType, Lower | UnitDiag> LMatrixType;
|
||||
typedef TriangularView<LUMatrixType, Upper> UMatrixType;
|
||||
|
||||
public:
|
||||
using Base::_solve_impl;
|
||||
|
||||
SuperLU() : Base() { init(); }
|
||||
|
||||
explicit SuperLU(const MatrixType &matrix) : Base() {
|
||||
init();
|
||||
Base::compute(matrix);
|
||||
}
|
||||
|
||||
~SuperLU() {}
|
||||
|
||||
/** Performs a symbolic decomposition on the sparcity of \a matrix.
|
||||
*
|
||||
* This function is particularly useful when solving for several problems having the same structure.
|
||||
*
|
||||
* \sa factorize()
|
||||
*/
|
||||
void analyzePattern(const MatrixType &matrix) {
|
||||
m_info = InvalidInput;
|
||||
m_isInitialized = false;
|
||||
Base::analyzePattern(matrix);
|
||||
}
|
||||
|
||||
/** Performs a numeric decomposition of \a matrix
|
||||
*
|
||||
* The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
|
||||
*
|
||||
* \sa analyzePattern()
|
||||
*/
|
||||
void factorize(const MatrixType &matrix);
|
||||
|
||||
/** \internal */
|
||||
template <typename Rhs, typename Dest>
|
||||
void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
|
||||
|
||||
inline const LMatrixType &matrixL() const {
|
||||
if (m_extractedDataAreDirty) this->extractData();
|
||||
return m_l;
|
||||
}
|
||||
|
||||
inline const UMatrixType &matrixU() const {
|
||||
if (m_extractedDataAreDirty) this->extractData();
|
||||
return m_u;
|
||||
}
|
||||
|
||||
inline const IntColVectorType &permutationP() const {
|
||||
if (m_extractedDataAreDirty) this->extractData();
|
||||
return m_p;
|
||||
}
|
||||
|
||||
inline const IntRowVectorType &permutationQ() const {
|
||||
if (m_extractedDataAreDirty) this->extractData();
|
||||
return m_q;
|
||||
}
|
||||
|
||||
Scalar determinant() const;
|
||||
|
||||
protected:
|
||||
using Base::m_l;
|
||||
using Base::m_matrix;
|
||||
using Base::m_p;
|
||||
using Base::m_q;
|
||||
using Base::m_sluA;
|
||||
using Base::m_sluB;
|
||||
using Base::m_sluBerr;
|
||||
using Base::m_sluCscale;
|
||||
using Base::m_sluEqued;
|
||||
using Base::m_sluEtree;
|
||||
using Base::m_sluFerr;
|
||||
using Base::m_sluL;
|
||||
using Base::m_sluOptions;
|
||||
using Base::m_sluRscale;
|
||||
using Base::m_sluStat;
|
||||
using Base::m_sluU;
|
||||
using Base::m_sluX;
|
||||
using Base::m_u;
|
||||
|
||||
using Base::m_analysisIsOk;
|
||||
using Base::m_extractedDataAreDirty;
|
||||
using Base::m_factorizationIsOk;
|
||||
using Base::m_info;
|
||||
using Base::m_isInitialized;
|
||||
|
||||
void init() {
|
||||
Base::init();
|
||||
|
||||
set_default_options(&this->m_sluOptions);
|
||||
m_sluOptions.PrintStat = NO;
|
||||
m_sluOptions.ConditionNumber = NO;
|
||||
m_sluOptions.Trans = NOTRANS;
|
||||
m_sluOptions.ColPerm = COLAMD;
|
||||
}
|
||||
|
||||
private:
|
||||
SuperLU(SuperLU &) {}
|
||||
};
|
||||
|
||||
template <typename MatrixType>
|
||||
void SuperLU<MatrixType>::factorize(const MatrixType &a) {
|
||||
eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
|
||||
if (!m_analysisIsOk) {
|
||||
m_info = InvalidInput;
|
||||
return;
|
||||
}
|
||||
|
||||
this->initFactorization(a);
|
||||
|
||||
m_sluOptions.ColPerm = COLAMD;
|
||||
int info = 0;
|
||||
RealScalar recip_pivot_growth, rcond;
|
||||
RealScalar ferr, berr;
|
||||
|
||||
StatInit(&m_sluStat);
|
||||
SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
|
||||
&m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &ferr, &berr,
|
||||
&m_sluStat, &info, Scalar());
|
||||
StatFree(&m_sluStat);
|
||||
|
||||
m_extractedDataAreDirty = true;
|
||||
|
||||
// FIXME how to better check for errors ???
|
||||
m_info = info == 0 ? Success : NumericalIssue;
|
||||
m_factorizationIsOk = true;
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
template <typename Rhs, typename Dest>
|
||||
void SuperLU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const {
|
||||
eigen_assert(m_factorizationIsOk &&
|
||||
"The decomposition is not in a valid state for solving, you must first call either compute() or "
|
||||
"analyzePattern()/factorize()");
|
||||
|
||||
const Index rhsCols = b.cols();
|
||||
eigen_assert(m_matrix.rows() == b.rows());
|
||||
|
||||
m_sluOptions.Trans = NOTRANS;
|
||||
m_sluOptions.Fact = FACTORED;
|
||||
m_sluOptions.IterRefine = NOREFINE;
|
||||
|
||||
m_sluFerr.resize(rhsCols);
|
||||
m_sluBerr.resize(rhsCols);
|
||||
|
||||
Ref<const Matrix<typename Rhs::Scalar, Dynamic, Dynamic, ColMajor> > b_ref(b);
|
||||
Ref<const Matrix<typename Dest::Scalar, Dynamic, Dynamic, ColMajor> > x_ref(x);
|
||||
|
||||
m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
|
||||
m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
|
||||
|
||||
typename Rhs::PlainObject b_cpy;
|
||||
if (m_sluEqued != 'N') {
|
||||
b_cpy = b;
|
||||
m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());
|
||||
}
|
||||
|
||||
StatInit(&m_sluStat);
|
||||
int info = 0;
|
||||
RealScalar recip_pivot_growth, rcond;
|
||||
SuperLU_gssvx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
|
||||
&m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond,
|
||||
&m_sluFerr[0], &m_sluBerr[0], &m_sluStat, &info, Scalar());
|
||||
StatFree(&m_sluStat);
|
||||
|
||||
if (x.derived().data() != x_ref.data()) x = x_ref;
|
||||
|
||||
m_info = info == 0 ? Success : NumericalIssue;
|
||||
}
|
||||
|
||||
// the code of this extractData() function has been adapted from the SuperLU's Matlab support code,
|
||||
//
|
||||
// Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
||||
//
|
||||
// THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY
|
||||
// EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
//
|
||||
template <typename MatrixType, typename Derived>
|
||||
void SuperLUBase<MatrixType, Derived>::extractData() const {
|
||||
eigen_assert(m_factorizationIsOk &&
|
||||
"The decomposition is not in a valid state for extracting factors, you must first call either compute() "
|
||||
"or analyzePattern()/factorize()");
|
||||
if (m_extractedDataAreDirty) {
|
||||
int upper;
|
||||
int fsupc, istart, nsupr;
|
||||
int lastl = 0, lastu = 0;
|
||||
SCformat *Lstore = static_cast<SCformat *>(m_sluL.Store);
|
||||
NCformat *Ustore = static_cast<NCformat *>(m_sluU.Store);
|
||||
Scalar *SNptr;
|
||||
|
||||
const Index size = m_matrix.rows();
|
||||
m_l.resize(size, size);
|
||||
m_l.resizeNonZeros(Lstore->nnz);
|
||||
m_u.resize(size, size);
|
||||
m_u.resizeNonZeros(Ustore->nnz);
|
||||
|
||||
int *Lcol = m_l.outerIndexPtr();
|
||||
int *Lrow = m_l.innerIndexPtr();
|
||||
Scalar *Lval = m_l.valuePtr();
|
||||
|
||||
int *Ucol = m_u.outerIndexPtr();
|
||||
int *Urow = m_u.innerIndexPtr();
|
||||
Scalar *Uval = m_u.valuePtr();
|
||||
|
||||
Ucol[0] = 0;
|
||||
Ucol[0] = 0;
|
||||
|
||||
/* for each supernode */
|
||||
for (int k = 0; k <= Lstore->nsuper; ++k) {
|
||||
fsupc = L_FST_SUPC(k);
|
||||
istart = L_SUB_START(fsupc);
|
||||
nsupr = L_SUB_START(fsupc + 1) - istart;
|
||||
upper = 1;
|
||||
|
||||
/* for each column in the supernode */
|
||||
for (int j = fsupc; j < L_FST_SUPC(k + 1); ++j) {
|
||||
SNptr = &((Scalar *)Lstore->nzval)[L_NZ_START(j)];
|
||||
|
||||
/* Extract U */
|
||||
for (int i = U_NZ_START(j); i < U_NZ_START(j + 1); ++i) {
|
||||
Uval[lastu] = ((Scalar *)Ustore->nzval)[i];
|
||||
/* Matlab doesn't like explicit zero. */
|
||||
if (Uval[lastu] != 0.0) Urow[lastu++] = U_SUB(i);
|
||||
}
|
||||
for (int i = 0; i < upper; ++i) {
|
||||
/* upper triangle in the supernode */
|
||||
Uval[lastu] = SNptr[i];
|
||||
/* Matlab doesn't like explicit zero. */
|
||||
if (Uval[lastu] != 0.0) Urow[lastu++] = L_SUB(istart + i);
|
||||
}
|
||||
Ucol[j + 1] = lastu;
|
||||
|
||||
/* Extract L */
|
||||
Lval[lastl] = 1.0; /* unit diagonal */
|
||||
Lrow[lastl++] = L_SUB(istart + upper - 1);
|
||||
for (int i = upper; i < nsupr; ++i) {
|
||||
Lval[lastl] = SNptr[i];
|
||||
/* Matlab doesn't like explicit zero. */
|
||||
if (Lval[lastl] != 0.0) Lrow[lastl++] = L_SUB(istart + i);
|
||||
}
|
||||
Lcol[j + 1] = lastl;
|
||||
|
||||
++upper;
|
||||
} /* for j ... */
|
||||
|
||||
} /* for k ... */
|
||||
|
||||
// squeeze the matrices :
|
||||
m_l.resizeNonZeros(lastl);
|
||||
m_u.resizeNonZeros(lastu);
|
||||
|
||||
m_extractedDataAreDirty = false;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename MatrixType>
|
||||
typename SuperLU<MatrixType>::Scalar SuperLU<MatrixType>::determinant() const {
|
||||
eigen_assert(m_factorizationIsOk &&
|
||||
"The decomposition is not in a valid state for computing the determinant, you must first call either "
|
||||
"compute() or analyzePattern()/factorize()");
|
||||
|
||||
if (m_extractedDataAreDirty) this->extractData();
|
||||
|
||||
Scalar det = Scalar(1);
|
||||
for (int j = 0; j < m_u.cols(); ++j) {
|
||||
if (m_u.outerIndexPtr()[j + 1] - m_u.outerIndexPtr()[j] > 0) {
|
||||
int lastId = m_u.outerIndexPtr()[j + 1] - 1;
|
||||
eigen_assert(m_u.innerIndexPtr()[lastId] <= j);
|
||||
if (m_u.innerIndexPtr()[lastId] == j) det *= m_u.valuePtr()[lastId];
|
||||
}
|
||||
}
|
||||
if (PermutationMap(m_p.data(), m_p.size()).determinant() * PermutationMap(m_q.data(), m_q.size()).determinant() < 0)
|
||||
det = -det;
|
||||
if (m_sluEqued != 'N')
|
||||
return det / m_sluRscale.prod() / m_sluCscale.prod();
|
||||
else
|
||||
return det;
|
||||
}
|
||||
|
||||
#ifdef EIGEN_PARSED_BY_DOXYGEN
|
||||
#define EIGEN_SUPERLU_HAS_ILU
|
||||
#endif
|
||||
|
||||
#ifdef EIGEN_SUPERLU_HAS_ILU
|
||||
|
||||
/** \ingroup SuperLUSupport_Module
|
||||
* \class SuperILU
|
||||
* \brief A sparse direct \b incomplete LU factorization and solver based on the SuperLU library
|
||||
*
|
||||
* This class allows to solve for an approximate solution of A.X = B sparse linear problems via an incomplete LU
|
||||
* factorization using the SuperLU library. This class is aimed to be used as a preconditioner of the iterative linear
|
||||
* solvers.
|
||||
*
|
||||
* \warning This class is only for the 4.x versions of SuperLU. The 3.x and 5.x versions are not supported.
|
||||
*
|
||||
* \tparam MatrixType_ the type of the sparse matrix A, it must be a SparseMatrix<>
|
||||
*
|
||||
* \implsparsesolverconcept
|
||||
*
|
||||
* \sa \ref TutorialSparseSolverConcept, class IncompleteLUT, class ConjugateGradient, class BiCGSTAB
|
||||
*/
|
||||
|
||||
template <typename MatrixType_>
|
||||
class SuperILU : public SuperLUBase<MatrixType_, SuperILU<MatrixType_> > {
|
||||
public:
|
||||
typedef SuperLUBase<MatrixType_, SuperILU> Base;
|
||||
typedef MatrixType_ MatrixType;
|
||||
typedef typename Base::Scalar Scalar;
|
||||
typedef typename Base::RealScalar RealScalar;
|
||||
|
||||
public:
|
||||
using Base::_solve_impl;
|
||||
|
||||
SuperILU() : Base() { init(); }
|
||||
|
||||
SuperILU(const MatrixType &matrix) : Base() {
|
||||
init();
|
||||
Base::compute(matrix);
|
||||
}
|
||||
|
||||
~SuperILU() {}
|
||||
|
||||
/** Performs a symbolic decomposition on the sparcity of \a matrix.
|
||||
*
|
||||
* This function is particularly useful when solving for several problems having the same structure.
|
||||
*
|
||||
* \sa factorize()
|
||||
*/
|
||||
void analyzePattern(const MatrixType &matrix) { Base::analyzePattern(matrix); }
|
||||
|
||||
/** Performs a numeric decomposition of \a matrix
|
||||
*
|
||||
* The given matrix must has the same sparcity than the matrix on which the symbolic decomposition has been performed.
|
||||
*
|
||||
* \sa analyzePattern()
|
||||
*/
|
||||
void factorize(const MatrixType &matrix);
|
||||
|
||||
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
||||
/** \internal */
|
||||
template <typename Rhs, typename Dest>
|
||||
void _solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &dest) const;
|
||||
#endif // EIGEN_PARSED_BY_DOXYGEN
|
||||
|
||||
protected:
|
||||
using Base::m_l;
|
||||
using Base::m_matrix;
|
||||
using Base::m_p;
|
||||
using Base::m_q;
|
||||
using Base::m_sluA;
|
||||
using Base::m_sluB;
|
||||
using Base::m_sluBerr;
|
||||
using Base::m_sluCscale;
|
||||
using Base::m_sluEqued;
|
||||
using Base::m_sluEtree;
|
||||
using Base::m_sluFerr;
|
||||
using Base::m_sluL;
|
||||
using Base::m_sluOptions;
|
||||
using Base::m_sluRscale;
|
||||
using Base::m_sluStat;
|
||||
using Base::m_sluU;
|
||||
using Base::m_sluX;
|
||||
using Base::m_u;
|
||||
|
||||
using Base::m_analysisIsOk;
|
||||
using Base::m_extractedDataAreDirty;
|
||||
using Base::m_factorizationIsOk;
|
||||
using Base::m_info;
|
||||
using Base::m_isInitialized;
|
||||
|
||||
void init() {
|
||||
Base::init();
|
||||
|
||||
ilu_set_default_options(&m_sluOptions);
|
||||
m_sluOptions.PrintStat = NO;
|
||||
m_sluOptions.ConditionNumber = NO;
|
||||
m_sluOptions.Trans = NOTRANS;
|
||||
m_sluOptions.ColPerm = MMD_AT_PLUS_A;
|
||||
|
||||
// no attempt to preserve column sum
|
||||
m_sluOptions.ILU_MILU = SILU;
|
||||
// only basic ILU(k) support -- no direct control over memory consumption
|
||||
// better to use ILU_DropRule = DROP_BASIC | DROP_AREA
|
||||
// and set ILU_FillFactor to max memory growth
|
||||
m_sluOptions.ILU_DropRule = DROP_BASIC;
|
||||
m_sluOptions.ILU_DropTol = NumTraits<Scalar>::dummy_precision() * 10;
|
||||
}
|
||||
|
||||
private:
|
||||
SuperILU(SuperILU &) {}
|
||||
};
|
||||
|
||||
template <typename MatrixType>
|
||||
void SuperILU<MatrixType>::factorize(const MatrixType &a) {
|
||||
eigen_assert(m_analysisIsOk && "You must first call analyzePattern()");
|
||||
if (!m_analysisIsOk) {
|
||||
m_info = InvalidInput;
|
||||
return;
|
||||
}
|
||||
|
||||
this->initFactorization(a);
|
||||
|
||||
int info = 0;
|
||||
RealScalar recip_pivot_growth, rcond;
|
||||
|
||||
StatInit(&m_sluStat);
|
||||
SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
|
||||
&m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &m_sluStat,
|
||||
&info, Scalar());
|
||||
StatFree(&m_sluStat);
|
||||
|
||||
// FIXME how to better check for errors ???
|
||||
m_info = info == 0 ? Success : NumericalIssue;
|
||||
m_factorizationIsOk = true;
|
||||
}
|
||||
|
||||
#ifndef EIGEN_PARSED_BY_DOXYGEN
|
||||
template <typename MatrixType>
|
||||
template <typename Rhs, typename Dest>
|
||||
void SuperILU<MatrixType>::_solve_impl(const MatrixBase<Rhs> &b, MatrixBase<Dest> &x) const {
|
||||
eigen_assert(m_factorizationIsOk &&
|
||||
"The decomposition is not in a valid state for solving, you must first call either compute() or "
|
||||
"analyzePattern()/factorize()");
|
||||
|
||||
const int rhsCols = b.cols();
|
||||
eigen_assert(m_matrix.rows() == b.rows());
|
||||
|
||||
m_sluOptions.Trans = NOTRANS;
|
||||
m_sluOptions.Fact = FACTORED;
|
||||
m_sluOptions.IterRefine = NOREFINE;
|
||||
|
||||
m_sluFerr.resize(rhsCols);
|
||||
m_sluBerr.resize(rhsCols);
|
||||
|
||||
Ref<const Matrix<typename Rhs::Scalar, Dynamic, Dynamic, ColMajor> > b_ref(b);
|
||||
Ref<const Matrix<typename Dest::Scalar, Dynamic, Dynamic, ColMajor> > x_ref(x);
|
||||
|
||||
m_sluB = SluMatrix::Map(b_ref.const_cast_derived());
|
||||
m_sluX = SluMatrix::Map(x_ref.const_cast_derived());
|
||||
|
||||
typename Rhs::PlainObject b_cpy;
|
||||
if (m_sluEqued != 'N') {
|
||||
b_cpy = b;
|
||||
m_sluB = SluMatrix::Map(b_cpy.const_cast_derived());
|
||||
}
|
||||
|
||||
int info = 0;
|
||||
RealScalar recip_pivot_growth, rcond;
|
||||
|
||||
StatInit(&m_sluStat);
|
||||
SuperLU_gsisx(&m_sluOptions, &m_sluA, m_q.data(), m_p.data(), &m_sluEtree[0], &m_sluEqued, &m_sluRscale[0],
|
||||
&m_sluCscale[0], &m_sluL, &m_sluU, NULL, 0, &m_sluB, &m_sluX, &recip_pivot_growth, &rcond, &m_sluStat,
|
||||
&info, Scalar());
|
||||
StatFree(&m_sluStat);
|
||||
|
||||
if (x.derived().data() != x_ref.data()) x = x_ref;
|
||||
|
||||
m_info = info == 0 ? Success : NumericalIssue;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
} // end namespace Eigen
|
||||
|
||||
#endif // EIGEN_SUPERLUSUPPORT_H
|
||||
Loading…
Add table
Add a link
Reference in a new issue