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
// Copyright (C) 2009 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Andreas Waechter IBM 2009-09-18
// based on IpWsmpSolverInterface.hpp (rev 1483)
#ifndef __IPITERATIVEWSMPSOLVERINTERFACE_HPP__
#define __IPITERATIVEWSMPSOLVERINTERFACE_HPP__
#include "IpSparseSymLinearSolverInterface.hpp"
#include "IpTypes.h"
namespace Ipopt
{
/** Interface to the linear solver WISMP, derived from
* SparseSymLinearSolverInterface.
*/
class IterativeWsmpSolverInterface: public SparseSymLinearSolverInterface
{
public:
/** @name Constructor/Destructor */
///@{
/** Constructor */
IterativeWsmpSolverInterface();
/** Destructor */
virtual ~IterativeWsmpSolverInterface();
///@}
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 double* GetValuesArrayPtr();
virtual ESymSolverStatus MultiSolve(
bool new_matrix,
const Index* ia,
const Index* ja,
Index nrhs,
double* rhs_vals,
bool check_NegEVals,
Index numberOfNegEVals
);
virtual Index NumberOfNegEVals() const;
///@}
//* @name Options of Linear solver */
///@{
virtual bool IncreaseQuality();
virtual bool ProvidesInertia() const
{
return false;
}
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 */
IterativeWsmpSolverInterface(
const IterativeWsmpSolverInterface&
);
/** Default Assignment Operator */
void operator=(
const IterativeWsmpSolverInterface&
);
///@}
/** @name Information about the matrix */
///@{
/** Number of rows and columns of the matrix */
Index dim_;
/** Array for storing the values of the matrix. */
double* a_;
///@}
/** @name Solver specific options */
///@{
/** Option that controls the matching strategy. */
Index wsmp_num_threads_;
/** Pivot tolerance */
Number wsmp_pivtol_;
/** Maximal pivot tolerance */
Number wsmp_pivtolmax_;
/** Indicating which of WSMP's scaling methods should be used. */
Index wsmp_scaling_;
/** iteration number in which matrices are to be written out */
Index wsmp_write_matrix_iteration_;
Number wsmp_inexact_droptol_;
Number wsmp_inexact_fillin_limit_;
///@}
/** Counter for matrix file numbers */
Index matrix_file_number_;
/** @name Information about most recent factorization/solve */
///@{
#if 0
/** Number of negative eigenvalues */
Index negevals_;
#endif
///@}
/** @name Initialization flags */
///@{
/** Flag indicating if internal data is initialized.
* For initialization, this object needs to have seen a matrix
*/
bool initialized_;
/** Flag indicating if the matrix has to be refactorized because
* the pivot tolerance has been changed.
*/
bool pivtol_changed_;
/** Flag indicating whether symbolic factorization and order has
* already been performed.
*/
bool have_symbolic_factorization_;
///@}
/** @name Solver specific information */
///@{
/** Integer parameter array for WISMP. */
ipindex* IPARM_;
/** Double precision parameter array for WISMP. */
double* DPARM_;
///@}
/** @name Internal functions */
///@{
/** Call Wsmp to do the analysis phase.
*/
ESymSolverStatus SymbolicFactorization(
const Index* ia,
const Index* ja
);
/** Call Wsmp to really do the analysis phase. */
ESymSolverStatus InternalSymFact(
const Index* ia,
const Index* ja
);
/** Call Wsmp to factorize the Matrix. */
ESymSolverStatus Factorization(
const Index* ia,
const Index* ja,
bool check_NegEVals,
Index numberOfNegEVals
);
/** Call Wsmpx to do the Solve. */
ESymSolverStatus Solve(
const Index* ia,
const Index* ja,
Index nrhs,
double* rhs_vals
);
///@}
};
} // namespace Ipopt
#endif