1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
// Copyright (C) 2004, 2010 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Carl Laird, Andreas Waechter IBM 2005-03-17
#ifndef __IPPARDISOMKLSOLVERINTERFACE_HPP__
#define __IPPARDISOMKLSOLVERINTERFACE_HPP__
#include "IpoptConfig.h"
#include "IpSparseSymLinearSolverInterface.hpp"
#include "IpLibraryLoader.hpp"
#include "IpTypes.h"
namespace Ipopt
{
/** Interface to the linear solver Pardiso as distributed by Intel MKL, derived from SparseSymLinearSolverInterface.
* @since 3.14.0
*/
class PardisoMKLSolverInterface: public SparseSymLinearSolverInterface
{
public:
/** @name Constructor/Destructor */
///@{
/** Constructor */
PardisoMKLSolverInterface();
/** Destructor */
virtual ~PardisoMKLSolverInterface();
///@}
bool InitializeImpl(
const OptionsList& options,
const std::string& prefix
);
/** @name Methods for requesting solution of the linear system. */
///@{
virtual ESymSolverStatus InitializeStructure(
Index dim,
Index nonzeros,
const Index* ia,
const Index* ja
);
virtual Number* GetValuesArrayPtr();
virtual ESymSolverStatus MultiSolve(
bool new_matrix,
const Index* ia,
const Index* ja,
Index nrhs,
Number* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals);
virtual Index NumberOfNegEVals() const;
///@}
//* @name Options of Linear solver */
///@{
virtual bool IncreaseQuality();
virtual bool ProvidesInertia() const
{
return true;
}
EMatrixFormat MatrixFormat() const
{
return CSR_Format_1_Offset;
}
///@}
///@{
static void RegisterOptions(
SmartPtr<RegisteredOptions> roptions
);
///@}
private:
/**@name Default Compiler Generated Methods
* (Hidden to avoid implicit creation/calling).
* These methods are not implemented and
* we do not want the compiler to implement
* them for us, so we declare them private
* and do not define them. This ensures that
* they will not be implicitly created/called. */
///@{
/** Copy Constructor */
PardisoMKLSolverInterface(
const PardisoMKLSolverInterface&);
/** Default Assignment Operator */
void operator=(
const PardisoMKLSolverInterface&);
///@}
/** @name Information about the matrix */
///@{
/** Number of rows and columns of the matrix */
Index dim_;
/** Number of nonzeros of the matrix in triplet representation. */
Index nonzeros_;
/** Array for storing the values of the matrix. */
Number* a_;
///@}
/** @name Information about most recent factorization/solve */
///@{
/** Number of negative eigenvalues */
Index negevals_;
///@}
/** @name Solver specific options */
///@{
/** Type for matching strategies */
enum PardisoMatchingStrategy
{
COMPLETE,
COMPLETE2x2,
CONSTRAINT
};
/** Option that controls the matching strategy. */
PardisoMatchingStrategy match_strat_;
/** Flag indicating if symbolic factorization has already been performed. */
bool have_symbolic_factorization_;
/** Flag indicating whether the symbolic factorization should only
* be done after perturbed elements, if the inertia was wrong
*/
bool pardiso_redo_symbolic_fact_only_if_inertia_wrong_;
/** Flag indicating whether repeated perturbed elements even after
* a new symbolic factorization should be interpreted as a
* singular matrix
*/
bool pardiso_repeated_perturbation_means_singular_;
/** Flag indicating if the inertia is always assumed to be
* correct.
*/
bool skip_inertia_check_;
///@}
/** @name Initialization flags */
///@{
/** Flag indicating if internal data is initialized.
* For initialization, this object needs to have seen a matrix.
*/
bool initialized_;
///@}
/** @name Solver specific information */
///@{
/** Internal data address pointers. */
void** PT_;
/** Maximal number of factors with identical nonzero
* structure. Here, we only store one factorization. Is always 1.
*/
Index MAXFCT_;
/** Actual matrix for the solution phase. Is always 1.*/
Index MNUM_;
/** Matrix type; real and symmetric indefinite. Is always -2.*/
Index MTYPE_;
/** Parameter and info array for Pardiso. */
Index* IPARM_;
/** Parameter and info array for Pardiso. */
Number* DPARM_;
/** Message level. */
Index MSGLVL_;
///@}
/**@name Some counters for debugging */
///@{
Index debug_last_iter_;
Index debug_cnt_;
///@}
/** @name Internal functions */
///@{
/** Call Pardiso to do the analysis phase. */
ESymSolverStatus SymbolicFactorization(
const Index* ia,
const Index* ja
);
/** Call Pardiso to factorize the Matrix. */
ESymSolverStatus Factorization(
const Index* ia,
const Index* ja,
bool check_NegEVals,
Index numberOfNegEVals
);
/** Call Pardiso to do the Solve. */
ESymSolverStatus Solve(
const Index* ia,
const Index* ja,
Index nrhs,
Number* rhs_vals
);
///@}
};
} // namespace Ipopt
#endif /* __IPPARDISOMKLSOLVERINTERFACE_HPP__ */