33#ifndef EIGEN_PARDISOSUPPORT_H
34#define EIGEN_PARDISOSUPPORT_H
37#include "./InternalHeaderCheck.h"
41template <
typename MatrixType_>
43template <
typename MatrixType_,
int Options = Upper>
45template <
typename MatrixType_,
int Options = Upper>
49template <
typename IndexType>
50struct pardiso_run_selector {
51 static IndexType run(_MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase,
52 IndexType n,
void* a, IndexType* ia, IndexType* ja, IndexType* perm, IndexType nrhs,
53 IndexType* iparm, IndexType msglvl,
void* b,
void* x) {
55 ::pardiso(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
60struct pardiso_run_selector<long long int> {
61 using IndexType =
long long int;
62 static IndexType run(_MKL_DSS_HANDLE_t pt, IndexType maxfct, IndexType mnum, IndexType type, IndexType phase,
63 IndexType n,
void* a, IndexType* ia, IndexType* ja, IndexType* perm, IndexType nrhs,
64 IndexType* iparm, IndexType msglvl,
void* b,
void* x) {
66 ::pardiso_64(pt, &maxfct, &mnum, &type, &phase, &n, a, ia, ja, perm, &nrhs, iparm, &msglvl, b, x, &error);
71template <
class Pardiso>
74template <
typename MatrixType_>
75struct pardiso_traits<PardisoLU<MatrixType_> > {
76 using MatrixType = MatrixType_;
77 using Scalar =
typename MatrixType_::Scalar;
78 using RealScalar =
typename MatrixType_::RealScalar;
79 using StorageIndex =
typename MatrixType_::StorageIndex;
82template <
typename MatrixType_,
int Options>
83struct pardiso_traits<PardisoLLT<MatrixType_, Options> > {
84 using MatrixType = MatrixType_;
85 using Scalar =
typename MatrixType_::Scalar;
86 using RealScalar =
typename MatrixType_::RealScalar;
87 using StorageIndex =
typename MatrixType_::StorageIndex;
90template <
typename MatrixType_,
int Options>
91struct pardiso_traits<PardisoLDLT<MatrixType_, Options> > {
92 using MatrixType = MatrixType_;
93 using Scalar =
typename MatrixType_::Scalar;
94 using RealScalar =
typename MatrixType_::RealScalar;
95 using StorageIndex =
typename MatrixType_::StorageIndex;
100template <
class Derived>
105 using Base::m_isInitialized;
107 using Traits = internal::pardiso_traits<Derived>;
110 using Base::_solve_impl;
112 using MatrixType =
typename Traits::MatrixType;
113 using Scalar =
typename Traits::Scalar;
114 using RealScalar =
typename Traits::RealScalar;
115 using StorageIndex =
typename Traits::StorageIndex;
116 using SparseMatrixType = SparseMatrix<Scalar, RowMajor, StorageIndex>;
117 using VectorType = Matrix<Scalar, Dynamic, 1>;
118 using IntRowVectorType = Matrix<StorageIndex, 1, MatrixType::ColsAtCompileTime>;
119 using IntColVectorType = Matrix<StorageIndex, MatrixType::RowsAtCompileTime, 1>;
120 using ParameterType = Array<StorageIndex, 64, 1, DontAlign>;
121 enum { ScalarIsComplex = NumTraits<Scalar>::IsComplex, ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };
123 PardisoImpl() : m_analysisIsOk(false), m_factorizationIsOk(false) {
124 eigen_assert((
sizeof(StorageIndex) >=
sizeof(_INTEGER_t) &&
sizeof(StorageIndex) <= 8) &&
125 "Non-supported index type");
128 m_isInitialized =
false;
131 ~PardisoImpl() { pardisoRelease(); }
133 inline Index cols()
const {
return m_size; }
134 inline Index rows()
const {
return m_size; }
142 eigen_assert(m_isInitialized &&
"Decomposition is not initialized.");
149 ParameterType& pardisoParameterArray() {
return m_iparm; }
157 Derived& analyzePattern(
const MatrixType& matrix);
166 Derived& factorize(
const MatrixType& matrix);
168 Derived& compute(
const MatrixType& matrix);
170 template <
typename Rhs,
typename Dest>
171 void _solve_impl(
const MatrixBase<Rhs>& b, MatrixBase<Dest>& dest)
const;
174 void pardisoRelease() {
177 internal::pardiso_run_selector<StorageIndex>::run(m_pt, 1, 1, m_type, -1,
178 internal::convert_index<StorageIndex>(m_size), 0, 0, 0,
179 m_perm.data(), 0, m_iparm.data(), m_msglvl,
nullptr,
nullptr);
180 m_isInitialized =
false;
184 void pardisoInit(
int type) {
186 bool symmetric = numext::abs(m_type) < 10;
197 m_iparm[10] = symmetric ? 0 : 1;
199 m_iparm[12] = symmetric ? 0 : 1;
211 m_iparm[27] = (
sizeof(RealScalar) == 4) ? 1 : 0;
216 memset(m_pt, 0,
sizeof(m_pt));
222 void manageErrorCode(Index error)
const {
236 mutable SparseMatrixType m_matrix;
238 bool m_analysisIsOk, m_factorizationIsOk;
239 StorageIndex m_type, m_msglvl;
240 mutable void* m_pt[64];
241 mutable ParameterType m_iparm;
242 mutable IntColVectorType m_perm;
246template <
class Derived>
247Derived& PardisoImpl<Derived>::compute(
const MatrixType& a) {
249 eigen_assert(a.rows() == a.cols());
252 m_perm.setZero(m_size);
253 derived().getMatrix(a);
256 error = internal::pardiso_run_selector<StorageIndex>::run(
257 m_pt, 1, 1, m_type, 12, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
258 m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl,
nullptr,
nullptr);
259 manageErrorCode(error);
262 m_isInitialized =
true;
266template <
class Derived>
267Derived& PardisoImpl<Derived>::analyzePattern(
const MatrixType& a) {
269 eigen_assert(m_size == a.cols());
272 m_perm.setZero(m_size);
273 derived().getMatrix(a);
276 error = internal::pardiso_run_selector<StorageIndex>::run(
277 m_pt, 1, 1, m_type, 11, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
278 m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl,
nullptr,
nullptr);
280 manageErrorCode(error);
282 m_factorizationIsOk =
false;
283 m_isInitialized =
true;
287template <
class Derived>
288Derived& PardisoImpl<Derived>::factorize(
const MatrixType& a) {
289 eigen_assert(m_analysisIsOk &&
"You must first call analyzePattern()");
290 eigen_assert(m_size == a.rows() && m_size == a.cols());
292 derived().getMatrix(a);
295 error = internal::pardiso_run_selector<StorageIndex>::run(
296 m_pt, 1, 1, m_type, 22, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
297 m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), 0, m_iparm.data(), m_msglvl,
nullptr,
nullptr);
299 manageErrorCode(error);
304template <
class Derived>
305template <
typename BDerived,
typename XDerived>
313 Index nrhs = Index(b.cols());
314 eigen_assert(m_size == b.rows());
316 "Row-major right hand sides are not supported");
318 "Row-major matrices of unknowns are not supported");
330 const bool b_contiguous = b.derived().rowStride() == 1 && (nrhs == 1 || b.derived().colStride() == m_size);
331 const bool x_contiguous = x.derived().rowStride() == 1 && (nrhs == 1 || x.derived().colStride() == m_size);
333 Scalar* rhs_ptr =
const_cast<Scalar*
>(b.derived().data());
334 if (!b_contiguous || rhs_ptr == x.derived().data()) {
336 rhs_ptr = b_tmp.data();
338 Scalar* x_ptr = x.derived().data();
340 x_tmp.resize(m_size, nrhs);
341 x_ptr = x_tmp.data();
345 error = internal::pardiso_run_selector<StorageIndex>::run(
346 m_pt, 1, 1, m_type, 33, internal::convert_index<StorageIndex>(m_size), m_matrix.valuePtr(),
347 m_matrix.outerIndexPtr(), m_matrix.innerIndexPtr(), m_perm.data(), internal::convert_index<StorageIndex>(nrhs),
348 m_iparm.data(), m_msglvl, rhs_ptr, x_ptr);
350 if (!x_contiguous) x.derived() = x_tmp;
351 manageErrorCode(error);
371template <
typename MatrixType>
372class PardisoLU :
public PardisoImpl<PardisoLU<MatrixType> > {
374 using Base = PardisoImpl<PardisoLU>;
375 using Base::m_matrix;
376 using Base::pardisoInit;
377 friend class PardisoImpl<PardisoLU<MatrixType> >;
380 using Scalar =
typename Base::Scalar;
381 using RealScalar =
typename Base::RealScalar;
386 PardisoLU() : Base() { pardisoInit(Base::ScalarIsComplex ? 13 : 11); }
388 explicit PardisoLU(
const MatrixType& matrix) : Base() {
389 pardisoInit(Base::ScalarIsComplex ? 13 : 11);
394 void getMatrix(
const MatrixType& matrix) {
396 m_matrix.makeCompressed();
419template <
typename MatrixType,
int UpLo_>
420class PardisoLLT :
public PardisoImpl<PardisoLLT<MatrixType, UpLo_> > {
422 using Base = PardisoImpl<PardisoLLT<MatrixType, UpLo_> >;
423 using Base::m_matrix;
424 using Base::pardisoInit;
425 friend class PardisoImpl<PardisoLLT<MatrixType, UpLo_> >;
428 using Scalar =
typename Base::Scalar;
429 using RealScalar =
typename Base::RealScalar;
430 using StorageIndex =
typename Base::StorageIndex;
431 enum { UpLo = UpLo_ };
434 PardisoLLT() : Base() { pardisoInit(Base::ScalarIsComplex ? 4 : 2); }
436 explicit PardisoLLT(
const MatrixType& matrix) : Base() {
437 pardisoInit(Base::ScalarIsComplex ? 4 : 2);
442 void getMatrix(
const MatrixType& matrix) {
445 m_matrix.
resize(matrix.rows(), matrix.cols());
446 m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
447 m_matrix.makeCompressed();
473template <
typename MatrixType,
int Options>
474class PardisoLDLT :
public PardisoImpl<PardisoLDLT<MatrixType, Options> > {
476 using Base = PardisoImpl<PardisoLDLT<MatrixType, Options> >;
477 using Base::m_matrix;
478 using Base::pardisoInit;
479 friend class PardisoImpl<PardisoLDLT<MatrixType, Options> >;
482 using Scalar =
typename Base::Scalar;
483 using RealScalar =
typename Base::RealScalar;
484 using StorageIndex =
typename Base::StorageIndex;
488 PardisoLDLT() : Base() { pardisoInit(Base::ScalarIsComplex ? (
bool(Options &
Symmetric) ? 6 : -4) : -2); }
490 explicit PardisoLDLT(
const MatrixType& matrix) : Base() {
491 pardisoInit(Base::ScalarIsComplex ? (
bool(Options &
Symmetric) ? 6 : -4) : -2);
495 void getMatrix(
const MatrixType& matrix) {
498 m_matrix.
resize(matrix.rows(), matrix.cols());
499 m_matrix.template selfadjointView<Upper>() = matrix.template selfadjointView<UpLo>().twistedBy(p_null);
500 m_matrix.makeCompressed();
@ Flags
Definition DenseBase.h:162
Base class for all dense matrices, vectors, and expressions.
Definition MatrixBase.h:53
The matrix class, also used for vectors and row-vectors.
Definition Matrix.h:188
A sparse direct Cholesky (LDLT) factorization and solver based on the PARDISO library.
Definition PardisoSupport.h:474
A sparse direct Cholesky (LLT) factorization and solver based on the PARDISO library.
Definition PardisoSupport.h:420
A sparse direct LU factorization and solver based on the PARDISO library.
Definition PardisoSupport.h:372
void resize(Index newSize)
Definition PermutationMatrix.h:166
Permutation matrix.
Definition PermutationMatrix.h:346
A base class for sparse solvers.
Definition SparseSolverBase.h:68
SparseSolverBase()=default
Solve< Derived, Rhs > solve(const MatrixBase< Rhs > &b) const
Definition SparseSolverBase.h:88
ComputationInfo
Definition Constants.h:455
@ Symmetric
Definition Constants.h:230
@ Lower
Definition Constants.h:212
@ Upper
Definition Constants.h:214
@ NumericalIssue
Definition Constants.h:459
@ InvalidInput
Definition Constants.h:464
@ Success
Definition Constants.h:457
constexpr unsigned int RowMajorBit
Definition Constants.h:71