ROL_RandVarFunctional.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//               Rapid Optimization Library (ROL) Package
//
// Copyright 2014 NTESS and the ROL contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef ROL_RANDVARFUNCTIONAL_HPP
#define ROL_RANDVARFUNCTIONAL_HPP
 
#include "ROL_Vector.hpp"
#include "ROL_Objective.hpp"
#include "ROL_Ptr.hpp"
#include "ROL_SampleGenerator.hpp"
#include "ROL_ScalarController.hpp"
#include "ROL_VectorController.hpp"
 
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);
  }
 
  virtual void resetStorage(bool flag = true) {
    if (storage_) {
      value_storage_->objectiveUpdate();
      if (flag) {
        gradient_storage_->objectiveUpdate();
        if (storage_hessvec_) {
          gradvec_storage_->objectiveUpdate();
          hessvec_storage_->objectiveUpdate();
        }
      }
    }
  }
  virtual void resetStorage(UpdateType type) {
    if (storage_) {
      value_storage_->objectiveUpdate(type);
      gradient_storage_->objectiveUpdate(type);
      if (storage_hessvec_) {
        gradvec_storage_->objectiveUpdate(type);
        hessvec_storage_->objectiveUpdate(type);
      }
    }
  }
 
  virtual void initialize(const Vector<Real> &x) {
    // Create memory for class members
    if ( firstReset_ ) {
      g_          = x.dual().clone();
      hv_         = x.dual().clone();
      dualVector_ = x.dual().clone();
      firstReset_ = false;
    }
    // Zero member variables
    const Real zero(0);
    val_ = zero; gv_ = zero;
    g_->zero(); hv_->zero(); dualVector_->zero();
    if (storage_hessvec_) {
      gradvec_storage_->reset();
      hessvec_storage_->reset();
    }
  }
 
  virtual void setSample(const std::vector<Real> &point, const Real weight) {
    point_.assign(point.begin(),point.end());
    weight_ = weight;
  }
 
  virtual Real computeStatistic(const Ptr<const std::vector<Real>> &xstat) const {
    Real stat(0);
    if (xstat != nullPtr && !xstat->empty()) {
      stat = (*xstat)[0];
    }
    return stat;
  }
 
  virtual void updateValue(Objective<Real>         &obj,
                           const Vector<Real>      &x,
                           const std::vector<Real> &xstat,
                           Real                    &tol) {
    Real val = computeValue(obj,x,tol);
    val_ += weight_ * val;
  }
 
  virtual void updateGradient(Objective<Real>         &obj,
                              const Vector<Real>      &x,
                              const std::vector<Real> &xstat,
                              Real                    &tol) {
    computeGradient(*dualVector_,obj,x,tol);
    g_->axpy(weight_,*dualVector_);
  }
 
  virtual 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) {
    computeHessVec(*dualVector_,obj,v,x,tol);
    hv_->axpy(weight_,*dualVector_);
  }
 
  virtual Real getValue(const Vector<Real>      &x,
                        const std::vector<Real> &xstat,
                        SampleGenerator<Real>   &sampler) {
    Real val(0);
    sampler.sumAll(&val_,&val,1);
    return val;
  }
 
  virtual void getGradient(Vector<Real>            &g,
                           std::vector<Real>       &gstat,
                           const Vector<Real>      &x,
                           const std::vector<Real> &xstat,
                           SampleGenerator<Real>   &sampler) {
    sampler.sumAll(*g_,g);
  }
 
  virtual 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) {
    sampler.sumAll(*hv_,hv);
  }
};
 
}
 
#endif