ROL
ROL_SimpleEqConstrained.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// Rapid Optimization Library (ROL) Package
4//
5// Copyright 2014 NTESS and the ROL contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
17#ifndef ROL_SIMPLEEQCONSTRAINED_HPP
18#define ROL_SIMPLEEQCONSTRAINED_HPP
19
20#include "ROL_TestProblem.hpp"
21#include "ROL_StdVector.hpp"
22#include "ROL_LinearAlgebra.hpp"
23
24namespace ROL {
25namespace ZOO {
26
30 template< class Real, class XPrim=StdVector<Real>, class XDual=StdVector<Real> >
31 class Objective_SimpleEqConstrained : public Objective<Real> {
32
33 typedef std::vector<Real> vector;
34 typedef Vector<Real> V;
35
36 typedef typename vector::size_type uint;
37
38
39 private:
40
41 template<class VectorType>
42 ROL::Ptr<const vector> getVector( const V& x ) {
43
44 return dynamic_cast<const VectorType&>(x).getVector();
45 }
46
47 template<class VectorType>
48 ROL::Ptr<vector> getVector( V& x ) {
49
50 return dynamic_cast<VectorType&>(x).getVector();
51 }
52
53 public:
54 Objective_SimpleEqConstrained() {}
55
56 Real value( const Vector<Real> &x, Real &tol ) {
57
58
59 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
60
61 uint n = xp->size();
62 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective value): "
63 "Primal vector x must be of length 5.");
64
65 Real x1 = (*xp)[0];
66 Real x2 = (*xp)[1];
67 Real x3 = (*xp)[2];
68 Real x4 = (*xp)[3];
69 Real x5 = (*xp)[4];
70
71 Real arg = x1*x2*x3*x4*x5;
72 Real val = -0.5*pow(pow(x1,3)+pow(x2,3)+1.0,2);
73 if (std::abs(arg) < 1e5) val += exp(x1*x2*x3*x4*x5);
74 else if (arg > 1e5) val += 1e10;
75 //Real val = exp(x1*x2*x3*x4*x5) - 0.5 * pow( (pow(x1,3)+pow(x2,3)+1.0), 2);
76
77 return val;
78 }
79
80 void gradient( Vector<Real> &g, const Vector<Real> &x, Real &tol ) {
81
82
83 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
84 ROL::Ptr<vector> gp = getVector<XDual>(g);
85
86 uint n = xp->size();
87 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective gradient): "
88 " Primal vector x must be of length 5.");
89
90 n = gp->size();
91 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective gradient): "
92 "Gradient vector g must be of length 5.");
93
94 Real x1 = (*xp)[0];
95 Real x2 = (*xp)[1];
96 Real x3 = (*xp)[2];
97 Real x4 = (*xp)[3];
98 Real x5 = (*xp)[4];
99
100 Real expxi = exp(x1*x2*x3*x4*x5);
101
102 (*gp)[0] = x2*x3*x4*x5 * expxi - 3*pow(x1,2) * (pow(x1,3) + pow(x2,3) + 1);
103 (*gp)[1] = x1*x3*x4*x5 * expxi - 3*pow(x2,2) * (pow(x1,3) + pow(x2,3) + 1);
104 (*gp)[2] = x1*x2*x4*x5 * expxi;
105 (*gp)[3] = x1*x2*x3*x5 * expxi;
106 (*gp)[4] = x1*x2*x3*x4 * expxi;
107 }
108
109 void hessVec( Vector<Real> &hv, const Vector<Real> &v, const Vector<Real> &x, Real &tol ) {
110
111
112 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
113 ROL::Ptr<const vector> vp = getVector<XPrim>(v);
114 ROL::Ptr<vector> hvp = getVector<XDual>(hv);
115
116 uint n = xp->size();
117 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective hessVec): "
118 "Primal vector x must be of length 5.");
119
120 n = vp->size();
121 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective hessVec): "
122 "Input vector v must be of length 5.");
123
124 n = hvp->size();
125 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, objective hessVec): "
126 "Output vector hv must be of length 5.");
127
128 Real x1 = (*xp)[0];
129 Real x2 = (*xp)[1];
130 Real x3 = (*xp)[2];
131 Real x4 = (*xp)[3];
132 Real x5 = (*xp)[4];
133
134 Real v1 = (*vp)[0];
135 Real v2 = (*vp)[1];
136 Real v3 = (*vp)[2];
137 Real v4 = (*vp)[3];
138 Real v5 = (*vp)[4];
139
140 Real expxi = exp(x1*x2*x3*x4*x5);
141
142 (*hvp)[0] = ( pow(x2,2)*pow(x3,2)*pow(x4,2)*pow(x5,2)*expxi-9.0*pow(x1,4)-6.0*(pow(x1,3)+pow(x2,3)+1.0)*x1 ) * v1 +
143 ( x3*x4*x5*expxi+x2*pow(x3,2)*pow(x4,2)*pow(x5,2)*x1*expxi-9.0*pow(x2,2)*pow(x1,2) ) * v2 +
144 ( x2*x4*x5*expxi+pow(x2,2)*x3*pow(x4,2)*pow(x5,2)*x1*expxi ) * v3 +
145 ( x2*x3*x5*expxi+pow(x2,2)*pow(x3,2)*x4*pow(x5,2)*x1*expxi ) * v4 +
146 ( x2*x3*x4*expxi+pow(x2,2)*pow(x3,2)*pow(x4,2)*x5*x1*expxi ) * v5;
147
148 (*hvp)[1] = ( x3*x4*x5*expxi+x2*pow(x3,2)*pow(x4,2)*pow(x5,2)*x1*expxi-9.0*pow(x2,2)*pow(x1,2) ) * v1 +
149 ( pow(x1,2)*pow(x3,2)*pow(x4,2)*pow(x5,2)*expxi-9.0*pow(x2,4)-6.0*(pow(x1,3)+pow(x2,3)+1.0)*x2 ) * v2 +
150 ( x1*x4*x5*expxi+pow(x1,2)*x3*pow(x4,2)*pow(x5,2)*x2*expxi ) * v3 +
151 ( x1*x3*x5*expxi+pow(x1,2)*pow(x3,2)*x4*pow(x5,2)*x2*expxi ) * v4 +
152 ( x1*x3*x4*expxi+pow(x1,2)*pow(x3,2)*pow(x4,2)*x5*x2*expxi ) * v5;
153
154 (*hvp)[2] = ( x2*x4*x5*expxi+pow(x2,2)*x3*pow(x4,2)*pow(x5,2)*x1*expxi ) * v1 +
155 ( x1*x4*x5*expxi+pow(x1,2)*x3*pow(x4,2)*pow(x5,2)*x2*expxi ) * v2 +
156 ( pow(x1,2)*pow(x2,2)*pow(x4,2)*pow(x5,2)*expxi ) * v3 +
157 ( x1*x2*x5*expxi+pow(x1,2)*pow(x2,2)*x4*pow(x5,2)*x3*expxi ) * v4 +
158 ( x1*x2*x4*expxi+pow(x1,2)*pow(x2,2)*pow(x4,2)*x5*x3*expxi ) * v5;
159
160 (*hvp)[3] = ( x2*x3*x5*expxi+pow(x2,2)*pow(x3,2)*x4*pow(x5,2)*x1*expxi ) * v1 +
161 ( x1*x3*x5*expxi+pow(x1,2)*pow(x3,2)*x4*pow(x5,2)*x2*expxi ) * v2 +
162 ( x1*x2*x5*expxi+pow(x1,2)*pow(x2,2)*x4*pow(x5,2)*x3*expxi ) * v3 +
163 ( pow(x1,2)*pow(x2,2)*pow(x3,2)*pow(x5,2)*expxi ) * v4 +
164 ( x1*x2*x3*expxi+pow(x1,2)*pow(x2,2)*pow(x3,2)*x5*x4*expxi ) * v5;
165
166 (*hvp)[4] = ( x2*x3*x4*expxi+pow(x2,2)*pow(x3,2)*pow(x4,2)*x5*x1*expxi ) * v1 +
167 ( x1*x3*x4*expxi+pow(x1,2)*pow(x3,2)*pow(x4,2)*x5*x2*expxi ) * v2 +
168 ( x1*x2*x4*expxi+pow(x1,2)*pow(x2,2)*pow(x4,2)*x5*x3*expxi ) * v3 +
169 ( x1*x2*x3*expxi+pow(x1,2)*pow(x2,2)*pow(x3,2)*x5*x4*expxi ) * v4 +
170 ( pow(x1,2)*pow(x2,2)*pow(x3,2)*pow(x4,2)*expxi ) * v5;
171 }
172
173 };
174
175
181 template<class Real, class XPrim=StdVector<Real>, class XDual=StdVector<Real>, class CPrim=StdVector<Real>, class CDual=StdVector<Real> >
182 class EqualityConstraint_SimpleEqConstrained : public Constraint<Real> {
183
184 typedef std::vector<Real> vector;
185 typedef Vector<Real> V;
186
187 typedef typename vector::size_type uint;
188
189 private:
190 template<class VectorType>
191 ROL::Ptr<const vector> getVector( const V& x ) {
192
193 return dynamic_cast<const VectorType&>(x).getVector();
194 }
195
196 template<class VectorType>
197 ROL::Ptr<vector> getVector( V& x ) {
198
199 return dynamic_cast<VectorType&>(x).getVector();
200 }
201
202 public:
203 EqualityConstraint_SimpleEqConstrained() {}
204
205 void value( Vector<Real> &c, const Vector<Real> &x, Real &tol ) {
206
207
208 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
209 ROL::Ptr<vector> cp = getVector<CPrim>(c);
210
211 uint n = xp->size();
212 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint value): "
213 "Primal vector x must be of length 5.");
214
215 uint m = cp->size();
216 ROL_TEST_FOR_EXCEPTION( (m != 3), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint value): "
217 "Constraint vector c must be of length 3.");
218
219 Real x1 = (*xp)[0];
220 Real x2 = (*xp)[1];
221 Real x3 = (*xp)[2];
222 Real x4 = (*xp)[3];
223 Real x5 = (*xp)[4];
224
225 (*cp)[0] = x1*x1+x2*x2+x3*x3+x4*x4+x5*x5 - 10.0;
226 (*cp)[1] = x2*x3 - 5.0*x4*x5;
227 (*cp)[2] = x1*x1*x1 + x2*x2*x2 + 1.0;
228 }
229
230 void applyJacobian( Vector<Real> &jv, const Vector<Real> &v, const Vector<Real> &x, Real &tol ) {
231
232
233 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
234 ROL::Ptr<const vector> vp = getVector<XPrim>(v);
235 ROL::Ptr<vector> jvp = getVector<CPrim>(jv);
236
237 uint n = xp->size();
238 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyJacobian): "
239 "Primal vector x must be of length 5.");
240
241 uint d = vp->size();
242 ROL_TEST_FOR_EXCEPTION( (d != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyJacobian): "
243 "Input vector v must be of length 5.");
244 d = jvp->size();
245 ROL_TEST_FOR_EXCEPTION( (d != 3), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyJacobian): "
246 "Output vector jv must be of length 3.");
247
248 Real x1 = (*xp)[0];
249 Real x2 = (*xp)[1];
250 Real x3 = (*xp)[2];
251 Real x4 = (*xp)[3];
252 Real x5 = (*xp)[4];
253
254 Real v1 = (*vp)[0];
255 Real v2 = (*vp)[1];
256 Real v3 = (*vp)[2];
257 Real v4 = (*vp)[3];
258 Real v5 = (*vp)[4];
259
260 (*jvp)[0] = 2.0*(x1*v1+x2*v2+x3*v3+x4*v4+x5*v5);
261 (*jvp)[1] = x3*v2+x2*v3-5.0*x5*v4-5.0*x4*v5;
262 (*jvp)[2] = 3.0*x1*x1*v1+3.0*x2*x2*v2;
263
264 } //applyJacobian
265
266 void applyAdjointJacobian( Vector<Real> &ajv, const Vector<Real> &v, const Vector<Real> &x, Real &tol ) {
267
268
269 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
270 ROL::Ptr<const vector> vp = getVector<CDual>(v);
271 ROL::Ptr<vector> ajvp = getVector<XDual>(ajv);
272
273 uint n = xp->size();
274 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointJacobian): "
275 "Primal vector x must be of length 5.");
276
277 uint d = vp->size();
278 ROL_TEST_FOR_EXCEPTION( (d != 3), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointJacobian): "
279 "Input vector v must be of length 3.");
280
281 d = ajvp->size();
282 ROL_TEST_FOR_EXCEPTION( (d != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointJacobian): "
283 "Output vector ajv must be of length 5.");
284
285 Real x1 = (*xp)[0];
286 Real x2 = (*xp)[1];
287 Real x3 = (*xp)[2];
288 Real x4 = (*xp)[3];
289 Real x5 = (*xp)[4];
290
291 Real v1 = (*vp)[0];
292 Real v2 = (*vp)[1];
293 Real v3 = (*vp)[2];
294
295 (*ajvp)[0] = 2.0*x1*v1+3.0*x1*x1*v3;
296 (*ajvp)[1] = 2.0*x2*v1+x3*v2+3.0*x2*x2*v3;
297 (*ajvp)[2] = 2.0*x3*v1+x2*v2;
298 (*ajvp)[3] = 2.0*x4*v1-5.0*x5*v2;
299 (*ajvp)[4] = 2.0*x5*v1-5.0*x4*v2;
300
301 } //applyAdjointJacobian
302
303 void applyAdjointHessian( Vector<Real> &ahuv, const Vector<Real> &u, const Vector<Real> &v, const Vector<Real> &x, Real &tol ) {
304
305 ROL::Ptr<const vector> xp = getVector<XPrim>(x);
306 ROL::Ptr<const vector> up = getVector<CDual>(u);
307 ROL::Ptr<const vector> vp = getVector<XPrim>(v);
308 ROL::Ptr<vector> ahuvp = getVector<XDual>(ahuv);
309
310 uint n = xp->size();
311 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointHessian): "
312 "Primal vector x must be of length 5.");
313
314 n = vp->size();
315 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointHessian): "
316 "Direction vector v must be of length 5.");
317
318 n = ahuvp->size();
319 ROL_TEST_FOR_EXCEPTION( (n != 5), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointHessian): "
320 "Output vector ahuv must be of length 5.");
321 uint d = up->size();
322 ROL_TEST_FOR_EXCEPTION( (d != 3), std::invalid_argument, ">>> ERROR (ROL_SimpleEqConstrained, constraint applyAdjointHessian): "
323 "Dual constraint vector u must be of length 3.");
324
325 Real x1 = (*xp)[0];
326 Real x2 = (*xp)[1];
327
328 Real v1 = (*vp)[0];
329 Real v2 = (*vp)[1];
330 Real v3 = (*vp)[2];
331 Real v4 = (*vp)[3];
332 Real v5 = (*vp)[4];
333
334 Real u1 = (*up)[0];
335 Real u2 = (*up)[1];
336 Real u3 = (*up)[2];
337
338 (*ahuvp)[0] = 2.0*u1*v1 + 6.0*u3*x1*v1;
339 (*ahuvp)[1] = 2.0*u1*v2 + u2*v3 + 6.0*u3*x2*v2;
340 (*ahuvp)[2] = 2.0*u1*v3 + u2*v2;
341 (*ahuvp)[3] = 2.0*u1*v4 - 5.0*u2*v5;
342 (*ahuvp)[4] = 2.0*u1*v5 - 5.0*u2*v4;
343
344 } //applyAdjointHessian
345
346 /*std::vector<Real> solveAugmentedSystem(Vector<Real> &v1, Vector<Real> &v2, const Vector<Real> &b1, const Vector<Real> &b2, const Vector<Real> &x, Real &tol) {
347 ROL::Ptr<std::vector<Real> > v1p =
348 ROL::constPtrCast<std::vector<Real> >((dynamic_cast<XPrim&>(v1)).getVector());
349 ROL::Ptr<std::vector<Real> > v2p =
350 ROL::constPtrCast<std::vector<Real> >((dynamic_cast<CDual&>(v2)).getVector());
351 ROL::Ptr<const std::vector<Real> > b1p =
352 (dynamic_cast<XDual>(const_cast<Vector<Real> &&>(b1))).getVector();
353 ROL::Ptr<const std::vector<Real> > b2p =
354 (dynamic_cast<CPrim>(const_cast<Vector<Real> &&>(b2))).getVector();
355 ROL::Ptr<const std::vector<Real> > xp =
356 (dynamic_cast<XPrim>(const_cast<Vector<Real> &&>(x))).getVector();
357
358 Real x1 = (*xp)[0];
359 Real x2 = (*xp)[1];
360 Real x3 = (*xp)[2];
361 Real x4 = (*xp)[3];
362 Real x5 = (*xp)[4];
363
364 int i = 0;
365
366 // Assemble augmented system.
367 Teuchos::SerialDenseMatrix<int, Real> augmat(8,8);
368 for (i=0; i<5; i++) {
369 augmat(i,i) = 1.0;
370 }
371 augmat(5,0) = 2.0*x1; augmat(5,1) = 2.0*x2; augmat(5,2) = 2.0*x3; augmat(5,3) = 2.0*x4; augmat(5,4) = 2.0*x5;
372 augmat(6,1) = x3; augmat(6,2) = x2; augmat(6,3) = -5.0*x5; augmat(6,4) = -5.0*x4;
373 augmat(7,0) = 3.0*x1*x1; augmat(7,1) = 3.0*x2*x2;
374 augmat(0,5) = 2.0*x1; augmat(1,5) = 2.0*x2; augmat(2,5) = 2.0*x3; augmat(3,5) = 2.0*x4; augmat(4,5) = 2.0*x5;
375 augmat(1,6) = x3; augmat(2,6) = x2; augmat(3,6) = -5.0*x5; augmat(4,6) = -5.0*x4;
376 augmat(0,7) = 3.0*x1*x1; augmat(1,7) = 3.0*x2*x2;
377 Teuchos::SerialDenseVector<int, Real> lhs(8);
378 Teuchos::SerialDenseVector<int, Real> rhs(8);
379 for (i=0; i<5; i++) {
380 rhs(i) = (*b1p)[i];
381 }
382 for (i=5; i<8; i++) {
383 rhs(i) = (*b2p)[i-5];
384 }
385
386 // Solve augmented system.
387 Teuchos::SerialDenseSolver<int, Real> augsolver;
388 augsolver.setMatrix(&augmat, false);
389 augsolver.setVectors(&lhs, false), Teuchos::&rhs, false;
390 augsolver.solve();
391
392 // Retrieve solution.
393 for (i=0; i<5; i++) {
394 (*v1p)[i] = lhs(i);
395 }
396 for (i=0; i<3; i++) {
397 (*v2p)[i] = lhs(i+5);
398 }
399
400 return std::vector<Real>(0);
401
402 }*/ //solveAugmentedSystem
403
404 };
405
406
407 template<class Real, class XPrim=StdVector<Real>, class XDual=StdVector<Real>, class CPrim=StdVector<Real>, class CDual=StdVector<Real> >
408 class getSimpleEqConstrained : public TestProblem<Real> {
409 typedef std::vector<Real> vector;
410 typedef typename vector::size_type uint;
411 public:
412 getSimpleEqConstrained(void) {}
413
414 Ptr<Objective<Real>> getObjective(void) const {
415 // Instantiate objective function.
416 return ROL::makePtr<Objective_SimpleEqConstrained<Real,XPrim,XDual>>();
417 }
418
419 Ptr<Vector<Real>> getInitialGuess(void) const {
420 uint n = 5;
421 // Get initial guess.
422 Ptr<vector> x0p = makePtr<vector>(n,0);
423 (*x0p)[0] = -1.8;
424 (*x0p)[1] = 1.7;
425 (*x0p)[2] = 1.9;
426 (*x0p)[3] = -0.8;
427 (*x0p)[4] = -0.8;
428 return makePtr<XPrim>(x0p);
429 }
430
431 Ptr<Vector<Real>> getSolution(const int i = 0) const {
432 uint n = 5;
433 // Get solution.
434 Ptr<vector> solp = makePtr<vector>(n,0);
435 (*solp)[0] = -1.717143570394391e+00;
436 (*solp)[1] = 1.595709690183565e+00;
437 (*solp)[2] = 1.827245752927178e+00;
438 (*solp)[3] = -7.636430781841294e-01;
439 (*solp)[4] = -7.636430781841294e-01;
440 return makePtr<XPrim>(solp);
441 }
442
443 Ptr<Constraint<Real>> getEqualityConstraint(void) const {
444 // Instantiate constraints.
445 return ROL::makePtr<EqualityConstraint_SimpleEqConstrained<Real,XPrim,XDual,CPrim,CDual>>();
446 }
447
448 Ptr<Vector<Real>> getEqualityMultiplier(void) const {
449 Ptr<vector> lp = makePtr<vector>(3,0);
450 return makePtr<CDual>(lp);
451 }
452 };
453
454} // End ZOO Namespace
455} // End ROL Namespace
456
457#endif
ROL_StdVector.hpp
ROL_TestProblem.hpp
Contains definitions of test objective functions.
ROL::Constraint
Defines the general constraint operator interface.
Definition ROL_Constraint.hpp:52
ROL::Objective
Provides the interface to evaluate objective functions.
Definition ROL_Objective.hpp:44
ROL::Vector
Defines the linear algebra or vector space interface.
Definition ROL_Vector.hpp:51
ROL::ZOO::EqualityConstraint_SimpleEqConstrained
Equality constraints c_i(x) = 0, where: c1(x) = x1^2+x2^2+x3^2+x4^2+x5^2 - 10 c2(x) = x2*x3-5*x4*x5 c...
Definition ROL_SimpleEqConstrained.hpp:182
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::applyAdjointHessian
void applyAdjointHessian(Vector< Real > &ahuv, const Vector< Real > &u, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply the derivative of the adjoint of the constraint Jacobian at to vector in direction ,...
Definition ROL_SimpleEqConstrained.hpp:303
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::applyJacobian
void applyJacobian(Vector< Real > &jv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply the constraint Jacobian at , , to vector .
Definition ROL_SimpleEqConstrained.hpp:230
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::EqualityConstraint_SimpleEqConstrained
EqualityConstraint_SimpleEqConstrained()
Definition ROL_SimpleEqConstrained.hpp:203
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::getVector
ROL::Ptr< vector > getVector(V &x)
Definition ROL_SimpleEqConstrained.hpp:197
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::vector
std::vector< Real > vector
Definition ROL_SimpleEqConstrained.hpp:184
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::getVector
ROL::Ptr< const vector > getVector(const V &x)
Definition ROL_SimpleEqConstrained.hpp:191
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::value
void value(Vector< Real > &c, const Vector< Real > &x, Real &tol)
Evaluate the constraint operator at .
Definition ROL_SimpleEqConstrained.hpp:205
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::uint
vector::size_type uint
Definition ROL_SimpleEqConstrained.hpp:187
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::V
Vector< Real > V
Definition ROL_SimpleEqConstrained.hpp:185
ROL::ZOO::EqualityConstraint_SimpleEqConstrained::applyAdjointJacobian
void applyAdjointJacobian(Vector< Real > &ajv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply the adjoint of the the constraint Jacobian at , , to vector .
Definition ROL_SimpleEqConstrained.hpp:266
ROL::ZOO::Objective_SimpleEqConstrained
Objective function: f(x) = exp(x1*x2*x3*x4*x5) + 0.5*(x1^3+x2^3+1)^2.
Definition ROL_SimpleEqConstrained.hpp:31
ROL::ZOO::Objective_SimpleEqConstrained::value
Real value(const Vector< Real > &x, Real &tol)
Compute value.
Definition ROL_SimpleEqConstrained.hpp:56
ROL::ZOO::Objective_SimpleEqConstrained::V
Vector< Real > V
Definition ROL_SimpleEqConstrained.hpp:34
ROL::ZOO::Objective_SimpleEqConstrained::getVector
ROL::Ptr< vector > getVector(V &x)
Definition ROL_SimpleEqConstrained.hpp:48
ROL::ZOO::Objective_SimpleEqConstrained::uint
vector::size_type uint
Definition ROL_SimpleEqConstrained.hpp:36
ROL::ZOO::Objective_SimpleEqConstrained::hessVec
void hessVec(Vector< Real > &hv, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Apply Hessian approximation to vector.
Definition ROL_SimpleEqConstrained.hpp:109
ROL::ZOO::Objective_SimpleEqConstrained::Objective_SimpleEqConstrained
Objective_SimpleEqConstrained()
Definition ROL_SimpleEqConstrained.hpp:54
ROL::ZOO::Objective_SimpleEqConstrained::vector
std::vector< Real > vector
Definition ROL_SimpleEqConstrained.hpp:33
ROL::ZOO::Objective_SimpleEqConstrained::gradient
void gradient(Vector< Real > &g, const Vector< Real > &x, Real &tol)
Compute gradient.
Definition ROL_SimpleEqConstrained.hpp:80
ROL::ZOO::Objective_SimpleEqConstrained::getVector
ROL::Ptr< const vector > getVector(const V &x)
Definition ROL_SimpleEqConstrained.hpp:42
ROL::ZOO::getSimpleEqConstrained::getSolution
Ptr< Vector< Real > > getSolution(const int i=0) const
Definition ROL_SimpleEqConstrained.hpp:431
ROL::ZOO::getSimpleEqConstrained::getInitialGuess
Ptr< Vector< Real > > getInitialGuess(void) const
Definition ROL_SimpleEqConstrained.hpp:419
ROL::ZOO::getSimpleEqConstrained::getObjective
Ptr< Objective< Real > > getObjective(void) const
Definition ROL_SimpleEqConstrained.hpp:414
ROL::ZOO::getSimpleEqConstrained::getEqualityMultiplier
Ptr< Vector< Real > > getEqualityMultiplier(void) const
Definition ROL_SimpleEqConstrained.hpp:448
ROL::ZOO::getSimpleEqConstrained::getEqualityConstraint
Ptr< Constraint< Real > > getEqualityConstraint(void) const
Definition ROL_SimpleEqConstrained.hpp:443
Generated by doxygen 1.9.8