ROL
ROL_GetTestProblems.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 
49 #ifndef ROL_TESTOBJECTIVES_HPP
50 #define ROL_TESTOBJECTIVES_HPP
51 
52 
53 #include "ROL_Rosenbrock.hpp"
54 #include "ROL_FreudensteinRoth.hpp"
55 #include "ROL_Beale.hpp"
56 #include "ROL_Powell.hpp"
57 #include "ROL_SumOfSquares.hpp"
58 #include "ROL_LeastSquares.hpp"
59 #include "ROL_PoissonControl.hpp"
60 #include "ROL_PoissonInversion.hpp"
61 #include "ROL_Zakharov.hpp"
62 #include "ROL_HS1.hpp"
63 #include "ROL_HS2.hpp"
64 #include "ROL_HS3.hpp"
65 #include "ROL_HS4.hpp"
66 #include "ROL_HS5.hpp"
67 #include "ROL_HS9.hpp"
68 #include "ROL_HS14.hpp"
69 #include "ROL_HS24.hpp"
70 #include "ROL_HS25.hpp"
71 #include "ROL_HS28.hpp"
72 #include "ROL_HS29.hpp"
73 #include "ROL_HS32.hpp"
74 #include "ROL_HS38.hpp"
75 #include "ROL_HS39.hpp"
76 #include "ROL_HS42.hpp"
77 #include "ROL_HS45.hpp"
78 #include "ROL_HS48.hpp"
79 #include "ROL_HS49.hpp"
80 #include "ROL_HS50.hpp"
81 #include "ROL_HS51.hpp"
82 #include "ROL_HS52.hpp"
83 #include "ROL_BVP.hpp"
84 #include "ROL_ParaboloidCircle.hpp"
85 #include "ROL_SimpleEqConstrained.hpp"
86 #include "ROL_CantileverBeam.hpp"
87 #include "ROL_Cubic.hpp"
88 #include "ROL_Quartic.hpp"
89 #include "ROL_CylinderHead.hpp"
90 #include "ROL_Cantilever.hpp"
91 #include "ROL_Minimax1.hpp"
92 #include "ROL_Minimax2.hpp"
93 #include "ROL_Minimax3.hpp"
94 
95 
96 namespace ROL {
97 
143  enum ETestOptProblem {
144  TESTOPTPROBLEM_ROSENBROCK = 0,
145  TESTOPTPROBLEM_FREUDENSTEINANDROTH,
146  TESTOPTPROBLEM_BEALE,
147  TESTOPTPROBLEM_POWELL,
148  TESTOPTPROBLEM_SUMOFSQUARES,
149  TESTOPTPROBLEM_LEASTSQUARES,
150  TESTOPTPROBLEM_POISSONCONTROL,
151  TESTOPTPROBLEM_POISSONINVERSION,
152  TESTOPTPROBLEM_ZAKHAROV,
153  TESTOPTPROBLEM_HS1,
154  TESTOPTPROBLEM_HS2,
155  TESTOPTPROBLEM_HS3,
156  TESTOPTPROBLEM_HS4,
157  TESTOPTPROBLEM_HS5,
158  TESTOPTPROBLEM_HS9,
159  TESTOPTPROBLEM_HS14,
160  TESTOPTPROBLEM_HS24,
161  TESTOPTPROBLEM_HS25,
162  TESTOPTPROBLEM_HS28,
163  TESTOPTPROBLEM_HS29,
164  TESTOPTPROBLEM_HS32,
165  TESTOPTPROBLEM_HS38,
166  TESTOPTPROBLEM_HS39,
167  TESTOPTPROBLEM_HS42,
168  TESTOPTPROBLEM_HS45,
169  TESTOPTPROBLEM_HS48,
170  TESTOPTPROBLEM_HS49,
171  TESTOPTPROBLEM_HS50,
172  TESTOPTPROBLEM_HS51,
173  TESTOPTPROBLEM_HS52,
174  TESTOPTPROBLEM_BVP,
175  TESTOPTPROBLEM_PARABOLOIDCIRCLE,
176  TESTOPTPROBLEM_SIMPLEEQCONSTRAINED,
177  TESTOPTPROBLEM_CANTILEVERBEAM,
178  TESTOPTPROBLEM_CUBIC,
179  TESTOPTPROBLEM_QUARTIC,
180  TESTOPTPROBLEM_CYLINDERHEAD,
181  TESTOPTPROBLEM_CANTILEVER,
182  TESTOPTPROBLEM_MINIMAX1,
183  TESTOPTPROBLEM_MINIMAX2,
184  TESTOPTPROBLEM_MINIMAX3,
185  TESTOPTPROBLEM_LAST
186  };
187 
188  inline std::string ETestOptProblemToString(ETestOptProblem to) {
189  std::string retString;
190  switch(to) {
191  case TESTOPTPROBLEM_ROSENBROCK: retString = "Rosenbrock's Function"; break;
192  case TESTOPTPROBLEM_FREUDENSTEINANDROTH: retString = "Freudenstein and Roth's Function"; break;
193  case TESTOPTPROBLEM_BEALE: retString = "Beale's Function"; break;
194  case TESTOPTPROBLEM_POWELL: retString = "Powell's Badly Scaled Function"; break;
195  case TESTOPTPROBLEM_SUMOFSQUARES: retString = "Sum of Squares Function"; break;
196  case TESTOPTPROBLEM_LEASTSQUARES: retString = "Least Squares Function"; break;
197  case TESTOPTPROBLEM_POISSONCONTROL: retString = "Poisson Optimal Control"; break;
198  case TESTOPTPROBLEM_POISSONINVERSION: retString = "Poisson Inversion Problem"; break;
199  case TESTOPTPROBLEM_ZAKHAROV: retString = "Zakharov's Function"; break;
200  case TESTOPTPROBLEM_HS1: retString = "Hock and Schittkowski Test Problem #1"; break;
201  case TESTOPTPROBLEM_HS2: retString = "Hock and Schittkowski Test Problem #2"; break;
202  case TESTOPTPROBLEM_HS3: retString = "Hock and Schittkowski Test Problem #3"; break;
203  case TESTOPTPROBLEM_HS4: retString = "Hock and Schittkowski Test Problem #4"; break;
204  case TESTOPTPROBLEM_HS5: retString = "Hock and Schittkowski Test Problem #5"; break;
205  case TESTOPTPROBLEM_HS9: retString = "Hock and Schittkowski Test Problem #9"; break;
206  case TESTOPTPROBLEM_HS14: retString = "Hock and Schittkowski Test Problem #14"; break;
207  case TESTOPTPROBLEM_HS24: retString = "Hock and Schittkowski Test Problem #24"; break;
208  case TESTOPTPROBLEM_HS25: retString = "Hock and Schittkowski Test Problem #25"; break;
209  case TESTOPTPROBLEM_HS28: retString = "Hock and Schittkowski Test Problem #28"; break;
210  case TESTOPTPROBLEM_HS29: retString = "Hock and Schittkowski Test Problem #29"; break;
211  case TESTOPTPROBLEM_HS32: retString = "Hock and Schittkowski Test Problem #32"; break;
212  case TESTOPTPROBLEM_HS38: retString = "Hock and Schittkowski Test Problem #38"; break;
213  case TESTOPTPROBLEM_HS39: retString = "Hock and Schittkowski Test Problem #39"; break;
214  case TESTOPTPROBLEM_HS42: retString = "Hock and Schittkowski Test Problem #42"; break;
215  case TESTOPTPROBLEM_HS45: retString = "Hock and Schittkowski Test Problem #45"; break;
216  case TESTOPTPROBLEM_HS48: retString = "Hock and Schittkowski Test Problem #48"; break;
217  case TESTOPTPROBLEM_HS49: retString = "Hock and Schittkowski Test Problem #49"; break;
218  case TESTOPTPROBLEM_HS50: retString = "Hock and Schittkowski Test Problem #50"; break;
219  case TESTOPTPROBLEM_HS51: retString = "Hock and Schittkowski Test Problem #51"; break;
220  case TESTOPTPROBLEM_HS52: retString = "Hock and Schittkowski Test Problem #52"; break;
221  case TESTOPTPROBLEM_BVP: retString = "Boundary Value Problem"; break;
222  case TESTOPTPROBLEM_PARABOLOIDCIRCLE: retString = "Paraboloid Circle"; break;
223  case TESTOPTPROBLEM_SIMPLEEQCONSTRAINED: retString = "Simple Equality Constrained"; break;
224  case TESTOPTPROBLEM_CANTILEVERBEAM: retString = "Cantilever Beam"; break;
225  case TESTOPTPROBLEM_CUBIC: retString = "Cubic"; break;
226  case TESTOPTPROBLEM_QUARTIC: retString = "Quartic"; break;
227  case TESTOPTPROBLEM_CYLINDERHEAD: retString = "Cylinder Head"; break;
228  case TESTOPTPROBLEM_CANTILEVER: retString = "Cantilever"; break;
229  case TESTOPTPROBLEM_MINIMAX1: retString = "Minimax #1"; break;
230  case TESTOPTPROBLEM_MINIMAX2: retString = "Minimax #2"; break;
231  case TESTOPTPROBLEM_MINIMAX3: retString = "Minimax #3"; break;
232  case TESTOPTPROBLEM_LAST: retString = "Last Type (Dummy)"; break;
233  default: retString = "INVALID ETestOptProblem";
234  }
235  return retString;
236  }
237 
243  inline int isValidTestOptProblem(ETestOptProblem to){
244  return( (to == TESTOPTPROBLEM_ROSENBROCK) ||
245  (to == TESTOPTPROBLEM_FREUDENSTEINANDROTH) ||
246  (to == TESTOPTPROBLEM_BEALE) ||
247  (to == TESTOPTPROBLEM_POWELL) ||
248  (to == TESTOPTPROBLEM_SUMOFSQUARES) ||
249  (to == TESTOPTPROBLEM_LEASTSQUARES) ||
250  (to == TESTOPTPROBLEM_POISSONCONTROL) ||
251  (to == TESTOPTPROBLEM_POISSONINVERSION) ||
252  (to == TESTOPTPROBLEM_ZAKHAROV) ||
253  (to == TESTOPTPROBLEM_HS1) ||
254  (to == TESTOPTPROBLEM_HS2) ||
255  (to == TESTOPTPROBLEM_HS3) ||
256  (to == TESTOPTPROBLEM_HS4) ||
257  (to == TESTOPTPROBLEM_HS5) ||
258  (to == TESTOPTPROBLEM_HS9) ||
259  (to == TESTOPTPROBLEM_HS14) ||
260  (to == TESTOPTPROBLEM_HS24) ||
261  (to == TESTOPTPROBLEM_HS25) ||
262  (to == TESTOPTPROBLEM_HS28) ||
263  (to == TESTOPTPROBLEM_HS29) ||
264  (to == TESTOPTPROBLEM_HS32) ||
265  (to == TESTOPTPROBLEM_HS38) ||
266  (to == TESTOPTPROBLEM_HS39) ||
267  (to == TESTOPTPROBLEM_HS42) ||
268  (to == TESTOPTPROBLEM_HS45) ||
269  (to == TESTOPTPROBLEM_HS48) ||
270  (to == TESTOPTPROBLEM_HS49) ||
271  (to == TESTOPTPROBLEM_HS50) ||
272  (to == TESTOPTPROBLEM_HS51) ||
273  (to == TESTOPTPROBLEM_HS52) ||
274  (to == TESTOPTPROBLEM_BVP) ||
275  (to == TESTOPTPROBLEM_PARABOLOIDCIRCLE) ||
276  (to == TESTOPTPROBLEM_SIMPLEEQCONSTRAINED) ||
277  (to == TESTOPTPROBLEM_CANTILEVERBEAM) ||
278  (to == TESTOPTPROBLEM_CUBIC) ||
279  (to == TESTOPTPROBLEM_QUARTIC) ||
280  (to == TESTOPTPROBLEM_CYLINDERHEAD) ||
281  (to == TESTOPTPROBLEM_CANTILEVER) ||
282  (to == TESTOPTPROBLEM_MINIMAX1) ||
283  (to == TESTOPTPROBLEM_MINIMAX2) ||
284  (to == TESTOPTPROBLEM_MINIMAX3) );
285  }
286 
287  inline ETestOptProblem & operator++(ETestOptProblem &type) {
288  return type = static_cast<ETestOptProblem>(type+1);
289  }
290 
291  inline ETestOptProblem operator++(ETestOptProblem &type, int) {
292  ETestOptProblem oldval = type;
293  ++type;
294  return oldval;
295  }
296 
297  inline ETestOptProblem & operator--(ETestOptProblem &type) {
298  return type = static_cast<ETestOptProblem>(type-1);
299  }
300 
301  inline ETestOptProblem operator--(ETestOptProblem &type, int) {
302  ETestOptProblem oldval = type;
303  --type;
304  return oldval;
305  }
306 
307  inline ETestOptProblem StringToETestOptProblem(std::string s) {
308  s = removeStringFormat(s);
309  for ( ETestOptProblem to = TESTOPTPROBLEM_ROSENBROCK; to < TESTOPTPROBLEM_LAST; to++ ) {
310  if ( !s.compare(removeStringFormat(ETestOptProblemToString(to))) ) {
311  return to;
312  }
313  }
314  return TESTOPTPROBLEM_ROSENBROCK;
315  }
316 
317  template<class Real>
318  void GetTestProblem( Ptr<OptimizationProblem<Real> > &problem,
319  Ptr<Vector<Real> > &x0,
320  std::vector<Ptr<Vector<Real> > > &x,
321  const ETestOptProblem test ) {
322  Ptr<TestProblem<Real>> tp;
323  switch (test) {
324  case TESTOPTPROBLEM_ROSENBROCK: tp = makePtr<ZOO::getRosenbrock<Real>>(); break;
325  case TESTOPTPROBLEM_FREUDENSTEINANDROTH: tp = makePtr<ZOO::getFreudensteinRoth<Real>>(); break;
326  case TESTOPTPROBLEM_BEALE: tp = makePtr<ZOO::getBeale<Real>>(); break;
327  case TESTOPTPROBLEM_POWELL: tp = makePtr<ZOO::getPowell<Real>>(); break;
328  case TESTOPTPROBLEM_SUMOFSQUARES: tp = makePtr<ZOO::getSumOfSquares<Real>>(); break;
329  case TESTOPTPROBLEM_LEASTSQUARES: tp = makePtr<ZOO::getLeastSquares<Real>>(); break;
330  case TESTOPTPROBLEM_POISSONCONTROL: tp = makePtr<ZOO::getPoissonControl<Real>>(); break;
331  case TESTOPTPROBLEM_POISSONINVERSION: tp = makePtr<ZOO::getPoissonInversion<Real>>(); break;
332  case TESTOPTPROBLEM_ZAKHAROV: tp = makePtr<ZOO::getZakharov<Real>>(); break;
333  case TESTOPTPROBLEM_HS1: tp = makePtr<ZOO::getHS1<Real>>(); break;
334  case TESTOPTPROBLEM_HS2: tp = makePtr<ZOO::getHS2<Real>>(); break;
335  case TESTOPTPROBLEM_HS3: tp = makePtr<ZOO::getHS3<Real>>(); break;
336  case TESTOPTPROBLEM_HS4: tp = makePtr<ZOO::getHS4<Real>>(); break;
337  case TESTOPTPROBLEM_HS5: tp = makePtr<ZOO::getHS5<Real>>(); break;
338  case TESTOPTPROBLEM_HS9: tp = makePtr<ZOO::getHS9<Real>>(); break;
339  case TESTOPTPROBLEM_HS14: tp = makePtr<ZOO::getHS14<Real>>(); break;
340  case TESTOPTPROBLEM_HS24: tp = makePtr<ZOO::getHS24<Real>>(); break;
341  case TESTOPTPROBLEM_HS25: tp = makePtr<ZOO::getHS25<Real>>(); break;
342  case TESTOPTPROBLEM_HS28: tp = makePtr<ZOO::getHS28<Real>>(); break;
343  case TESTOPTPROBLEM_HS29: tp = makePtr<ZOO::getHS29<Real>>(); break;
344  case TESTOPTPROBLEM_HS32: tp = makePtr<ZOO::getHS32<Real>>(); break;
345  case TESTOPTPROBLEM_HS38: tp = makePtr<ZOO::getHS38<Real>>(); break;
346  case TESTOPTPROBLEM_HS39: tp = makePtr<ZOO::getHS39<Real>>(); break;
347  case TESTOPTPROBLEM_HS42: tp = makePtr<ZOO::getHS42<Real>>(); break;
348  case TESTOPTPROBLEM_HS45: tp = makePtr<ZOO::getHS45<Real>>(); break;
349  case TESTOPTPROBLEM_HS48: tp = makePtr<ZOO::getHS48<Real>>(); break;
350  case TESTOPTPROBLEM_HS49: tp = makePtr<ZOO::getHS49<Real>>(); break;
351  case TESTOPTPROBLEM_HS50: tp = makePtr<ZOO::getHS50<Real>>(); break;
352  case TESTOPTPROBLEM_HS51: tp = makePtr<ZOO::getHS51<Real>>(); break;
353  case TESTOPTPROBLEM_HS52: tp = makePtr<ZOO::getHS52<Real>>(); break;
354  case TESTOPTPROBLEM_BVP: tp = makePtr<ZOO::getBVP<Real>>(); break;
355  case TESTOPTPROBLEM_PARABOLOIDCIRCLE: tp = makePtr<ZOO::getParaboloidCircle<Real>>(); break;
356  case TESTOPTPROBLEM_SIMPLEEQCONSTRAINED: tp = makePtr<ZOO::getSimpleEqConstrained<Real>>(); break;
357  case TESTOPTPROBLEM_CANTILEVERBEAM: tp = makePtr<ZOO::getCantileverBeam<Real>>(); break;
358  case TESTOPTPROBLEM_CUBIC: tp = makePtr<ZOO::getCubic<Real>>(2); break;
359  case TESTOPTPROBLEM_QUARTIC: tp = makePtr<ZOO::getQuartic<Real>>(); break;
360  case TESTOPTPROBLEM_CYLINDERHEAD: tp = makePtr<ZOO::getCylinderHead<Real>>(); break;
361  case TESTOPTPROBLEM_CANTILEVER: tp = makePtr<ZOO::getCantilever<Real>>(); break;
362  case TESTOPTPROBLEM_MINIMAX1: tp = makePtr<ZOO::getMinimax1<Real>>(); break;
363  case TESTOPTPROBLEM_MINIMAX2: tp = makePtr<ZOO::getMinimax1<Real>>(); break;
364  case TESTOPTPROBLEM_MINIMAX3: tp = makePtr<ZOO::getMinimax1<Real>>(); break;
365  case TESTOPTPROBLEM_LAST: break;
366  }
367  tp->get(problem,x0,x);
368  }
369 } // namespace ROL
370 
371 #endif
ROL::ETestOptProblem
ETestOptProblem
Enumeration of test optimization problems.
Definition: ROL_GetTestProblems.hpp:143
ROL_HS38.hpp
Contains definitions for W. Hock and K. Schittkowski 38th test function.
ROL_HS9.hpp
Contains definitions for W. Hock and K. Schittkowski 9th test function.
ROL_HS29.hpp
Contains definitions for W. Hock and K. Schittkowski 32nd test problem which contains only inequality...
ROL_HS48.hpp
Contains definitions for W. Hock and K. Schittkowski 48th test function.
ROL_Cubic.hpp
Contains definitions for a cubic test problem.
ROL::operator++
EKrylov & operator++(EKrylov &type)
Definition: ROL_KrylovFactory.hpp:101
ROL_Minimax2.hpp
ROL::removeStringFormat
std::string removeStringFormat(std::string s)
Definition: ROL_Types.hpp:247
ROL_PoissonControl.hpp
Contains definitions for Poisson optimal control.
ROL_HS52.hpp
Contains definitions for W. Hock and K. Schittkowski 52nd test function.
ROL_Cantilever.hpp
Contains definitions for the cylinder head test problem.
ROL_HS25.hpp
Contains definitions for W. Hock and K. Schittkowski 25th test function.
ROL::isValidTestOptProblem
int isValidTestOptProblem(ETestOptProblem to)
Verifies validity of a TestOptProblem enum.
Definition: ROL_GetTestProblems.hpp:243
ROL_Beale.hpp
Contains definitions for Beale&#39;s function.
ROL_Rosenbrock.hpp
Contains definitions for Rosenbrock&#39;s function.
ROL::Vector
Defines the linear algebra or vector space interface.
Definition: ROL_Vector.hpp:80
ROL::GetTestProblem
void GetTestProblem(Ptr< OptimizationProblem< Real > > &problem, Ptr< Vector< Real > > &x0, std::vector< Ptr< Vector< Real > > > &x, const ETestOptProblem test)
Definition: ROL_GetTestProblems.hpp:318
ROL_CantileverBeam.hpp
Contains definitions for Cantilevered Beam example in G. N. Vanderplaats, Numerical Optimization Tech...
ROL_HS4.hpp
Contains definitions for W. Hock and K. Schittkowski 4th test function.
ROL_HS14.hpp
Contains definitions for W. Hock and K. Schittkowski 14th test function.
ROL_PoissonInversion.hpp
Contains definitions for Poisson material inversion.
ROL_HS39.hpp
Contains definitions for W. Hock and K. Schittkowski 39th test function.
ROL_FreudensteinRoth.hpp
Contains definitions for Freudenstein and Roth&#39;s function.
ROL_Quartic.hpp
Contains definitions for a quartic test problem.
ROL_CylinderHead.hpp
Contains definitions for the cylinder head test problem.
ROL::ETestOptProblemToString
std::string ETestOptProblemToString(ETestOptProblem to)
Definition: ROL_GetTestProblems.hpp:188
ROL_Minimax3.hpp
ROL_LeastSquares.hpp
Contains definitions for least squares function.
ROL_Powell.hpp
Contains definitions for Powell&#39;s badly scaled function.
ROL_Zakharov.hpp
Contains definitions for the Zakharov function as evaluated using only the ROL::Vector interface...
ROL_HS51.hpp
Contains definitions for W. Hock and K. Schittkowski 51th test function.
ROL_SimpleEqConstrained.hpp
Contains definitions for the equality constrained NLP from Nocedal/Wright, 2nd edition, page 574, example 18.2; note the typo in reversing the initial guess and the solution.
ROL_HS24.hpp
Contains definitions for W. Hock and K. Schittkowski 24th test problem which contains bound and inequ...
ROL_BVP.hpp
Contains definitions for the discrete boundary value problem (More, Garbow, Hillstrom, 1981).
ROL_HS1.hpp
Contains definitions for W. Hock and K. Schittkowski 1st test function.
ROL_HS49.hpp
Contains definitions for W. Hock and K. Schittkowski 49th test function.
ROL_HS32.hpp
Contains definitions for W. Hock and K. Schittkowski 32nd test problem which contains both inequality...
ROL_HS3.hpp
Contains definitions for W. Hock and K. Schittkowski 3rd test function.
ROL_HS50.hpp
Contains definitions for W. Hock and K. Schittkowski 50th test function.
ROL_HS28.hpp
Contains definitions for W. Hock and K. Schittkowski 28th test function.
ROL_Minimax1.hpp
ROL::operator--
EKrylov & operator--(EKrylov &type)
Definition: ROL_KrylovFactory.hpp:111
ROL_HS5.hpp
Contains definitions for W. Hock and K. Schittkowski 5th test function.
ROL_HS45.hpp
Contains definitions for W. Hock and K. Schittkowski 45th test function.
ROL::StringToETestOptProblem
ETestOptProblem StringToETestOptProblem(std::string s)
Definition: ROL_GetTestProblems.hpp:307
ROL_HS2.hpp
Contains definitions for W. Hock and K. Schittkowski 2nd test function.
ROL_HS42.hpp
Contains definitions for W. Hock and K. Schittkowski 42th test function.
ROL_SumOfSquares.hpp
Contains definitions for sum of squares function.
ROL_ParaboloidCircle.hpp
Contains definitions for the equality constrained NLP:
Generated by   doxygen 1.8.5