ROL
ROL_Minimax3.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_MINIMAX3_HPP
45#define ROL_MINIMAX3_HPP
46
47#include "ROL_TestProblem.hpp"
48#include "ROL_StdVector.hpp"
49#include "ROL_Ptr.hpp"
50
51namespace ROL {
52namespace ZOO {
53
54template<class Real>
55class Minimax3 : public Objective<Real> {
56
57 typedef std::vector<Real> vector;
58 typedef Vector<Real> V;
60
61private:
62
63 ROL::Ptr<const vector> getVector( const V& x ) {
64
65 return dynamic_cast<const SV&>(x).getVector();
66 }
67
68 ROL::Ptr<vector> getVector( V& x ) {
69
70 return dynamic_cast<SV&>(x).getVector();
71 }
72
73public:
74 Minimax3(void) {}
75
76 Real value(const Vector<Real> &x, Real &tol) {
77
78
79 ROL::Ptr<const vector> xp = getVector(x);
80
81 Real F = std::pow((*xp)[0],2.0) + std::pow((*xp)[1],2.0) + 2.0*std::pow((*xp)[2],2.0)
82 + std::pow((*xp)[3],2.0) - 5.0*(*xp)[0] - 5.0*(*xp)[1] - 21.0*(*xp)[2] + 7.0*(*xp)[3];
83 Real g2 = -std::pow((*xp)[0],2.0)-std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)-std::pow((*xp)[3],2.0)
84 -(*xp)[0]+(*xp)[1]-(*xp)[2]+(*xp)[3]+8.0;
85 Real g3 = -std::pow((*xp)[0],2.0)-2.0*std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)
86 -2.0*std::pow((*xp)[3],2.0)+(*xp)[0]+(*xp)[3]+10.0;
87 Real g4 = -std::pow((*xp)[0],2.0)-std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)
88 -2.0*(*xp)[0]+(*xp)[1]+(*xp)[3]+5.0;
89 Real a2 = 10.0, a3 = 10.0, a4 = 10.0;
90 return std::max(F,std::max(F-a2*g2,std::max(F-a3*g3,F-a4*g4)));
91 }
92
93 void gradient(Vector<Real> &g, const Vector<Real> &x, Real &tol) {
94
95
96 ROL::Ptr<const vector> xp = getVector(x);
97 ROL::Ptr<vector> gp = getVector(g);
98
99 Real F = std::pow((*xp)[0],2.0) + std::pow((*xp)[1],2.0) + 2.0*std::pow((*xp)[2],2.0)
100 + std::pow((*xp)[3],2.0) - 5.0*(*xp)[0] - 5.0*(*xp)[1] - 21.0*(*xp)[2] + 7.0*(*xp)[3];
101 Real g2 = -std::pow((*xp)[0],2.0)-std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)-std::pow((*xp)[3],2.0)
102 -(*xp)[0]+(*xp)[1]-(*xp)[2]+(*xp)[3]+8.0;
103 Real g3 = -std::pow((*xp)[0],2.0)-2.0*std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)
104 -2.0*std::pow((*xp)[3],2.0)+(*xp)[0]+(*xp)[3]+10.0;
105 Real g4 = -std::pow((*xp)[0],2.0)-std::pow((*xp)[1],2.0)-std::pow((*xp)[2],2.0)
106 -2.0*(*xp)[0]+(*xp)[1]+(*xp)[3]+5.0;
107 Real a2 = 10.0, a3 = 10.0, a4 = 10.0;
108
109 (*gp)[0] = 2.0*(*xp)[0] - 5.0;
110 (*gp)[1] = 2.0*(*xp)[1] - 5.0;
111 (*gp)[2] = 4.0*(*xp)[2] - 21.0;
112 (*gp)[3] = 2.0*(*xp)[3] + 7.0;
113 if ( F-a2*g2 >= std::max(F,std::max(F-a3*g3,F-a4*g4)) ) {
114 (*gp)[0] += a2*(2.0*(*xp)[0] + 1.0);
115 (*gp)[1] += a2*(2.0*(*xp)[1] - 1.0);
116 (*gp)[2] += a2*(2.0*(*xp)[2] + 1.0);
117 (*gp)[3] += a2*(2.0*(*xp)[3] - 1.0);
118 }
119 else if ( F-a3*g3 >= std::max(F,std::max(F-a2*g2,F-a4*g4)) ) {
120 (*gp)[0] += a2*(2.0*(*xp)[0] - 1.0);
121 (*gp)[1] += a2*(4.0*(*xp)[1]);
122 (*gp)[2] += a2*(2.0*(*xp)[2]);
123 (*gp)[3] += a2*(4.0*(*xp)[3] - 1.0);
124 }
125 else if ( F-a4*g4 >= std::max(F,std::max(F-a2*g2,F-a3*g3)) ) {
126 (*gp)[0] += a2*(2.0*(*xp)[0] + 2.0);
127 (*gp)[1] += a2*(2.0*(*xp)[1] - 1.0);
128 (*gp)[2] += a2*(2.0*(*xp)[2]);
129 (*gp)[3] += a2*(-1.0);
130 }
131 }
132}; // class Minimax3
133
134template<class Real>
135class getMinimax3 : public TestProblem<Real> {
136public:
137 getMinimax3(void) {}
138
139 Ptr<Objective<Real>> getObjective(void) const {
140 return makePtr<Minimax3<Real>>();
141 }
142
143 Ptr<Vector<Real>> getInitialGuess(void) const {
144 ROL::Ptr<std::vector<Real> > x_ptr = ROL::makePtr<std::vector<Real>>(4, 0.0);
145 return makePtr<StdVector<Real>>(x_ptr);
146 }
147
148 Ptr<Vector<Real>> getSolution(const int i = 0) const {
149 ROL::Ptr<std::vector<Real> > z_ptr = ROL::makePtr<std::vector<Real>>(4, 0.0);
150 (*z_ptr)[0] = 0.0; (*z_ptr)[1] = 1.0;
151 (*z_ptr)[2] = 2.0; (*z_ptr)[3] = -1.0;
152 return makePtr<StdVector<Real>>(z_ptr);
153 }
154};
155
156} // namespace ZOO
157} // namespace ROL
158
159#endif
Contains definitions of test objective functions.
Provides the interface to evaluate objective functions.
Provides the ROL::Vector interface for scalar values, to be used, for example, with scalar constraint...
Defines the linear algebra or vector space interface.
Definition: ROL_Vector.hpp:84
StdVector< Real > SV
Real value(const Vector< Real > &x, Real &tol)
Compute value.
ROL::Ptr< const vector > getVector(const V &x)
ROL::Ptr< vector > getVector(V &x)
std::vector< Real > vector
void gradient(Vector< Real > &g, const Vector< Real > &x, Real &tol)
Compute gradient.
Vector< Real > V
Ptr< Objective< Real > > getObjective(void) const
Ptr< Vector< Real > > getSolution(const int i=0) const
Ptr< Vector< Real > > getInitialGuess(void) const