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
244
245
246
247
248
249
// Copyright (C) 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors: Andreas Waechter IBM 2008-04-04
// derived file from IpFilterLSAcceptor.hpp
#ifndef __IPPENALTYLSACCEPTOR_HPP__
#define __IPPENALTYLSACCEPTOR_HPP__
#include "IpBacktrackingLSAcceptor.hpp"
#include "IpPDSystemSolver.hpp"
namespace Ipopt
{
/** Penalty function line search.
*
* This class implements the penalty function line search
* procedure as proposed by Waltz, Morales, Nocedal, Orban.
*/
class PenaltyLSAcceptor: public BacktrackingLSAcceptor
{
public:
/**@name Constructors/Destructors */
///@{
/** Constructor.
*
* The PDSystemSolver object only needs to be provided
* (i.e. not NULL) if second order correction or corrector
* steps are to be used.
*/
PenaltyLSAcceptor(
const SmartPtr<PDSystemSolver>& pd_solver
);
/** Destructor */
virtual ~PenaltyLSAcceptor();
///@}
virtual bool InitializeImpl(
const OptionsList& options,
const std::string& prefix
);
/** Reset the acceptor.
*
* This function should be called if all previous information
* should be discarded when the line search is performed the
* next time. For example, this method should be called if
* the barrier parameter is changed.
*/
virtual void Reset();
/** Initialization for the next line search.
*
* The flag in_watchdog indicates if we are currently in an
* active watchdog procedure.
*/
virtual void InitThisLineSearch(
bool in_watchdog
);
/** Method that is called before the restoration phase is called.
*
* Here, we can set up things that are required in the
* termination test for the restoration phase.
*/
virtual void PrepareRestoPhaseStart();
/** Method returning the lower bound on the trial step sizes. */
virtual Number CalculateAlphaMin();
/** Method for checking if current trial point is acceptable.
*
* It is assumed that the delta information in ip_data is the
* search direction used in criteria. The primal trial point has
* to be set before the call.
*/
virtual bool CheckAcceptabilityOfTrialPoint(
Number alpha_primal);
/** Try a second order correction for the constraints.
*
* If the first trial step (with incoming alpha_primal) has been
* rejected, this tries up to max_soc_ second order corrections for
* the constraints. Here, alpha_primal_test is the step size that
* has to be used in the penalty function acceptance tests. On
* output actual_delta_ has been set to the step including the
* second order correction if it has been accepted, otherwise it
* is unchanged. If the SOC step has been accepted, alpha_primal
* has the fraction-to-the-boundary value for the SOC step on
* output. The return value is true, if a SOC step has been
* accepted.
*/
virtual bool TrySecondOrderCorrection(
Number alpha_primal_test,
Number& alpha_primal,
SmartPtr<IteratesVector>& actual_delta
);
/** Try higher order corrector (for fast local convergence).
*
* In contrast to a second order correction step, which tries to
* make an unacceptable point acceptable by improving constraint
* violation, this corrector step is tried even if the regular
* primal-dual step is acceptable.
*/
virtual bool TryCorrector(
Number alpha_primal_test,
Number& alpha_primal,
SmartPtr<IteratesVector>& actual_delta
);
/** Method for ending the current line search.
*
* When it is called, the internal data should be updates.
*
* @param alpha_primal_test value of alpha that has been used for in the acceptence test ealier
*/
virtual char UpdateForNextIteration(
Number alpha_primal_test
);
/** Method for setting internal data if the watchdog procedure is started. */
virtual void StartWatchDog();
/** Method for setting internal data if the watchdog procedure is stopped. */
virtual void StopWatchDog();
/**@name Trial Point Accepting Methods.
*
* Used internally to check certain
* acceptability criteria and used externally (by the restoration phase
* convergence check object, for instance).
*/
///@{
/** Checks if a trial point is acceptable to the current iterate */
bool IsAcceptableToCurrentIterate(
Number trial_barr,
Number trial_theta,
bool called_from_restoration = false
) const;
///@}
/** 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.
*/
///@{
/** Copy Constructor */
PenaltyLSAcceptor(
const PenaltyLSAcceptor&
);
/** Overloaded Assignment Operator */
void operator=(
const PenaltyLSAcceptor&
);
///@}
/** Compute predicted reduction for given step size */
Number CalcPred(
Number alpha
);
/** @name Parameters for the penalty function line search
* algorithm. Names as in the filter paper */
///@{
/** Initial value of penalty parameter */
Number nu_init_;
/** Incrememt for penalty parameter */
Number nu_inc_;
/** \f$ \eta_{\varphi} \f$ */
Number eta_;
/** \f$ \rho \f$ */
Number rho_;
/** Maximal number of second order correction steps */
Index max_soc_;
/** Required reduction in constraint violation before trying
* multiple second order correction steps \f$ \kappa_{soc}\f$.
*/
Number kappa_soc_;
/** Second method correction method */
Index soc_method_;
///@}
/** @name Information related to watchdog procedure */
///@{
/** Constraint violation at the point with respect to which
* progress is to be made */
Number reference_theta_;
/** Barrier objective function at the point with respect to which
* progress is to be made */
Number reference_barr_;
/** Barrier gradient transpose search direction at the point with
* respect to which progress is to be made */
Number reference_gradBarrTDelta_;
/** Two-sided product of search direction with complete Hessian */
Number reference_dWd_;
/** Product of Jacobian of equality constraint with x direction */
SmartPtr<const Vector> reference_JacC_delta_;
/** Product of Jacobian of (d-s) constraint with search direction */
SmartPtr<const Vector> reference_JacD_delta_;
/** Reference predicted reduction. If positive, then it is used
* in watch dog. */
Number reference_pred_;
/** Constraint violation at reference point */
Number watchdog_theta_;
/** Barrier objective function at reference point */
Number watchdog_barr_;
/** Predicted reduction to be compared with in watch dog. */
Number watchdog_pred_;
///@}
/** @name Penalty parameter */
///@{
/** Current value of the penalty parameter */
Number nu_;
/** Value of penalty parameter at beginning of the iteration. */
Number last_nu_;
///@}
/** When called from the restoration phase, this is the required
* predicted reduction */
Number resto_pred_;
/** @name Strategy objective that are used */
///@{
SmartPtr<PDSystemSolver> pd_solver_;
///@}
};
} // namespace Ipopt
#endif