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
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
// Copyright (C) 2004, 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Carl Laird, Andreas Waechter IBM 2004-03-17
#ifndef __IPTSYMLINEARSOLVER_HPP__
#define __IPTSYMLINEARSOLVER_HPP__
#include "IpSymLinearSolver.hpp"
#include "IpSparseSymLinearSolverInterface.hpp"
#include "IpTSymScalingMethod.hpp"
#include "IpSymMatrix.hpp"
#include "IpTripletToCSRConverter.hpp"
#include <vector>
#include <list>
namespace Ipopt
{
/** General driver for linear solvers for sparse indefinite
* symmetric matrices.
*
* This interface includes a call to a method
* for scaling of the matrix (if given). This class takes in the
* constructor a pointer to the interface to an actual linear
* solver, and possibly a pointer to a method for computing scaling
* factors. It translates the SymMatrix into the format required
* by the linear solver and calls the solver via the
* TSymLinearSolverInterface. If a scaling method has been given,
* the matrix, the right hand side, and the solution are scaled.
*/
class TSymLinearSolver: public SymLinearSolver
{
public:
/** @name Constructor/Destructor */
///@{
/** Constructor.
*
* The solver_interface is a pointer to a linear
* solver for symmetric matrices in triplet format.
* If scaling_method not NULL, it must be a pointer to a class for
* computing scaling factors for the matrix.
*/
TSymLinearSolver(
SmartPtr<SparseSymLinearSolverInterface> solver_interface,
SmartPtr<TSymScalingMethod> scaling_method
);
/** Destructor */
virtual ~TSymLinearSolver();
///@}
bool InitializeImpl(
const OptionsList& options,
const std::string& prefix);
/** @name Methods for requesting solution of the linear system. */
///@{
virtual ESymSolverStatus MultiSolve(
const SymMatrix& A,
std::vector<SmartPtr<const Vector> >& rhsV,
std::vector<SmartPtr<Vector> >& solV,
bool check_NegEVals,
Index numberOfNegEVals
);
virtual Index NumberOfNegEVals() const;
///@}
//* @name Options of Linear solver */
///@{
virtual bool IncreaseQuality();
virtual bool ProvidesInertia() const;
///@}
/** @name Methods related to the detection of linearly dependent
* rows in a matrix
*/
///@{
bool ProvidesDegeneracyDetection() const;
ESymSolverStatus DetermineDependentRows(
Index n_rows,
Index n_cols,
Index n_jac_nz,
Number* jac_c_vals,
Index* jac_c_iRow,
Index* jac_c_jCol,
std::list<Index>& c_deps
);
///@}
/** Methods for OptionsList */
///@{
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. */
///@{
/** Default Constructor */
TSymLinearSolver();
/** Copy Constructor */
TSymLinearSolver(
const TSymLinearSolver&
);
/** Default Assignment Operator */
void operator=(
const TSymLinearSolver&
);
///@}
/** @name Information about the matrix */
///@{
/** Tag for the incoming matrix */
TaggedObject::Tag atag_;
/** Number of rows and columns of the matrix */
Index dim_;
/** Number of nonzeros of the matrix in triplet format.
*
* Note that some elements might appear multiple times in
* which case the values are added.
*/
Index nonzeros_triplet_;
/** Number of nonzeros in compressed format.
*
* This is only computed if the sparse linear solver works
* with the CSR format.
*/
Index nonzeros_compressed_;
///@}
/** @name Initialization flags */
///@{
/** Flag indicating if the internal structures are initialized.
*
* For initialization, this object needs to have seen a matrix.
*/
bool have_structure_;
/** Flag indicating whether the scaling objected is to be switched
* on when increased quality is requested.
*/
bool linear_scaling_on_demand_;
/** Flag indicating if the InitializeStructure method has been
* called for the linear solver.
*/
bool initialized_;
///@}
/** Strategy Object for an interface to a linear solver. */
SmartPtr<SparseSymLinearSolverInterface> solver_interface_;
/** @name Stuff for scaling of the linear system. */
///@{
/** Strategy Object for a method that computes scaling factors for
* the matrices.
*
* If NULL, no scaling is performed.
*/
SmartPtr<TSymScalingMethod> scaling_method_;
/** Array storing the scaling factors */
Number* scaling_factors_;
/** Flag indicating whether scaling should be performed */
bool use_scaling_;
/** Flag indicating whether we just switched on the scaling */
bool just_switched_on_scaling_;
///@}
/** @name information about the matrix. */
///@{
/** row indices of matrix in triplet (MA27) format. */
Index* airn_;
/** column indices of matrix in triplet (MA27) format. */
Index* ajcn_;
/** Pointer to object for conversion from triplet to compressed format.
*
* This is only required if the linear solver works with
* the compressed representation.
*/
SmartPtr<TripletToCSRConverter> triplet_to_csr_converter_;
/** Flag indicating what matrix data format the solver requires. */
SparseSymLinearSolverInterface::EMatrixFormat matrix_format_;
///@}
/** @name Algorithmic parameters */
///@{
/** Flag indicating whether the TNLP with identical structure has
* already been solved before.
*/
bool warm_start_same_structure_;
///@}
/** @name Internal functions */
///@{
/** Initialize nonzero structure.
*
* Set dim_ and nonzeros_, and copy the nonzero structure of symT_A
* into airn_ and ajcn_.
*/
ESymSolverStatus InitializeStructure(
const SymMatrix& symT_A
);
/** Copy the elements of the matrix in the required format into
* the array that is provided by the solver interface.
*/
void GiveMatrixToSolver(
bool new_matrix,
const SymMatrix& sym_A
);
///@}
};
} // namespace Ipopt
#endif