ROL
ROL_InteriorPointStep.hpp
Go to the documentation of this file.
1// @HEADER
2// ************************************************************************
3//
4// Rapid Optimization Library (ROL) Package
5// Copyright (2014) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact lead developers:
38// Drew Kouri (dpkouri@sandia.gov) and
39// Denis Ridzal (dridzal@sandia.gov)
40//
41// ************************************************************************
42// @HEADER
43
44#ifndef ROL_INTERIORPOINTSTEP_H
45#define ROL_INTERIORPOINTSTEP_H
46
47#include "ROL_CompositeStep.hpp"
49#include "ROL_FletcherStep.hpp"
50#include "ROL_BundleStep.hpp"
55#include "ROL_InteriorPoint.hpp"
57#include "ROL_Types.hpp"
59
60
61namespace ROL {
62
63template<class Real>
64class AugmentedLagrangianStep;
65
66template <class Real>
67class InteriorPointStep : public Step<Real> {
68
71
72private:
73
74 ROL::Ptr<StatusTest<Real> > status_;
75 ROL::Ptr<Step<Real> > step_;
76 ROL::Ptr<Algorithm<Real> > algo_;
77 ROL::Ptr<BoundConstraint<Real> > bnd_;
78 ROL::ParameterList parlist_;
79
80 // Storage
81 ROL::Ptr<Vector<Real> > x_;
82 ROL::Ptr<Vector<Real> > g_;
83 ROL::Ptr<Vector<Real> > l_;
84 ROL::Ptr<Vector<Real> > c_;
85
86 Real mu_; // Barrier parameter
87 Real mumin_; // Minimal value of barrier parameter
88 Real mumax_; // Maximal value of barrier parameter
89 Real rho_; // Barrier parameter reduction factor
90
91 // For the subproblem
92 int subproblemIter_; // Status test maximum number of iterations
93
94 int verbosity_; // Adjust level of detail in printing step information
95 bool print_;
96
98
100 std::string stepname_;
101
102public:
103
104 using Step<Real>::initialize;
105 using Step<Real>::compute;
106 using Step<Real>::update;
107
109
110 InteriorPointStep(ROL::ParameterList &parlist) :
111 Step<Real>(),
112 status_(ROL::nullPtr),
113 step_(ROL::nullPtr),
114 algo_(ROL::nullPtr),
115 parlist_(parlist),
116 x_(ROL::nullPtr),
117 g_(ROL::nullPtr),
118 l_(ROL::nullPtr),
119 c_(ROL::nullPtr),
120 hasEquality_(false),
122 stepname_("Composite Step") {
123
124 using ROL::ParameterList;
125
126 verbosity_ = parlist.sublist("General").get("Print Verbosity",0);
127
128 // List of general Interior Point parameters
129 ParameterList& iplist = parlist.sublist("Step").sublist("Interior Point");
130 mu_ = iplist.get("Initial Barrier Penalty",1.0);
131 mumin_ = iplist.get("Minimum Barrier Penalty",1.e-4);
132 mumax_ = iplist.get("Maximum Barrier Penalty",1e8);
133 rho_ = iplist.get("Barrier Penalty Reduction Factor",0.5);
134
135 // Subproblem step information
136 print_ = iplist.sublist("Subproblem").get("Print History",false);
137 Real gtol = iplist.sublist("Subproblem").get("Optimality Tolerance",1e-8);
138 Real ctol = iplist.sublist("Subproblem").get("Feasibility Tolerance",1e-8);
139 Real stol = static_cast<Real>(1e-6)*std::min(gtol,ctol);
140 int maxit = iplist.sublist("Subproblem").get("Iteration Limit",1000);
141 parlist_.sublist("Status Test").set("Gradient Tolerance", gtol);
142 parlist_.sublist("Status Test").set("Constraint Tolerance", ctol);
143 parlist_.sublist("Status Test").set("Step Tolerance", stol);
144 parlist_.sublist("Status Test").set("Iteration Limit", maxit);
145 // Get step name from parameterlist
146 stepname_ = iplist.sublist("Subproblem").get("Step Type","Composite Step");
148 }
149
153 Vector<Real> &l, const Vector<Real> &c,
155 AlgorithmState<Real> &algo_state ) {
156 hasEquality_ = true;
157
158 ROL::Ptr<StepState<Real> > state = Step<Real>::getState();
159 state->descentVec = x.clone();
160 state->gradientVec = g.clone();
161 state->constraintVec = c.clone();
162
163 // Initialize storage
164 x_ = x.clone();
165 g_ = g.clone();
166 l_ = l.clone();
167 c_ = c.clone();
168
169 x_->set(x);
170
171 auto& ipobj = dynamic_cast<IPOBJ&>(obj);
172 auto& ipcon = dynamic_cast<IPCON&>(con);
173
174 // Set initial penalty
175 ipobj.updatePenalty(mu_);
176
177 algo_state.nfval = 0;
178 algo_state.ncval = 0;
179 algo_state.ngrad = 0;
180
181 Real zerotol = 0.0;
182 obj.update(x,true,algo_state.iter);
183 algo_state.value = obj.value(x,zerotol);
184
185 obj.gradient(*g_,x,zerotol);
186 algo_state.gnorm = g_->norm();
187
188 con.value(*c_,x,zerotol);
189 algo_state.cnorm = c_->norm();
190
191 algo_state.nfval += ipobj.getNumberFunctionEvaluations();
192 algo_state.ngrad += ipobj.getNumberGradientEvaluations();
193 algo_state.ncval += ipcon.getNumberConstraintEvaluations();
194
195 }
196
197
198
201 AlgorithmState<Real> &algo_state ) {
202 bnd.projectInterior(x);
203 initialize(x,g,l,c,obj,con,algo_state);
204 }
205
206
211 AlgorithmState<Real> &algo_state ) {
212 bnd.projectInterior(x);
213
214 ROL::Ptr<StepState<Real> > state = Step<Real>::getState();
215 state->descentVec = x.clone();
216 state->gradientVec = g.clone();
217
218 // Initialize storage
219 x_ = x.clone(); x_->set(x);
220 g_ = g.clone();
221
222 // Set initial penalty
223 auto& ipobj = dynamic_cast<IPOBJ&>(obj);
224 ipobj.updatePenalty(mu_);
225
226 algo_state.nfval = 0;
227 algo_state.ncval = 0;
228 algo_state.ngrad = 0;
229
230 Real zerotol = std::sqrt(ROL_EPSILON<Real>());
231 obj.update(x,true,algo_state.iter);
232 algo_state.value = obj.value(x,zerotol);
233
234 obj.gradient(*g_,x,zerotol);
235 algo_state.gnorm = g_->norm();
236
237 algo_state.cnorm = static_cast<Real>(0);
238
239 algo_state.nfval += ipobj.getNumberFunctionEvaluations();
240 algo_state.ngrad += ipobj.getNumberGradientEvaluations();
241
242 bnd_ = ROL::makePtr<BoundConstraint<Real>>();
243 bnd_->deactivate();
244 }
245
246
247
251 const Vector<Real> &x,
252 const Vector<Real> &l,
253 Objective<Real> &obj,
254 Constraint<Real> &con,
255 AlgorithmState<Real> &algo_state ) {
256 // Grab interior point objective and constraint
257 //auto& ipobj = dynamic_cast<IPOBJ&>(obj);
258 //auto& ipcon = dynamic_cast<IPCON&>(con);
259
260 Real one(1);
261 // Create the algorithm
262 Ptr<Objective<Real>> penObj;
264 Ptr<Objective<Real>> raw_obj = makePtrFromRef(obj);
265 Ptr<Constraint<Real>> raw_con = makePtrFromRef(con);
266 Ptr<StepState<Real>> state = Step<Real>::getState();
267 penObj = makePtr<AugmentedLagrangian<Real>>(raw_obj,raw_con,l,one,x,*(state->constraintVec),parlist_);
268 step_ = makePtr<AugmentedLagrangianStep<Real>>(parlist_);
269 }
270 else if (stepType_ == STEP_FLETCHER) {
271 Ptr<Objective<Real>> raw_obj = makePtrFromRef(obj);
272 Ptr<Constraint<Real>> raw_con = makePtrFromRef(con);
273 Ptr<StepState<Real>> state = Step<Real>::getState();
274 penObj = makePtr<Fletcher<Real>>(raw_obj,raw_con,x,*(state->constraintVec),parlist_);
275 step_ = makePtr<FletcherStep<Real>>(parlist_);
276 }
277 else {
278 penObj = makePtrFromRef(obj);
279 stepname_ = "Composite Step";
281 step_ = makePtr<CompositeStep<Real>>(parlist_);
282 }
283 status_ = makePtr<ConstraintStatusTest<Real>>(parlist_);
284 algo_ = ROL::makePtr<Algorithm<Real>>(step_,status_,false);
285
286 // Run the algorithm
287 x_->set(x); l_->set(l);
288 algo_->run(*x_,*g_,*l_,*c_,*penObj,con,print_);
289 s.set(*x_); s.axpy(-one,x);
290
291 // Get number of iterations from the subproblem solve
292 subproblemIter_ = (algo_->getState())->iter;
293 }
294
296 const Vector<Real> &x,
297 const Vector<Real> &l,
298 Objective<Real> &obj,
299 Constraint<Real> &con,
301 AlgorithmState<Real> &algo_state ) {
302 compute(s,x,l,obj,con,algo_state);
303 }
304
305 // Bound constrained
307 const Vector<Real> &x,
308 Objective<Real> &obj,
310 AlgorithmState<Real> &algo_state ) {
311 // Grab interior point objective and constraint
312 auto& ipobj = dynamic_cast<IPOBJ&>(obj);
313
314 // Create the algorithm
315 if (stepType_ == STEP_BUNDLE) {
316 status_ = makePtr<BundleStatusTest<Real>>(parlist_);
317 step_ = makePtr<BundleStep<Real>>(parlist_);
318 }
319 else if (stepType_ == STEP_LINESEARCH) {
320 status_ = makePtr<StatusTest<Real>>(parlist_);
321 step_ = makePtr<LineSearchStep<Real>>(parlist_);
322 }
323 else {
324 status_ = makePtr<StatusTest<Real>>(parlist_);
325 step_ = makePtr<TrustRegionStep<Real>>(parlist_);
326 }
327 algo_ = ROL::makePtr<Algorithm<Real>>(step_,status_,false);
328
329 // Run the algorithm
330 x_->set(x);
331 algo_->run(*x_,*g_,ipobj,*bnd_,print_);
332 s.set(*x_); s.axpy(static_cast<Real>(-1),x);
333
334 // Get number of iterations from the subproblem solve
335 subproblemIter_ = (algo_->getState())->iter;
336 }
337
338
339
343 Vector<Real> &l,
344 const Vector<Real> &s,
345 Objective<Real> &obj,
346 Constraint<Real> &con,
347 AlgorithmState<Real> &algo_state ) {
348 // Grab interior point objective and constraint
349 auto& ipobj = dynamic_cast<IPOBJ&>(obj);
350 auto& ipcon = dynamic_cast<IPCON&>(con);
351
352 // If we can change the barrier parameter, do so
353 if( (rho_< 1.0 && mu_ > mumin_) || (rho_ > 1.0 && mu_ < mumax_) ) {
354 mu_ *= rho_;
355 ipobj.updatePenalty(mu_);
356 }
357
358 ROL::Ptr<StepState<Real> > state = Step<Real>::getState();
359 state->SPiter = subproblemIter_;
360
361 // Update optimization vector
362 x.plus(s);
363
364 algo_state.iterateVec->set(x);
365 state->descentVec->set(s);
366 algo_state.snorm = s.norm();
367 algo_state.iter++;
368
369 Real zerotol = 0.0;
370
371 algo_state.value = ipobj.value(x,zerotol);
372 algo_state.value = ipobj.getObjectiveValue();
373
374 ipcon.value(*c_,x,zerotol);
375 state->constraintVec->set(*c_);
376
377 ipobj.gradient(*g_,x,zerotol);
378 state->gradientVec->set(*g_);
379
380 ipcon.applyAdjointJacobian(*g_,*l_,x,zerotol);
381 state->gradientVec->plus(*g_);
382
383 algo_state.gnorm = g_->norm();
384 algo_state.cnorm = state->constraintVec->norm();
385 algo_state.snorm = s.norm();
386
387 algo_state.nfval += ipobj.getNumberFunctionEvaluations();
388 algo_state.ngrad += ipobj.getNumberGradientEvaluations();
389 algo_state.ncval += ipcon.getNumberConstraintEvaluations();
390
391 }
392
394 Vector<Real> &l,
395 const Vector<Real> &s,
396 Objective<Real> &obj,
397 Constraint<Real> &con,
399 AlgorithmState<Real> &algo_state ) {
400 update(x,l,s,obj,con,algo_state);
401
402 ROL::Ptr<StepState<Real> > state = Step<Real>::getState();
403 x_->set(x);
404 x_->axpy(static_cast<Real>(-1),state->gradientVec->dual());
405 bnd.project(*x_);
406 x_->axpy(static_cast<Real>(-1),x);
407 algo_state.gnorm = x_->norm();
408 }
409
411 const Vector<Real> &s,
412 Objective<Real> &obj,
414 AlgorithmState<Real> &algo_state ) {
415 // Grab interior point objective
416 auto& ipobj = dynamic_cast<IPOBJ&>(obj);
417
418 // If we can change the barrier parameter, do so
419 if( (rho_< 1.0 && mu_ > mumin_) || (rho_ > 1.0 && mu_ < mumax_) ) {
420 mu_ *= rho_;
421 ipobj.updatePenalty(mu_);
422 }
423
424 ROL::Ptr<StepState<Real> > state = Step<Real>::getState();
425
426 // Update optimization vector
427 x.plus(s);
428
429 algo_state.iterateVec->set(x);
430 state->descentVec->set(s);
431 algo_state.snorm = s.norm();
432 algo_state.iter++;
433
434 Real zerotol = std::sqrt(ROL_EPSILON<Real>());
435
436 algo_state.value = ipobj.value(x,zerotol);
437 algo_state.value = ipobj.getObjectiveValue();
438
439 ipobj.gradient(*g_,x,zerotol);
440 state->gradientVec->set(*g_);
441
442 x_->set(x);
443 x_->axpy(static_cast<Real>(-1),state->gradientVec->dual());
444 bnd.project(*x_);
445 x_->axpy(static_cast<Real>(-1),x);
446
447 algo_state.gnorm = x_->norm();
448 algo_state.snorm = s.norm();
449
450 algo_state.nfval += ipobj.getNumberFunctionEvaluations();
451 algo_state.ngrad += ipobj.getNumberGradientEvaluations();
452 }
453
456 std::string printHeader( void ) const {
457 std::stringstream hist;
458
459 if( verbosity_ > 0 ) {
460
461 hist << std::string(116,'-') << "\n";
462 hist << "Interior Point status output definitions\n\n";
463
464 hist << " IPiter - Number of interior point steps taken\n";
465 hist << " SPiter - Number of subproblem solver iterations\n";
466 hist << " penalty - Penalty parameter multiplying the barrier objective\n";
467 hist << " fval - Number of objective evaluations\n";
468 if (hasEquality_) {
469 hist << " cnorm - Norm of the composite constraint\n";
470 hist << " gLnorm - Norm of the Lagrangian's gradient\n";
471 }
472 else {
473 hist << " gnorm - Norm of the projected norm of the objective gradient\n";
474 }
475 hist << " snorm - Norm of step (update to optimzation and slack vector)\n";
476 hist << " #fval - Number of objective function evaluations\n";
477 hist << " #grad - Number of gradient evaluations\n";
478 if (hasEquality_) {
479 hist << " #cval - Number of composite constraint evaluations\n";
480 }
481 hist << std::string(116,'-') << "\n";
482 }
483
484 hist << " ";
485 hist << std::setw(9) << std::left << "IPiter";
486 hist << std::setw(9) << std::left << "SPiter";
487 hist << std::setw(15) << std::left << "penalty";
488 hist << std::setw(15) << std::left << "fval";
489 if (hasEquality_) {
490 hist << std::setw(15) << std::left << "cnorm";
491 hist << std::setw(15) << std::left << "gLnorm";
492 }
493 else {
494 hist << std::setw(15) << std::left << "gnorm";
495 }
496 hist << std::setw(15) << std::left << "snorm";
497 hist << std::setw(8) << std::left << "#fval";
498 hist << std::setw(8) << std::left << "#grad";
499 if (hasEquality_) {
500 hist << std::setw(8) << std::left << "#cval";
501 }
502
503 hist << "\n";
504 return hist.str();
505 }
506
509 std::string printName( void ) const {
510 std::stringstream hist;
511 hist << "\n" << "Primal Interior Point Solver\n";
512 return hist.str();
513 }
514
517 std::string print( AlgorithmState<Real> &algo_state, bool pHeader = false ) const {
518 std::stringstream hist;
519 hist << std::scientific << std::setprecision(6);
520 if ( algo_state.iter == 0 ) {
521 hist << printName();
522 }
523 if ( pHeader ) {
524 hist << printHeader();
525 }
526 if ( algo_state.iter == 0 ) {
527 hist << " ";
528 hist << std::setw(9) << std::left << algo_state.iter;
529 hist << std::setw(9) << std::left << subproblemIter_;
530 hist << std::setw(15) << std::left << mu_;
531 hist << std::setw(15) << std::left << algo_state.value;
532 if (hasEquality_) {
533 hist << std::setw(15) << std::left << algo_state.cnorm;
534 }
535 hist << std::setw(15) << std::left << algo_state.gnorm;
536 hist << "\n";
537 }
538 else {
539 hist << " ";
540 hist << std::setw(9) << std::left << algo_state.iter;
541 hist << std::setw(9) << std::left << subproblemIter_;
542 hist << std::setw(15) << std::left << mu_;
543 hist << std::setw(15) << std::left << algo_state.value;
544 if (hasEquality_) {
545 hist << std::setw(15) << std::left << algo_state.cnorm;
546 }
547 hist << std::setw(15) << std::left << algo_state.gnorm;
548 hist << std::setw(15) << std::left << algo_state.snorm;
549// hist << std::scientific << std::setprecision(6);
550 hist << std::setw(8) << std::left << algo_state.nfval;
551 hist << std::setw(8) << std::left << algo_state.ngrad;
552 if (hasEquality_) {
553 hist << std::setw(8) << std::left << algo_state.ncval;
554 }
555 hist << "\n";
556 }
557 return hist.str();
558 }
559
560}; // class InteriorPointStep
561
562} // namespace ROL
563
564#endif // ROL_INTERIORPOINTSTEP_H
Contains definitions of custom data types in ROL.
Provides the interface to apply upper and lower bound constraints.
virtual void projectInterior(Vector< Real > &x)
Project optimization variables into the interior of the feasible set.
virtual void project(Vector< Real > &x)
Project optimization variables onto the bounds.
Has both inequality and equality constraints. Treat inequality constraint as equality with slack vari...
Defines the general constraint operator interface.
virtual void value(Vector< Real > &c, const Vector< Real > &x, Real &tol)=0
Evaluate the constraint operator at .
ROL::Ptr< StatusTest< Real > > status_
ROL::Ptr< BoundConstraint< Real > > bnd_
ROL::Ptr< Step< Real > > step_
void initialize(Vector< Real > &x, const Vector< Real > &g, Objective< Real > &obj, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Initialize step with no equality constraint.
std::string print(AlgorithmState< Real > &algo_state, bool pHeader=false) const
Print iterate status.
void compute(Vector< Real > &s, const Vector< Real > &x, const Vector< Real > &l, Objective< Real > &obj, Constraint< Real > &con, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Compute step (equality constraints).
void update(Vector< Real > &x, const Vector< Real > &s, Objective< Real > &obj, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Update step, if successful.
Constraint_Partitioned< Real > IPCON
InteriorPoint::PenalizedObjective< Real > IPOBJ
ROL::Ptr< Vector< Real > > c_
std::string printName(void) const
Print step name.
void compute(Vector< Real > &s, const Vector< Real > &x, Objective< Real > &obj, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Compute step.
void initialize(Vector< Real > &x, const Vector< Real > &g, Vector< Real > &l, const Vector< Real > &c, Objective< Real > &obj, Constraint< Real > &con, AlgorithmState< Real > &algo_state)
Initialize step with equality constraint.
InteriorPointStep(ROL::ParameterList &parlist)
std::string printHeader(void) const
Print iterate header.
ROL::Ptr< Vector< Real > > g_
ROL::Ptr< Vector< Real > > x_
void initialize(Vector< Real > &x, const Vector< Real > &g, Vector< Real > &l, const Vector< Real > &c, Objective< Real > &obj, Constraint< Real > &con, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Initialize step with equality constraint.
void update(Vector< Real > &x, Vector< Real > &l, const Vector< Real > &s, Objective< Real > &obj, Constraint< Real > &con, BoundConstraint< Real > &bnd, AlgorithmState< Real > &algo_state)
Update step, if successful (equality constraints).
ROL::Ptr< Vector< Real > > l_
void update(Vector< Real > &x, Vector< Real > &l, const Vector< Real > &s, Objective< Real > &obj, Constraint< Real > &con, AlgorithmState< Real > &algo_state)
Update step, if successful (equality constraints).
void compute(Vector< Real > &s, const Vector< Real > &x, const Vector< Real > &l, Objective< Real > &obj, Constraint< Real > &con, AlgorithmState< Real > &algo_state)
Compute step (equality constraints).
ROL::Ptr< Algorithm< Real > > algo_
Provides the interface to evaluate objective functions.
virtual void gradient(Vector< Real > &g, const Vector< Real > &x, Real &tol)
Compute gradient.
virtual Real value(const Vector< Real > &x, Real &tol)=0
Compute value.
virtual void update(const Vector< Real > &x, UpdateType type, int iter=-1)
Update objective function.
Provides the interface to compute optimization steps.
Definition: ROL_Step.hpp:68
ROL::Ptr< StepState< Real > > getState(void)
Definition: ROL_Step.hpp:73
Defines the linear algebra or vector space interface.
Definition: ROL_Vector.hpp:84
virtual Real norm() const =0
Returns where .
virtual void set(const Vector &x)
Set where .
Definition: ROL_Vector.hpp:209
virtual void plus(const Vector &x)=0
Compute , where .
virtual ROL::Ptr< Vector > clone() const =0
Clone to make a new (uninitialized) vector.
virtual void axpy(const Real alpha, const Vector &x)
Compute where .
Definition: ROL_Vector.hpp:153
@ STEP_BUNDLE
Definition: ROL_Types.hpp:278
@ STEP_AUGMENTEDLAGRANGIAN
Definition: ROL_Types.hpp:277
@ STEP_LINESEARCH
Definition: ROL_Types.hpp:280
@ STEP_COMPOSITESTEP
Definition: ROL_Types.hpp:279
@ STEP_FLETCHER
Definition: ROL_Types.hpp:285
EStep StringToEStep(std::string s)
Definition: ROL_Types.hpp:391
State for algorithm class. Will be used for restarts.
Definition: ROL_Types.hpp:143
ROL::Ptr< Vector< Real > > iterateVec
Definition: ROL_Types.hpp:157