ROL_PrimalDualInteriorPointOperator.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_PRIMALDUALINTERIORPOINTOPERATOR_H
#define ROL_PRIMALDUALINTERIORPOINTOPERATOR_H
 
#include "ROL_LinearOperator.hpp"
 
 
namespace ROL { 
 
 
 
template<class Real> 
class PrimalDualInteriorPointBlock11 : public LinearOperator<Real> {
 
  typedef Vector<Real>             V;
  typedef PartitionedVector<Real>  PV;
  typedef Objective<Real>          OBJ;
  typedef Constraint<Real> CON;      
 
  static const size_type OPT   = 0;
  static const size_type EQUAL = 1;
  static const size_type LOWER = 0;
  static const size_type UPPER = 1;
 
  ROL::Ptr<const V>   x_;            // Optimization vector
  ROL::Ptr<const V>   l_;            //  constraint multiplier
 
  ROL::Ptr<V> scratch_;
 
  Real delta_; // Initial correction
 
 
public: 
 
  PrimalDualInteriorPointBlock11( ROL::Ptr<OBJ> &obj, ROL::Ptr<CON> &con, 
                           const V &x, ROL::Ptr<V> & scratch, 
                           Real delta=0 ) : 
    obj_(obj), con_(con), scratch_(scratch), delta_(delta) { 
 
    const PV &x_pv = dynamic_cast<const PV&>(x);
 
    x_  = x_pv.get(OPT);
    l_  = x_pv.get(EQUAL);
  }
 
  void update( const Vector<Real> &x, bool flag = true, int iter = -1 ) {
 
    const PV &x_pv = dynamic_cast<const PV&>(x);
    
    x_  = x_pv.get(OPT);
    l_  = x_pv.get(EQUAL);
 
    obj_->update(*x_,flag,true);
    con_->update(*x_,flag,true);  
  }
 
