ROL
ROL_MeanDeviation.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 
10 #ifndef ROL_MEANDEVIATION_HPP
11 #define ROL_MEANDEVIATION_HPP
12 
13 #include "ROL_RandVarFunctional.hpp"
14 #include "ROL_ParameterList.hpp"
15 #include "ROL_PositiveFunction.hpp"
16 #include "ROL_PlusFunction.hpp"
17 #include "ROL_AbsoluteValue.hpp"
18 
43 namespace ROL {
44 
45 template<class Real>
46 class MeanDeviation : public RandVarFunctional<Real> {
47  typedef typename std::vector<Real>::size_type uint;
48 private:
49  Ptr<PositiveFunction<Real> > positiveFunction_;
50  std::vector<Real> order_;
51  std::vector<Real> coeff_;
52  uint NumMoments_;
53 
54  std::vector<Real> dev0_;
55  std::vector<Real> dev1_;
56  std::vector<Real> dev2_;
57  std::vector<Real> dev3_;
58  std::vector<Real> des0_;
59  std::vector<Real> des1_;
60  std::vector<Real> des2_;
61  std::vector<Real> des3_;
62  std::vector<Real> devp_;
63  std::vector<Real> gvp1_;
64  std::vector<Real> gvp2_;
65  std::vector<Real> gvp3_;
66  std::vector<Real> gvs1_;
67  std::vector<Real> gvs2_;
68  std::vector<Real> gvs3_;
69 
70  Ptr<ScalarController<Real>> values_;
71  Ptr<ScalarController<Real>> gradvecs_;
72  Ptr<VectorController<Real>> gradients_;
73  Ptr<VectorController<Real>> hessvecs_;
74 
75  using RandVarFunctional<Real>::val_;
76  using RandVarFunctional<Real>::gv_;
77  using RandVarFunctional<Real>::g_;
78  using RandVarFunctional<Real>::hv_;
79  using RandVarFunctional<Real>::dualVector_;
80 
81  using RandVarFunctional<Real>::point_;
82  using RandVarFunctional<Real>::weight_;
83 
84  using RandVarFunctional<Real>::computeValue;
85  using RandVarFunctional<Real>::computeGradient;
86  using RandVarFunctional<Real>::computeGradVec;
87  using RandVarFunctional<Real>::computeHessVec;
88 
89  void initializeStorage(void) {
90  NumMoments_ = order_.size();
91 
92  dev0_.clear(); dev1_.clear(); dev2_.clear(); dev3_.clear();
93  des0_.clear(); des1_.clear(); des2_.clear(); des3_.clear();
94  devp_.clear();
95  gvp1_.clear(); gvp2_.clear(); gvp3_.clear();
96  gvs1_.clear(); gvs2_.clear(); gvs3_.clear();
97 
98  dev0_.resize(NumMoments_); dev1_.resize(NumMoments_);
99  dev2_.resize(NumMoments_); dev3_.resize(NumMoments_);
100  des0_.resize(NumMoments_); des1_.resize(NumMoments_);
101  des2_.resize(NumMoments_); des3_.resize(NumMoments_);
102  devp_.resize(NumMoments_);
103  gvp1_.resize(NumMoments_); gvp2_.resize(NumMoments_);
104  gvp3_.resize(NumMoments_);
105  gvs1_.resize(NumMoments_); gvs2_.resize(NumMoments_);
106  gvs3_.resize(NumMoments_);
107 
108  values_ = makePtr<ScalarController<Real>>();
109  gradvecs_ = makePtr<ScalarController<Real>>();
110  gradients_ = makePtr<VectorController<Real>>();
111  hessvecs_ = makePtr<VectorController<Real>>();
112 
113  RandVarFunctional<Real>::setStorage(values_,gradients_);
114  RandVarFunctional<Real>::setHessVecStorage(gradvecs_,hessvecs_);
115  }
116 
117  void clear(void) {
118  const Real zero(0);
119  dev0_.assign(NumMoments_,zero); dev1_.assign(NumMoments_,zero);
120  dev2_.assign(NumMoments_,zero); dev3_.assign(NumMoments_,zero);
121  des0_.assign(NumMoments_,zero); des1_.assign(NumMoments_,zero);
122  des2_.assign(NumMoments_,zero); des3_.assign(NumMoments_,zero);
123  devp_.assign(NumMoments_,zero);
124  gvp1_.assign(NumMoments_,zero); gvp2_.assign(NumMoments_,zero);
125  gvp3_.assign(NumMoments_,zero);
126  gvs1_.assign(NumMoments_,zero); gvs2_.assign(NumMoments_,zero);
127  gvs3_.assign(NumMoments_,zero);
128 
129  gradvecs_->reset();
130  hessvecs_->reset();
131  }
132 
133  void checkInputs(void) {
134  int oSize = order_.size(), cSize = coeff_.size();
135  ROL_TEST_FOR_EXCEPTION((oSize!=cSize),std::invalid_argument,
136  ">>> ERROR (ROL::MeanDeviation): Order and coefficient arrays have different sizes!");
137  Real zero(0), two(2);
138  for (int i = 0; i < oSize; i++) {
139  ROL_TEST_FOR_EXCEPTION((order_[i] < two), std::invalid_argument,
140  ">>> ERROR (ROL::MeanDeviation): Element of order array out of range!");
141  ROL_TEST_FOR_EXCEPTION((coeff_[i] < zero), std::invalid_argument,
142  ">>> ERROR (ROL::MeanDeviation): Element of coefficient array out of range!");
143  }
144  ROL_TEST_FOR_EXCEPTION(positiveFunction_ == nullPtr, std::invalid_argument,
145  ">>> ERROR (ROL::MeanDeviation): PositiveFunction pointer is null!");
146  initializeStorage();
147  }
148 
149 public:
159  MeanDeviation( const Real order, const Real coeff,
160  const Ptr<PositiveFunction<Real> > &pf )
161  : RandVarFunctional<Real>(), positiveFunction_(pf) {
162  order_.clear(); order_.push_back(order);
163  coeff_.clear(); coeff_.push_back(coeff);
164  checkInputs();
165  }
166 
176  MeanDeviation( const std::vector<Real> &order,
177  const std::vector<Real> &coeff,
178  const Ptr<PositiveFunction<Real> > &pf )
179  : RandVarFunctional<Real>(), positiveFunction_(pf) {
180  order_.clear(); coeff_.clear();
181  for ( uint i = 0; i < order.size(); i++ ) {
182  order_.push_back(order[i]);
183  }
184  for ( uint i = 0; i < coeff.size(); i++ ) {
185  coeff_.push_back(coeff[i]);
186  }
187  checkInputs();
188  }
189 
201  MeanDeviation( ROL::ParameterList &parlist )
202  : RandVarFunctional<Real>() {
203  ROL::ParameterList &list
204  = parlist.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation");
205 
206  // Get data from parameter list
207  order_ = ROL::getArrayFromStringParameter<double>(list,"Orders");
208 
209  coeff_ = ROL::getArrayFromStringParameter<double>(list,"Coefficients");
210 
211  // Build (approximate) positive function
212  std::string type = list.get<std::string>("Deviation Type");
213  if ( type == "Upper" ) {
214  positiveFunction_ = makePtr<PlusFunction<Real>>(list);
215  }
216  else if ( type == "Absolute" ) {
217  positiveFunction_ = makePtr<AbsoluteValue<Real>>(list);
218  }
219  else {
220  ROL_TEST_FOR_EXCEPTION(true, std::invalid_argument,
221  ">>> (ROL::MeanDeviation): Deviation type is not recoginized!");
222  }
223  // Check inputs
224  checkInputs();
225  }
226 
227  void setStorage(const Ptr<ScalarController<Real>> &value_storage,
228  const Ptr<VectorController<Real>> &gradient_storage) {
229  values_ = value_storage;
230  gradients_ = gradient_storage;
231  RandVarFunctional<Real>::setStorage(values_,gradients_);
232  }
233 
234  void setHessVecStorage(const Ptr<ScalarController<Real>> &gradvec_storage,
235  const Ptr<VectorController<Real>> &hessvec_storage) {
236  gradvecs_ = gradvec_storage;
237  hessvecs_ = hessvec_storage;
238  RandVarFunctional<Real>::setHessVecStorage(gradvecs_,hessvecs_);
239  }
240 
241  void initialize(const Vector<Real> &x) {
242  RandVarFunctional<Real>::initialize(x);
243  clear();
244  }
245 
246  void updateValue(Objective<Real> &obj,
247  const Vector<Real> &x,
248  const std::vector<Real> &xstat,
249  Real &tol) {
250  Real val = computeValue(obj,x,tol);
251  val_ += weight_ * val;
252  }
253 
254  void updateGradient(Objective<Real> &obj,
255  const Vector<Real> &x,
256  const std::vector<Real> &xstat,
257  Real &tol) {
258  Real val = computeValue(obj,x,tol);
259  val_ += weight_ * val;
260  computeGradient(*dualVector_,obj,x,tol);
261  g_->axpy(weight_,*dualVector_);
262  }
263 
264  void updateHessVec(Objective<Real> &obj,
265  const Vector<Real> &v,
266  const std::vector<Real> &vstat,
267  const Vector<Real> &x,
268  const std::vector<Real> &xstat,
269  Real &tol) {
270  Real val = computeValue(obj,x,tol);
271  val_ += weight_ * val;
272  Real gv = computeGradVec(*dualVector_,obj,v,x,tol);
273  gv_ += weight_ * gv;
274  //g_->axpy(weight_,*dualVector_);
275  computeHessVec(*dualVector_,obj,v,x,tol);
276  //hv_->axpy(weight_,hv);
277  }
278 
279  Real getValue(const Vector<Real> &x,
280  const std::vector<Real> &xstat,
281  SampleGenerator<Real> &sampler) {
282  // Compute expected value
283  Real ev(0);
284  sampler.sumAll(&val_,&ev,1);
285  // Compute deviation
286  Real diff(0), pf0(0), dev(0), one(1), weight(0);
287  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
288  values_->get(diff,sampler.getMyPoint(i));
289  weight = sampler.getMyWeight(i);
290  diff -= ev;
291  pf0 = positiveFunction_->evaluate(diff,0);
292  for ( uint p = 0; p < NumMoments_; p++ ) {
293  dev0_[p] += std::pow(pf0,order_[p]) * weight;
294  }
295  }
296  sampler.sumAll(&dev0_[0],&des0_[0],NumMoments_);
297  for ( uint p = 0; p < NumMoments_; p++ ) {
298  dev += coeff_[p]*std::pow(des0_[p],one/order_[p]);
299  }
300  // Return mean plus deviation
301  return ev + dev;
302  }
303 
304  void getGradient(Vector<Real> &g,
305  std::vector<Real> &gstat,
306  const Vector<Real> &x,
307  const std::vector<Real> &xstat,
308  SampleGenerator<Real> &sampler) {
309  // Compute expected value
310  Real ev(0);
311  sampler.sumAll(&val_,&ev,1);
312  // Compute deviation
313  Real diff(0), pf0(0), pf1(0), c(0), one(1), zero(0), weight(0);
314  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
315  values_->get(diff,sampler.getMyPoint(i));
316  weight = sampler.getMyWeight(i);
317  diff -= ev;
318  pf0 = positiveFunction_->evaluate(diff,0);
319  pf1 = positiveFunction_->evaluate(diff,1);
320  for ( uint p = 0; p < NumMoments_; p++ ) {
321  dev0_[p] += weight * std::pow(pf0,order_[p]);
322  dev1_[p] += weight * std::pow(pf0,order_[p]-one) * pf1;
323  }
324  }
325  sampler.sumAll(&dev0_[0],&des0_[0],NumMoments_);
326  sampler.sumAll(&dev1_[0],&des1_[0],NumMoments_);
327  for ( uint p = 0; p < NumMoments_; p++ ) {
328  dev0_[p] = std::pow(des0_[p],one-one/order_[p]);
329  }
330  // Compute derivative
331  dualVector_->zero();
332  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
333  values_->get(diff,sampler.getMyPoint(i));
334  weight = sampler.getMyWeight(i);
335  diff -= ev;
336  pf0 = positiveFunction_->evaluate(diff,0);
337  pf1 = positiveFunction_->evaluate(diff,1);
338  c = zero;
339  for ( uint p = 0; p < NumMoments_; p++ ) {
340  if ( dev0_[p] > zero ) {
341  c += coeff_[p]/dev0_[p] * (std::pow(pf0,order_[p]-one)*pf1 - des1_[p]);
342  }
343  }
344  gradients_->get(*dualVector_,sampler.getMyPoint(i));
345  g_->axpy(weight*c,*dualVector_);
346  }
347  sampler.sumAll(*g_,g);
348  }
349 
350  void getHessVec(Vector<Real> &hv,
351  std::vector<Real> &hvstat,
352  const Vector<Real> &v,
353  const std::vector<Real> &vstat,
354  const Vector<Real> &x,
355  const std::vector<Real> &xstat,
356  SampleGenerator<Real> &sampler) {
357  // Compute expected value
358  std::vector<Real> myval(2), val(2);
359  myval[0] = val_;
360  myval[1] = gv_;
361  sampler.sumAll(&myval[0],&val[0],2);
362  Real ev = val[0], egv = val[1];
363  // Compute deviation
364  Real diff(0), pf0(0), pf1(0), pf2(0), zero(0), one(1), two(2);
365  Real cg(0), ch(0), diff1(0), diff2(0), diff3(0), weight(0), gv(0);
366  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
367  values_->get(diff,sampler.getMyPoint(i));
368  weight = sampler.getMyWeight(i);
369  diff -= ev;
370  pf0 = positiveFunction_->evaluate(diff,0);
371  pf1 = positiveFunction_->evaluate(diff,1);
372  pf2 = positiveFunction_->evaluate(diff,2);
373  for ( uint p = 0; p < NumMoments_; p++ ) {
374  dev0_[p] += weight * std::pow(pf0,order_[p]);
375  dev1_[p] += weight * std::pow(pf0,order_[p]-one) * pf1;
376  dev2_[p] += weight * std::pow(pf0,order_[p]-two) * pf1 * pf1;
377  dev3_[p] += weight * std::pow(pf0,order_[p]-one) * pf2;
378  }
379  }
380  sampler.sumAll(&dev0_[0],&des0_[0],NumMoments_);
381  sampler.sumAll(&dev1_[0],&des1_[0],NumMoments_);
382  sampler.sumAll(&dev2_[0],&des2_[0],NumMoments_);
383  sampler.sumAll(&dev3_[0],&des3_[0],NumMoments_);
384  for ( uint p = 0; p < NumMoments_; p++ ) {
385  devp_[p] = std::pow(des0_[p],two-one/order_[p]);
386  dev0_[p] = std::pow(des0_[p],one-one/order_[p]);
387  }
388  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
389  values_->get(diff,sampler.getMyPoint(i));
390  weight = sampler.getMyWeight(i);
391  diff -= ev;
392  gradvecs_->get(gv,sampler.getMyPoint(i));
393  pf0 = positiveFunction_->evaluate(diff,0);
394  pf1 = positiveFunction_->evaluate(diff,1);
395  pf2 = positiveFunction_->evaluate(diff,2);
396  for ( uint p = 0; p < NumMoments_; p++ ) {
397  gvp1_[p] += weight * (std::pow(pf0,order_[p]-one)*pf1-des1_[p]) *
398  (gv - egv);
399  gvp2_[p] += weight * (std::pow(pf0,order_[p]-two)*pf1*pf1-des2_[p]) *
400  (gv - egv);
401  gvp3_[p] += weight * (std::pow(pf0,order_[p]-one)*pf2-des3_[p]) *
402  (gv - egv);
403  }
404  }
405  sampler.sumAll(&gvp1_[0],&gvs1_[0],NumMoments_);
406  sampler.sumAll(&gvp2_[0],&gvs2_[0],NumMoments_);
407  sampler.sumAll(&gvp3_[0],&gvs3_[0],NumMoments_);
408  // Compute derivative
409  dualVector_->zero();
410  for (int i = sampler.start(); i < sampler.numMySamples(); ++i) {
411  values_->get(diff,sampler.getMyPoint(i));
412  weight = sampler.getMyWeight(i);
413  diff -= ev;
414  gradvecs_->get(gv,sampler.getMyPoint(i));
415  pf0 = positiveFunction_->evaluate(diff,0);
416  pf1 = positiveFunction_->evaluate(diff,1);
417  pf2 = positiveFunction_->evaluate(diff,2);
418  cg = one;
419  ch = zero;
420  for ( uint p = 0; p < NumMoments_; p++ ) {
421  if ( dev0_[p] > zero ) {
422  diff1 = std::pow(pf0,order_[p]-one)*pf1-des1_[p];
423  diff2 = std::pow(pf0,order_[p]-two)*pf1*pf1*(gv-egv)-gvs2_[p];
424  diff3 = std::pow(pf0,order_[p]-one)*pf2*(gv-egv)-gvs3_[p];
425  cg += coeff_[p]*diff1/dev0_[p];
426  ch += coeff_[p]*(((order_[p]-one)*diff2+diff3)/dev0_[p] -
427  (order_[p]-one)*gvs1_[p]*diff1/devp_[p]);
428  }
429  }
430  gradients_->get(*g_,sampler.getMyPoint(i));
431  dualVector_->axpy(weight*ch,*g_);
432  hessvecs_->get(*hv_,sampler.getMyPoint(i));
433  dualVector_->axpy(weight*cg,*hv_);
434  }
435  sampler.sumAll(*dualVector_,hv);
436  }
437 };
438 
439 }
440 
441 #endif
ROL::Objective
Provides the interface to evaluate objective functions.
Definition: ROL_Objective.hpp:44
ROL::RandVarFunctional::computeHessVec
void computeHessVec(Vector< Real > &hv, Objective< Real > &obj, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Definition: ROL_RandVarFunctional.hpp:122
size_type
typename PV< Real >::size_type size_type
Definition: ROL_Objective_SerialSimOpt.hpp:90
ROL::MeanDeviation::dev2_
std::vector< Real > dev2_
Definition: ROL_MeanDeviation.hpp:56
ROL::MeanDeviation::gvs3_
std::vector< Real > gvs3_
Definition: ROL_MeanDeviation.hpp:68
ROL::RandVarFunctional::g_
Ptr< Vector< Real > > g_
Definition: ROL_RandVarFunctional.hpp:59
ROL::MeanDeviation::updateValue
void updateValue(Objective< Real > &obj, const Vector< Real > &x, const std::vector< Real > &xstat, Real &tol)
Update internal storage for value computation.
Definition: ROL_MeanDeviation.hpp:246
ROL::MeanDeviation::MeanDeviation
MeanDeviation(const std::vector< Real > &order, const std::vector< Real > &coeff, const Ptr< PositiveFunction< Real > > &pf)
Constructor.
Definition: ROL_MeanDeviation.hpp:176
ROL::RandVarFunctional::computeValue
Real computeValue(Objective< Real > &obj, const Vector< Real > &x, Real &tol)
Definition: ROL_RandVarFunctional.hpp:68
ROL::MeanDeviation::setHessVecStorage
void setHessVecStorage(const Ptr< ScalarController< Real >> &gradvec_storage, const Ptr< VectorController< Real >> &hessvec_storage)
Definition: ROL_MeanDeviation.hpp:234
ROL::MeanDeviation::dev0_
std::vector< Real > dev0_
Definition: ROL_MeanDeviation.hpp:54
ROL::MeanDeviation::updateHessVec
void updateHessVec(Objective< Real > &obj, const Vector< Real > &v, const std::vector< Real > &vstat, const Vector< Real > &x, const std::vector< Real > &xstat, Real &tol)
Update internal risk measure storage for Hessian-time-a-vector computation.
Definition: ROL_MeanDeviation.hpp:264
ROL::RandVarFunctional::hv_
Ptr< Vector< Real > > hv_
Definition: ROL_RandVarFunctional.hpp:60
ROL::MeanDeviation::values_
Ptr< ScalarController< Real > > values_
Definition: ROL_MeanDeviation.hpp:70
ROL::MeanDeviation::getGradient
void getGradient(Vector< Real > &g, std::vector< Real > &gstat, const Vector< Real > &x, const std::vector< Real > &xstat, SampleGenerator< Real > &sampler)
Return risk measure (sub)gradient.
Definition: ROL_MeanDeviation.hpp:304
ROL::MeanDeviation::uint
std::vector< Real >::size_type uint
Definition: ROL_MeanDeviation.hpp:47
ROL::MeanDeviation::dev3_
std::vector< Real > dev3_
Definition: ROL_MeanDeviation.hpp:57
ROL::MeanDeviation::MeanDeviation
MeanDeviation(const Real order, const Real coeff, const Ptr< PositiveFunction< Real > > &pf)
Constructor.
Definition: ROL_MeanDeviation.hpp:159
ROL::SampleGenerator::getMyPoint
virtual std::vector< Real > getMyPoint(const int i) const
Definition: ROL_SampleGenerator.hpp:78
ROL_PositiveFunction.hpp
ROL::SampleGenerator::getMyWeight
virtual Real getMyWeight(const int i) const
Definition: ROL_SampleGenerator.hpp:82
ROL::RandVarFunctional::dualVector_
Ptr< Vector< Real > > dualVector_
Definition: ROL_RandVarFunctional.hpp:61
ROL::MeanDeviation::des0_
std::vector< Real > des0_
Definition: ROL_MeanDeviation.hpp:58
ROL_RandVarFunctional.hpp
ROL::RandVarFunctional::setStorage
virtual void setStorage(const Ptr< ScalarController< Real >> &value_storage, const Ptr< VectorController< Real >> &gradient_storage)
Definition: ROL_RandVarFunctional.hpp:174
ROL::Vector
Defines the linear algebra or vector space interface.
Definition: ROL_Vector.hpp:46
ROL::SampleGenerator::numMySamples
virtual int numMySamples(void) const
Definition: ROL_SampleGenerator.hpp:74
ROL::MeanDeviation::MeanDeviation
MeanDeviation(ROL::ParameterList &parlist)
Constructor.
Definition: ROL_MeanDeviation.hpp:201
ROL::SampleGenerator::sumAll
void sumAll(Real *input, Real *output, int dim) const
Definition: ROL_SampleGenerator.hpp:94
zero
Objective_SerialSimOpt(const Ptr< Obj > &obj, const V &ui) z0_ zero()
Definition: ROL_Objective_SerialSimOpt.hpp:111
ROL::MeanDeviation
Provides an interface for the mean plus a sum of arbitrary order deviations.
Definition: ROL_MeanDeviation.hpp:46
ROL::MeanDeviation::gvp3_
std::vector< Real > gvp3_
Definition: ROL_MeanDeviation.hpp:65
ROL::MeanDeviation::order_
std::vector< Real > order_
Definition: ROL_MeanDeviation.hpp:50
ROL::MeanDeviation::getHessVec
void getHessVec(Vector< Real > &hv, std::vector< Real > &hvstat, const Vector< Real > &v, const std::vector< Real > &vstat, const Vector< Real > &x, const std::vector< Real > &xstat, SampleGenerator< Real > &sampler)
Return risk measure Hessian-times-a-vector.
Definition: ROL_MeanDeviation.hpp:350
ROL::MeanDeviation::initialize
void initialize(const Vector< Real > &x)
Initialize temporary variables.
Definition: ROL_MeanDeviation.hpp:241
ROL::MeanDeviation::gvp2_
std::vector< Real > gvp2_
Definition: ROL_MeanDeviation.hpp:64
ROL::MeanDeviation::gradvecs_
Ptr< ScalarController< Real > > gradvecs_
Definition: ROL_MeanDeviation.hpp:71
ROL::MeanDeviation::des3_
std::vector< Real > des3_
Definition: ROL_MeanDeviation.hpp:61
ROL::MeanDeviation::dev1_
std::vector< Real > dev1_
Definition: ROL_MeanDeviation.hpp:55
ROL::MeanDeviation::updateGradient
void updateGradient(Objective< Real > &obj, const Vector< Real > &x, const std::vector< Real > &xstat, Real &tol)
Update internal risk measure storage for gradient computation.
Definition: ROL_MeanDeviation.hpp:254
ROL::MeanDeviation::des2_
std::vector< Real > des2_
Definition: ROL_MeanDeviation.hpp:60
ROL::MeanDeviation::devp_
std::vector< Real > devp_
Definition: ROL_MeanDeviation.hpp:62
ROL::MeanDeviation::getValue
Real getValue(const Vector< Real > &x, const std::vector< Real > &xstat, SampleGenerator< Real > &sampler)
Return risk measure value.
Definition: ROL_MeanDeviation.hpp:279
ROL::RandVarFunctional::computeGradient
void computeGradient(Vector< Real > &g, Objective< Real > &obj, const Vector< Real > &x, Real &tol)
Definition: ROL_RandVarFunctional.hpp:86
ROL::MeanDeviation::setStorage
void setStorage(const Ptr< ScalarController< Real >> &value_storage, const Ptr< VectorController< Real >> &gradient_storage)
Definition: ROL_MeanDeviation.hpp:227
ROL::MeanDeviation::gvs2_
std::vector< Real > gvs2_
Definition: ROL_MeanDeviation.hpp:67
ROL::RandVarFunctional::computeGradVec
Real computeGradVec(Vector< Real > &g, Objective< Real > &obj, const Vector< Real > &v, const Vector< Real > &x, Real &tol)
Definition: ROL_RandVarFunctional.hpp:102
ROL::RandVarFunctional
Provides the interface to implement any functional that maps a random variable to a (extended) real n...
Definition: ROL_RandVarFunctional.hpp:47
ROL_PlusFunction.hpp
ROL::MeanDeviation::gradients_
Ptr< VectorController< Real > > gradients_
Definition: ROL_MeanDeviation.hpp:72
ROL_AbsoluteValue.hpp
ROL::MeanDeviation::des1_
std::vector< Real > des1_
Definition: ROL_MeanDeviation.hpp:59
ROL::RandVarFunctional::setHessVecStorage
virtual void setHessVecStorage(const Ptr< ScalarController< Real >> &gradvec_storage, const Ptr< VectorController< Real >> &hessvec_storage)
Definition: ROL_RandVarFunctional.hpp:181
ROL::MeanDeviation::gvp1_
std::vector< Real > gvp1_
Definition: ROL_MeanDeviation.hpp:63
ROL::MeanDeviation::coeff_
std::vector< Real > coeff_
Definition: ROL_MeanDeviation.hpp:51
ROL::MeanDeviation::hessvecs_
Ptr< VectorController< Real > > hessvecs_
Definition: ROL_MeanDeviation.hpp:73
ROL::RandVarFunctional::initialize
virtual void initialize(const Vector< Real > &x)
Initialize temporary variables.
Definition: ROL_RandVarFunctional.hpp:219
ROL::MeanDeviation::gvs1_
std::vector< Real > gvs1_
Definition: ROL_MeanDeviation.hpp:66
ROL::MeanDeviation::positiveFunction_
Ptr< PositiveFunction< Real > > positiveFunction_
Definition: ROL_MeanDeviation.hpp:49
Generated by   doxygen 1.8.5