Provides the interface to implement any functional that maps a random variable to a (extended) real number. More...

#include <ROL_RandVarFunctional.hpp>

Detailed Description

Provides the interface to implement any functional that maps a random variable to a (extended) real number.

Let \((\Omega,\mathcal{F},\mathbb{P})\) be a probability space. Here, \(\Omega\) is the set of outcomes, \(\mathcal{F}\subseteq 2^\Omega\) is a \(\sigma\)-algebra of events and \(\mathbb{P}:\mathcal{F}\to[0,1]\) is a probability measure. Moreover, let \(\mathcal{X}\) be a class of random variables. A ``random variable functional'' is an extended real-valued functional that associates numerical values to random variables, i.e., \(\mathcal{R}:\mathcal{X}\to\mathbb{R}\cup\{+\infty\}\). In most cases, \(\mathcal{X} = L^p(\Omega,\mathcal{F},\mathbb{P})\) for some \(1\le p\le \infty\).

ROL's random variable functional base class is written in a way to exploit parallel sampling. General risk measures may depend on global information such as the expected value of a random variable, \(\mathbb{E}[X]\). Thus, ROL::RandVarFunctional contains functions to update intermediate information and to compute desired quantities such as values, gradients and Hessians applied to vectors. */

namespace ROL {

template<class Real> class RandVarFunctional { private: bool storage_; bool storage_hessvec_; Ptr<ScalarController<Real>> value_storage_; Ptr<VectorController<Real>> gradient_storage_; Ptr<ScalarController<Real>> gradvec_storage_; Ptr<VectorController<Real>> hessvec_storage_;

protected: Real val_; Real gv_; Ptr<Vector<Real> > g_; Ptr<Vector<Real> > hv_; Ptr<Vector<Real> > dualVector_; bool firstReset_;

std::vector<Real> point_; Real weight_;

Evaluate objective function at current parameter Real computeValue(Objective<Real> &obj, const Vector<Real> &x, Real &tol) { Real val(0); bool isComputed = false; if (storage_) { isComputed = value_storage_->get(val,point_); } if (!isComputed || !storage_) { obj.setParameter(point_); val = obj.value(x,tol); if (storage_) { value_storage_->set(val,point_); } } return val; }

Evaluate gradient of objective function at current parameter void computeGradient(Vector<Real> &g, Objective<Real> &obj, const Vector<Real> &x, Real &tol) { bool isComputed = false; if (storage_) { isComputed = gradient_storage_->get(g,point_); } if (!isComputed || !storage_) { obj.setParameter(point_); obj.gradient(g,x,tol); if ( storage_ ) { gradient_storage_->set(g,point_); } } }

Evaluate Gradient-times-a-vector at current parameter Real computeGradVec(Vector<Real> &g, Objective<Real> &obj, const Vector<Real> &v, const Vector<Real> &x, Real &tol) { Real gv(0); computeGradient(g,obj,x,tol); bool isComputed = false; if (storage_hessvec_) { isComputed = gradvec_storage_->get(gv,point_); } if (!isComputed || !storage_hessvec_) { gv = g.dot(v.dual()); gv = g.apply(v); if (storage_hessvec_) { gradvec_storage_->set(gv,point_); } } return gv; }

Evaluate Hessian-times-a-vector at current parameter void computeHessVec(Vector<Real> &hv, Objective<Real> &obj, const Vector<Real> &v, const Vector<Real> &x, Real &tol) { bool isComputed = false; if (storage_hessvec_) { isComputed = hessvec_storage_->get(hv,point_); } if (!isComputed || !storage_hessvec_) { obj.setParameter(point_); obj.hessVec(hv,v,x,tol); if (storage_hessvec_) { hessvec_storage_->set(hv,point_); } } }

public: virtual ~RandVarFunctional() {}

RandVarFunctional(void) : storage_(false), storage_hessvec_(false), value_storage_(nullPtr), gradient_storage_(nullPtr), gradvec_storage_(nullPtr), hessvec_storage_(nullPtr), val_(0), gv_(0), firstReset_(true), point_({}), weight_(0) {}

void useStorage(bool storage) { storage_ = storage; if (storage) { if (value_storage_ == nullPtr) { value_storage_ = makePtr<ScalarController<Real>>(); } if (gradient_storage_ == nullPtr) { gradient_storage_ = makePtr<VectorController<Real>>(); } } }

void useHessVecStorage(bool storage) { storage_hessvec_ = storage; if (storage) { useStorage(storage); if (gradvec_storage_ == nullPtr) { gradvec_storage_ = makePtr<ScalarController<Real>>(); } if (hessvec_storage_ == nullPtr) { hessvec_storage_ = makePtr<VectorController<Real>>(); } } }

virtual void setStorage(const Ptr<ScalarController<Real>> &value_storage, const Ptr<VectorController<Real>> &gradient_storage) { value_storage_ = value_storage; gradient_storage_ = gradient_storage; useStorage(true); }

virtual void setHessVecStorage(const Ptr<ScalarController<Real>> &gradvec_storage, const Ptr<VectorController<Real>> &hessvec_storage) { gradvec_storage_ = gradvec_storage; hessvec_storage_ = hessvec_storage; useHessVecStorage(true); }

/** Reset internal storage.

     @param[in]   x  is a vector used for initializing storage

The documentation for this class was generated from the following file:

ROL_RandVarFunctional.hpp