Ipopt Documentation  
IpRestoIpoptNLP.hpp
Go to the documentation of this file.
1 // Copyright (C) 2004, 2006 International Business Machines and others.
2 // All Rights Reserved.
3 // This code is published under the Eclipse Public License.
4 //
5 // Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
6 
7 #ifndef __IPRESTOIPOPTNLP_HPP__
8 #define __IPRESTOIPOPTNLP_HPP__
9 
10 #include "IpIpoptNLP.hpp"
11 #include "IpIpoptData.hpp"
13 #include "IpCompoundMatrix.hpp"
14 #include "IpCompoundSymMatrix.hpp"
15 #include "IpCompoundVector.hpp"
16 #include "IpIdentityMatrix.hpp"
17 #include "IpDiagMatrix.hpp"
18 #include "IpZeroMatrix.hpp"
19 #include "IpOrigIpoptNLP.hpp"
20 
21 namespace Ipopt
22 {
23 
31 class RestoIpoptNLP: public IpoptNLP
32 {
33 public:
37  IpoptNLP& orig_ip_nlp,
38  IpoptData& orig_ip_data,
39  IpoptCalculatedQuantities& orig_ip_cq
40  );
41 
45 
46  virtual bool Initialize(
47  const Journalist& jnlst,
48  const OptionsList& options,
49  const std::string& prefix
50  );
51 
53  virtual bool InitializeStructures(
55  bool init_x,
56  SmartPtr<Vector>& y_c,
57  bool init_y_c,
58  SmartPtr<Vector>& y_d,
59  bool init_y_d,
60  SmartPtr<Vector>& z_L,
61  bool init_z_L,
62  SmartPtr<Vector>& z_U,
63  bool init_z_U,
64  SmartPtr<Vector>& v_L,
65  SmartPtr<Vector>& v_U);
66 
68  virtual bool GetWarmStartIterate(
69  IteratesVector& /*warm_start_iterate*/
70  )
71  {
72  return false;
73  }
74 
76  SolverReturn /*status*/,
77  const Vector& /*x*/,
78  const Vector& /*z_L*/,
79  const Vector& /*z_U*/,
80  const Vector& /*c*/,
81  const Vector& /*d*/,
82  const Vector& /*y_c*/,
83  const Vector& /*y_d*/,
84  Number /*obj_value*/,
85  const IpoptData* /*ip_data*/,
86  IpoptCalculatedQuantities* /*ip_cq*/
87  )
88  { }
89 
91 
96  virtual bool objective_depends_on_mu() const
97  {
98  return true;
99  }
100 
102  virtual Number f(
103  const Vector& x
104  );
105 
107  virtual Number f(
108  const Vector& x,
109  Number mu
110  );
111 
114  const Vector& x
115  );
116 
119  const Vector& x,
120  Number mu
121  );
122 
124  virtual SmartPtr<const Vector> c(
125  const Vector& x
126  );
127 
130  const Vector& x
131  );
132 
135  virtual SmartPtr<const Vector> d(
136  const Vector& x
137  );
138 
141  const Vector& x
142  );
143 
146  const Vector& x,
147  Number obj_factor,
148  const Vector& yc,
149  const Vector& yd
150  );
151 
154  const Vector& x,
155  Number obj_factor,
156  const Vector& yc,
157  const Vector& yd,
158  Number mu
159  );
160 
167 
169  virtual SmartPtr<const Vector> x_L() const
170  {
171  return GetRawPtr(x_L_);
172  }
173 
175  virtual SmartPtr<const Matrix> Px_L() const
176  {
177  return GetRawPtr(Px_L_);
178  }
179 
181  virtual SmartPtr<const Vector> x_U() const
182  {
183  return GetRawPtr(x_U_);
184  }
185 
187  virtual SmartPtr<const Matrix> Px_U() const
188  {
189  return GetRawPtr(Px_U_);
190  }
191 
193  virtual SmartPtr<const Vector> d_L() const
194  {
195  return GetRawPtr(d_L_);
196  }
197 
199  virtual SmartPtr<const Matrix> Pd_L() const
200  {
201  return GetRawPtr(Pd_L_);
202  }
203 
205  virtual SmartPtr<const Vector> d_U() const
206  {
207  return GetRawPtr(d_U_);
208  }
209 
211  virtual SmartPtr<const Matrix> Pd_U() const
212  {
213  return GetRawPtr(Pd_U_);
214  }
215 
217  {
218  return GetRawPtr(h_space_);
219  }
220 
222  {
223  return GetRawPtr(x_space_);
224  }
226 
228  virtual void GetSpaces(
232  SmartPtr<const VectorSpace>& x_l_space,
233  SmartPtr<const MatrixSpace>& px_l_space,
234  SmartPtr<const VectorSpace>& x_u_space,
235  SmartPtr<const MatrixSpace>& px_u_space,
236  SmartPtr<const VectorSpace>& d_l_space,
237  SmartPtr<const MatrixSpace>& pd_l_space,
238  SmartPtr<const VectorSpace>& d_u_space,
239  SmartPtr<const MatrixSpace>& pd_u_space,
240  SmartPtr<const MatrixSpace>& Jac_c_space,
241  SmartPtr<const MatrixSpace>& Jac_d_space,
242  SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space);
243 
248  virtual void AdjustVariableBounds(
249  const Vector& new_x_L,
250  const Vector& new_x_U,
251  const Vector& new_d_L,
252  const Vector& new_d_U
253  );
254 
257  AlgorithmMode mode,
258  Index iter,
259  Number obj_value,
260  Number inf_pr,
261  Number inf_du,
262  Number mu,
263  Number d_norm,
264  Number regularization_size,
265  Number alpha_du,
266  Number alpha_pr,
267  Index ls_trials,
270  );
271 
275  IpoptNLP& OrigIpNLP() const
277  {
278  return *orig_ip_nlp_;
279  }
280 
282  {
283  return *orig_ip_data_;
284  }
285 
287  {
288  return *orig_ip_cq_;
289  }
291 
295  Number Rho() const
296  {
297  return rho_;
298  }
299 
301  virtual Index f_evals() const
303  {
304  return f_evals_;
305  }
306  virtual Index grad_f_evals() const
307  {
308  return grad_f_evals_;
309  }
310  virtual Index c_evals() const
311  {
312  return c_evals_;
313  }
314  virtual Index jac_c_evals() const
315  {
316  return jac_c_evals_;
317  }
318  virtual Index d_evals() const
319  {
320  return d_evals_;
321  }
322  virtual Index jac_d_evals() const
323  {
324  return jac_d_evals_;
325  }
326  virtual Index h_evals() const
327  {
328  return h_evals_;
329  }
331 
333  Number Eta(
334  Number mu
335  ) const;
336 
341  {
342  return ConstPtr(dr_x_);
343  }
344 
345  static void RegisterOptions(
347  );
348 
349 private:
351 
354 
357 
361 
365 
367 
369 
371 
373 
375 
377 
379 
381 
383 
385 
387 
389 
392 
394 
397 
400 
403 
406 
409 
412 
415 
419 
421 
426 
429 
432 
433  // TODO in the following we should use pointers to CONST values
434  // TODO We can get rid of one of the dr DR
438 
442 
451 
453  RestoIpoptNLP();
454 
457  const RestoIpoptNLP&
458  );
459 
461  void operator=(
462  const RestoIpoptNLP&
463  );
465 
467 
473 
477 
480 
482  Index f_evals_;
491 };
492 
493 } // namespace Ipopt
494 
495 #endif
virtual SmartPtr< const Vector > d_L() const
Lower bounds on d.
SmartPtr< CompoundMatrixSpace > pd_l_space_
Number Eta(Number mu) const
Method to calculate eta, the factor for the regularization term.
void operator=(const RestoIpoptNLP &)
Default Assignment Operator.
SmartPtr< CompoundVectorSpace > x_l_space_
virtual void AdjustVariableBounds(const Vector &new_x_L, const Vector &new_x_U, const Vector &new_d_L, const Vector &new_d_U)
Method for adapting the variable bounds.
Specialized CompoundVector class specifically for the algorithm iterates.
Class for all IPOPT specific calculated quantities.
SmartPtr< CompoundVector > x_U_
Upper bounds on x.
SmartPtr< CompoundVectorSpace > c_space_
SmartPtr< CompoundMatrix > Px_U_
Permutation matrix (x_U_ -> x)
bool evaluate_orig_obj_at_resto_trial_
Flag indicating if evaluation of the objective should be performed for every restoration phase object...
SmartPtr< CompoundVectorSpace > d_u_space_
SmartPtr< CompoundVectorSpace > d_space_
virtual bool InitializeStructures(SmartPtr< Vector > &x, bool init_x, SmartPtr< Vector > &y_c, bool init_y_c, SmartPtr< Vector > &y_d, bool init_y_d, SmartPtr< Vector > &z_L, bool init_z_L, SmartPtr< Vector > &z_U, bool init_z_U, SmartPtr< Vector > &v_L, SmartPtr< Vector > &v_U)
Initialize (create) structures for the iteration data.
virtual SmartPtr< const Vector > d(const Vector &x)
Inequality constraint residual (reformulated as equalities with slacks.
SmartPtr< CompoundMatrixSpace > px_l_space_
IpoptNLP & OrigIpNLP() const
virtual bool GetWarmStartIterate(IteratesVector &)
Method accessing the GetWarmStartIterate of the NLP.
~RestoIpoptNLP()
Destructor.
SmartPtr< CompoundVector > x_L_
Lower bounds on x.
AlgorithmMode
enum to indicate the mode in which the algorithm is
virtual Index f_evals() const
SmartPtr< IpoptData > orig_ip_data_
Pointer to the original IpoptData.
double Number
Type of all numbers.
Definition: IpTypes.hpp:15
virtual SmartPtr< const Matrix > Px_U() const
Permutation matrix (x_U_ -> x.
Vector Base Class.
Definition: IpVector.hpp:47
SmartPtr< DiagMatrix > DR_x_
IpoptCalculatedQuantities & OrigIpCq() const
virtual Index d_evals() const
Number eta_factor_
scaling factor for eta calculation
virtual SmartPtr< const Vector > x_U() const
Upper bounds on x.
SmartPtr< CompoundMatrix > Pd_U_
Permutation matrix (d_U_ -> d.
virtual Index h_evals() const
Number eta_mu_exponent_
exponent for mu in eta calculation
SmartPtr< CompoundMatrix > Pd_L_
Permutation matrix (d_L_ -> d)
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, SmartPtr< const IpoptData > ip_data, SmartPtr< IpoptCalculatedQuantities > ip_cq)
User callback method.
SmartPtr< CompoundSymMatrixSpace > h_space_
virtual SmartPtr< const VectorSpace > x_space() const
x_space
This file contains a base class for all exceptions and a set of macros to help with exceptions...
virtual bool objective_depends_on_mu() const
Accessor methods for model data.
Template class for Smart Pointers.
Definition: IpSmartPtr.hpp:171
Number rho_
Penalty parameter for the $l_1$ norm.
SmartPtr< CompoundVectorSpace > x_u_space_
This class stores a list of user set options.
SolverReturn
enum for the return from the optimize algorithm
Definition: IpAlgTypes.hpp:19
virtual Index jac_c_evals() const
U * GetRawPtr(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:651
HessianApproximationType hessian_approximation_
Flag indicating how Hessian information is obtained.
SmartPtr< CompoundMatrixSpace > jac_c_space_
void FinalizeSolution(SolverReturn, const Vector &, const Vector &, const Vector &, const Vector &, const Vector &, const Vector &, const Vector &, Number, const IpoptData *, IpoptCalculatedQuantities *)
HessianApproximationType
enumeration for the Hessian information type.
SmartPtr< CompoundVector > d_U_
Upper bounds on d.
Number Rho() const
Accessor Method for obtaining the Rho penalization factor for the ell_1 norm.
SmartPtr< Vector > x_ref_
$x$ part of the reference point in the regularization term
Class to organize all the data required by the algorithm.
Definition: IpIpoptData.hpp:97
This class maps the traditional NLP into something that is more useful by Ipopt.
SmartPtr< IpoptNLP > orig_ip_nlp_
Pointer to the original IpoptNLP.
bool initialized_
Flag indicating if initialization method has been called.
static void RegisterOptions(SmartPtr< RegisteredOptions > roptions)
int Index
Type of all indices of vectors, matrices etc.
Definition: IpTypes.hpp:17
virtual void 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)
Accessor method for vector/matrix spaces pointers.
virtual Index c_evals() const
SmartPtr< IpoptCalculatedQuantities > orig_ip_cq_
Pointer to the original IpoptCalculatedQuantities.
virtual SmartPtr< const Vector > d_U() const
Upper bounds on d.
SmartPtr< const U > ConstPtr(const SmartPtr< U > &smart_ptr)
Definition: IpSmartPtr.hpp:665
virtual SmartPtr< const Matrix > Pd_U() const
Permutation matrix (d_U_ -> d.
virtual SmartPtr< const Vector > x_L() const
Lower bounds on x.
SmartPtr< CompoundVectorSpace > d_l_space_
IpoptData & OrigIpData() const
Class responsible for all message output.
virtual bool Initialize(const Journalist &jnlst, const OptionsList &options, const std::string &prefix)
Initialization method.
SmartPtr< CompoundMatrixSpace > px_u_space_
virtual Index grad_f_evals() const
SmartPtr< const Vector > DR_x() const
Method returning the scaling factors for the 2-norm penalization term.
virtual SmartPtr< const Matrix > Pd_L() const
Permutation matrix (d_L_ -> d)
virtual SmartPtr< const SymMatrix > uninitialized_h()
Provides a Hessian matrix from the correct matrix space with uninitialized values.
virtual Index jac_d_evals() const
virtual SmartPtr< const Matrix > jac_c(const Vector &x)
Jacobian Matrix for equality constraints.
SmartPtr< Vector > dr_x_
Scaling factors for the $x$ part of the regularization term.
This is the abstract base class for classes that map the traditional NLP into something that is more ...
Definition: IpIpoptNLP.hpp:27
virtual SmartPtr< const SymMatrix > h(const Vector &x, Number obj_factor, const Vector &yc, const Vector &yd)
Hessian of the Lagrangian (incorrect version for restoration phase)
virtual Number f(const Vector &x)
Objective value (incorrect version for restoration phase)
SmartPtr< CompoundMatrixSpace > jac_d_space_
virtual SmartPtr< const Vector > grad_f(const Vector &x)
Gradient of the objective (incorrect version for restoration phase)
virtual SmartPtr< const SymMatrixSpace > HessianMatrixSpace() const
Accessor method to obtain the MatrixSpace for the Hessian matrix (or it&#39;s approximation) ...
virtual SmartPtr< const Vector > c(const Vector &x)
Equality constraint residual.
RestoIpoptNLP()
Default Constructor.
SmartPtr< CompoundVectorSpace > x_space_
Necessary Vector/Matrix spaces.
virtual SmartPtr< const Matrix > jac_d(const Vector &x)
Jacobian Matrix for inequality constraints.
virtual SmartPtr< const Matrix > Px_L() const
Permutation matrix (x_L_ -> x)
SmartPtr< CompoundMatrix > Px_L_
Permutation matrix (x_L_ -> x)
SmartPtr< CompoundVector > d_L_
Lower bounds on d.
SmartPtr< CompoundMatrixSpace > pd_u_space_