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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpNLP.hpp 2269 2013-05-05 11:32:40Z stefan $
//
// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
#ifndef __IPNLP_HPP__
#define __IPNLP_HPP__
#include "IpUtils.hpp"
#include "IpVector.hpp"
#include "IpSmartPtr.hpp"
#include "IpMatrix.hpp"
#include "IpSymMatrix.hpp"
#include "IpOptionsList.hpp"
#include "IpAlgTypes.hpp"
#include "IpReturnCodes.hpp"
namespace Ipopt
{
// forward declarations
class IpoptData;
class IpoptCalculatedQuantities;
class IteratesVector;
/** Brief Class Description.
* Detailed Class Description.
*/
class NLP : public ReferencedObject
{
public:
/**@name Constructors/Destructors */
//@{
/** Default constructor */
NLP()
{}
/** Default destructor */
virtual ~NLP()
{}
//@}
/** Exceptions */
//@{
DECLARE_STD_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED);
DECLARE_STD_EXCEPTION(INVALID_NLP);
//@}
/** @name NLP Initialization (overload in
* derived classes).*/
//@{
/** Overload if you want the chance to process options or parameters that
* may be specific to the NLP */
virtual bool ProcessOptions(const OptionsList& options,
const std::string& prefix)
{
return true;
}
/** Method for creating the derived vector / matrix types. The
* Hess_lagrangian_space pointer can be NULL if a quasi-Newton
* options is chosen. */
virtual bool GetSpaces(SmartPtr<const VectorSpace>& x_space,
SmartPtr<const VectorSpace>& c_space,
SmartPtr<const VectorSpace>& d_space,
SmartPtr<const VectorSpace>& x_l_space,
SmartPtr<const MatrixSpace>& px_l_space,
SmartPtr<const VectorSpace>& x_u_space,
SmartPtr<const MatrixSpace>& px_u_space,
SmartPtr<const VectorSpace>& d_l_space,
SmartPtr<const MatrixSpace>& pd_l_space,
SmartPtr<const VectorSpace>& d_u_space,
SmartPtr<const MatrixSpace>& pd_u_space,
SmartPtr<const MatrixSpace>& Jac_c_space,
SmartPtr<const MatrixSpace>& Jac_d_space,
SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space)=0;
/** Method for obtaining the bounds information */
virtual bool GetBoundsInformation(const Matrix& Px_L,
Vector& x_L,
const Matrix& Px_U,
Vector& x_U,
const Matrix& Pd_L,
Vector& d_L,
const Matrix& Pd_U,
Vector& d_U)=0;
/** Method for obtaining the starting point for all the
* iterates. ToDo it might not make sense to ask for initial
* values for v_L and v_U? */
virtual bool GetStartingPoint(
SmartPtr<Vector> x,
bool need_x,
SmartPtr<Vector> y_c,
bool need_y_c,
SmartPtr<Vector> y_d,
bool need_y_d,
SmartPtr<Vector> z_L,
bool need_z_L,
SmartPtr<Vector> z_U,
bool need_z_U
)=0;
/** Method for obtaining an entire iterate as a warmstart point.
* The incoming IteratesVector has to be filled. The default
* dummy implementation returns false. */
virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate)
{
return false;
}
//@}
/** @name NLP evaluation routines (overload
* in derived classes. */
//@{
virtual bool Eval_f(const Vector& x, Number& f) = 0;
virtual bool Eval_grad_f(const Vector& x, Vector& g_f) = 0;
virtual bool Eval_c(const Vector& x, Vector& c) = 0;
virtual bool Eval_jac_c(const Vector& x, Matrix& jac_c) = 0;
virtual bool Eval_d(const Vector& x, Vector& d) = 0;
virtual bool Eval_jac_d(const Vector& x, Matrix& jac_d) = 0;
virtual bool Eval_h(const Vector& x,
Number obj_factor,
const Vector& yc,
const Vector& yd,
SymMatrix& h) = 0;
//@}
/** @name NLP solution routines. Have default dummy
* implementations that can be overloaded. */
//@{
/** This method is called at the very end of the optimization. It
* provides the final iterate to the user, so that it can be
* stored as the solution. The status flag indicates the outcome
* of the optimization, where SolverReturn is defined in
* IpAlgTypes.hpp. */
virtual void FinalizeSolution(SolverReturn status,
const Vector& x, const Vector& z_L,
const Vector& z_U,
const Vector& c, const Vector& d,
const Vector& y_c, const Vector& y_d,
Number obj_value,
const IpoptData* ip_data,
IpoptCalculatedQuantities* ip_cq)
{}
/** This method is called once per iteration, after the iteration
* summary output has been printed. It provides the current
* information to the user to do with it anything she wants. It
* also allows the user to ask for a premature termination of the
* optimization by returning false, in which case Ipopt will
* terminate with a corresponding return status. The basic
* information provided in the argument list has the quantities
* values printed in the iteration summary line. If more
* information is required, a user can obtain it from the IpData
* and IpCalculatedQuantities objects. However, note that the
* provided quantities are all for the problem that Ipopt sees,
* i.e., the quantities might be scaled, fixed variables might be
* sorted out, etc. The status indicates things like whether the
* algorithm is in the restoration phase... In the restoration
* phase, the dual variables are probably not not changing. */
virtual bool IntermediateCallBack(AlgorithmMode mode,
Index iter, Number obj_value,
Number inf_pr, Number inf_du,
Number mu, Number d_norm,
Number regularization_size,
Number alpha_du, Number alpha_pr,
Index ls_trials,
const IpoptData* ip_data,
IpoptCalculatedQuantities* ip_cq)
{
return true;
}
//@}
/** Routines to get the scaling parameters. These do not need to
* be overloaded unless the options are set for User scaling
*/
//@{
virtual void GetScalingParameters(
const SmartPtr<const VectorSpace> x_space,
const SmartPtr<const VectorSpace> c_space,
const SmartPtr<const VectorSpace> d_space,
Number& obj_scaling,
SmartPtr<Vector>& x_scaling,
SmartPtr<Vector>& c_scaling,
SmartPtr<Vector>& d_scaling) const
{
THROW_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED,
"You have set options for user provided scaling, but have"
" not implemented GetScalingParameters in the NLP interface");
}
//@}
/** Method for obtaining the subspace in which the limited-memory
* Hessian approximation should be done. This is only called if
* the limited-memory Hessian approximation is chosen. Since the
* Hessian is zero in the space of all variables that appear in
* the problem functions only linearly, this allows the user to
* provide a VectorSpace for all nonlinear variables, and an
* ExpansionMatrix to lift from this VectorSpace to the
* VectorSpace of the primal variables x. If the returned values
* are NULL, it is assumed that the Hessian is to be approximated
* in the space of all x variables. The default instantiation of
* this method returns NULL, and a user only has to overwrite
* this method if the approximation is to be done only in a
* subspace. */
virtual void
GetQuasiNewtonApproximationSpaces(SmartPtr<VectorSpace>& approx_space,
SmartPtr<Matrix>& P_approx)
{
approx_space = NULL;
P_approx = NULL;
}
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 */
NLP(const NLP&);
/** Overloaded Equals Operator */
void operator=(const NLP&);
//@}
};
} // namespace Ipopt
#endif
|