  void apply( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const {
 
    
 
    PV &Hv_pv = dynamic_cast<PV&>(Hv);
    const PV &v_pv = dynamic_cast<const PV&>(v);
 
    // output vector components
    ROL::Ptr<V> Hvx  = Hv_pv.get(OPT);
    ROL::Ptr<V> Hvl  = Hv_pv.get(EQUAL);
 
    // input vector components
    ROL::Ptr<const V> vx  = v_pv.get(OPT);
    ROL::Ptr<const V> vl  = v_pv.get(EQUAL); 
 
    obj_->hessVec(*jvx,*vx,*x_,tol);
    con_->applyAdjointHessian(*scratch_,*l_,*vx,*x_,tol);
    jvx->plus(*scratch_); 
    con_->applyAdjointJacobian(*scratch_,*vl,*x_,tol);
    jvx->plus(*scratch_);
 
    // Inertial correction
    if( delta_ != 0 ) {
      jvx->axpy(delta_,*vx);
    }
 
    con_->applyJacobian(*jvl,*vx,*x_,tol);
 
  }
 
  void applyInverse( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const {
     ROL_TEST_FOR_EXCEPTION( true , std::logic_error, 
                                ">>> ERROR (ROL_PrimalDualInteriorPointBlock11, applyInverse): "
                                "Not implemented.");    
  }
  
  void setInertia( Real delta ) { 
    delta_ = delta;
  }
 
 
};  // class PrimalDualInteriorPointBlock11
 
 
template<class Real> 
class PrimalDualInteriorPointBlock12 : public LinearOperator<Real> {
 
  typedef Vector<Real>             V;
  typedef PartitionedVector<Real>  PV;
 
  static const size_type OPT   = 0;
  static const size_type EQUAL = 1;
  static const size_type LOWER = 0;
  static const size_type UPPER = 1;
 
public:
 
  void apply( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const { 
    
 
    PV &Hv_pv = dynamic_cast<PV&>(Hv);
    const PV &v_pv = dynamic_cast<const PV&>(v);
 
    // output vector components
    ROL::Ptr<V> Hvx  = Hv_pv.get(OPT);
    ROL::Ptr<V> Hvl  = Hv_pv.get(EQUAL);
 
    // input vector components
    ROL::Ptr<const V> vzl  = v_pv.get(LOWER);
    ROL::Ptr<const V> vzu  = v_pv.get(UPPER); 
 
    Hvx->set(*vzu);
    Hvx->axpy(-1.0,*vzl);
    Hvl->zero();
   
  }
 
  void applyInverse( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const {
     ROL_TEST_FOR_EXCEPTION( true , std::logic_error, 
                                ">>> ERROR (ROL_PrimalDualInteriorPointBlock12, applyInverse): "
                                "Not implemented.");    
  }
 
 
};  // class PrimalDualInteriorPointBlock12
 
 
template<class Real> 
class PrimalDualInteriorPointBlock21 : public LinearOperator<Real> {
 
  typedef Vector<Real>             V;
  typedef PartitionedVector<Real>  PV;
 
  static const size_type OPT   = 0;
  static const size_type EQUAL = 1;
  static const size_type LOWER = 0;
  static const size_type UPPER = 1;
 
  ROL::Ptr<const V> zl_;
  ROL::Ptr<const V> zu_;
 
public:
 
  PrimalDualInteriorPointBlock21( const V &z ) {
    const PV &z_pv = dynamic_cast<const PV&>(z);
    zl_ = z_pv.get(LOWER);
    zu_ = z_pv.get(UPPER);  
  }
 
  void update( const Vector<Real> &z, bool flag = true, int iter = -1 ) {
    const PV &z_pv = dynamic_cast<const PV&>(z);
    zl_ = z_pv.get(LOWER);
    zu_ = z_pv.get(UPPER);  
  } 
 
  virtual void apply( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const { 
    
 
    PV &Hv_pv = dynamic_cast<PV&>(Hv);
    const PV &v_pv = dynamic_cast<const PV&>(v);
 
    // output vector components
    ROL::Ptr<V> Hvzl  = Hv_pv.get(LOWER);
    ROL::Ptr<V> Hvzu  = Hv_pv.get(UPPER);
 
    // input vector components
    ROL::Ptr<const V> vx  = v_pv.get(OPT);
    ROL::Ptr<const V> vl  = v_pv.get(EQUAL); 
 
    Hvzl->set(*vx);
    Hvzl->applyBinary(mult_,*zl_);
 
    Hvzu->set(*vx);
    Hvzu->applyBinary(mult_,*zu_);
    Hvzu->scale(-1.0); 
  }
 
  virtual void applyInverse( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const {
     ROL_TEST_FOR_EXCEPTION( true , std::logic_error, 
                                ">>> ERROR (ROL_PrimalDualInteriorPointBlock21, applyInverse): "
                                "Not implemented.");    
  }
 
};  // class PrimalDualInteriorPointBlock21
 
 
template<class Real> 
class PrimalDualInteriorPointBlock22 : public LinearOperator<Real> {
 
  typedef Vector<Real>             V;
  typedef PartitionedVector<Real>  PV;
  typedef BoundConstraint<Real>    BND;      
 
  static const size_type OPT   = 0;
  static const size_type LOWER = 0;
  static const size_type UPPER = 1;
 
  ROL::Ptr<const V> x_;
  ROL::Ptr<const V> xl_;
  ROL::Ptr<const V> xu_;
 
  Elementwise::Multiply<Real> mult_;
  Elementwise::Multiply<Real> divinv_;
 
 
public:
 
  PrimalDualInteriorPointBlock22( const ROL::Ptr<BND> &bnd, const Vector<Real> &x ) {
 
    const PV &x_pv = dynamic_cast<const PV&>(x);
    
    x_  = x_pv.get(OPT);
    xl_ = bnd.getLowerBound();
    xu_ = bnd.getUpperBound();
 
  }
 
  virtual void update( const Vector<Real> &x, bool flag = true, int iter = -1 ) {
 
    const PV &x_pv = dynamic_cast<const PV&>(x);
    x_  = x_pv.get(OPT);
  }
 
  virtual void apply( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const { 
    
 
    PV &Hv_pv = dynamic_cast<PV&>(Hv);
    const PV &v_pv = dynamic_cast<const PV&>(v);
 
    // output vector components
    ROL::Ptr<V> Hvzl  = Hv_pv.get(LOWER);
    ROL::Ptr<V> Hvzu  = Hv_pv.get(UPPER);
 
    // input vector components
    ROL::Ptr<const V> vzl = v_pv.get(LOWER);
    ROL::Ptr<const V> vzu = v_pv.get(UPPER); 
 
    Hvzl->set(*x_);
    Hvzl->axpy(-1.0,*xl_);
    Hvzl->applyBinary(mult_,*vzl);
 
    Hvzu->set(*xu_);
    Hvzu->axpy(-1.0,*x_);
    Hvzu->applyBinary(mult_,*vzu);
 
  }
 
  virtual void applyInverse( Vector<Real> &Hv, const Vector<Real> &v, Real &tol ) const {
 
    
 
    PV &Hv_pv = dynamic_cast<PV&>(Hv);
    const PV &v_pv = dynamic_cast<const PV&>(v);
 
    // output vector components
    ROL::Ptr<V> Hvzl  = Hv_pv.get(LOWER);
    ROL::Ptr<V> Hvzu  = Hv_pv.get(UPPER);
 
    // input vector components
    ROL::Ptr<const V> vzl = v_pv.get(LOWER);
    ROL::Ptr<const V> vzu = v_pv.get(UPPER); 
 
    Hvzl->set(*x_);
    Hvzl->axpy(-1.0,*xl_);
    Hvzl->applyBinary(divinv_,*vzl); // Hvzl = vzl/(x-xl)
 
    Hvzu->set(*xu_);
    Hvzu->axpy(-1.0,*x_);
    Hvzu->applyBinary(divinv_,*vzu); // Hvzu = vzu/(xu-x)
  }
 
};  // class PrimalDualInteriorPointBlock22
 
 
} // namespace ROL
 
 
 
#endif  // ROL_PRIMALDUALINTERIORPOINTOPERATOR_H