ROL_BoundConstraint.hpp

Go to the documentation of this file.

// @HEADER
// ************************************************************************
//
//               Rapid Optimization Library (ROL) Package
//                 Copyright (2014) Sandia Corporation
//
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact lead developers:
//              Drew Kouri   (dpkouri@sandia.gov) and
//              Denis Ridzal (dridzal@sandia.gov)
//
// ************************************************************************
// @HEADER

#ifndef ROL_BOUND_CONSTRAINT_H
#define ROL_BOUND_CONSTRAINT_H

#include "ROL_Vector.hpp"
#include "ROL_Types.hpp"
#include <iostream>

namespace ROL {

template <class Real>
class BoundConstraint {
private:
  bool Lactivated_; 
  bool Uactivated_; 
  Ptr<Vector<Real> > lower_;
  Ptr<Vector<Real> > upper_;
  bool hasSetScalar_;

public:

  virtual ~BoundConstraint() {}

  BoundConstraint(void) : Lactivated_(true), Uactivated_(true), hasSetScalar_(false) {}

  BoundConstraint(const Vector<Real> &x) : Lactivated_(false), Uactivated_(false), hasSetScalar_(false) {
    try {
      lower_ = x.clone(); lower_->setScalar(ROL_NINF<Real>());
      upper_ = x.clone(); upper_->setScalar(ROL_INF<Real>());
      hasSetScalar_ = true;
    }
    catch(std::exception &e) {
      hasSetScalar_ = false;
      // Do nothing.  If someone calls getLowerBound or getUpperBound,
      // an exception will be thrown.
    }
  }


  // REQUIRED FUNCTIONS (VIRTUAL)

  virtual void update( const Vector<Real> &x, bool flag = true, int iter = -1 ) {}

  virtual void project( Vector<Real> &x ) {
    if (isActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::project: Not Implemented!");
    }
  }

  virtual void projectInterior( Vector<Real> &x ) {
    if (isActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::projectInterior: Not Implemented!");
    }
  }

  virtual void pruneUpperActive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) {
    if (isUpperActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::pruneUpperActive: Not Implemented!");
    }
  }

  virtual void pruneUpperActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) {
    if (isUpperActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::pruneUpperActive: Not Implemented!");
    }
  }

  virtual void pruneLowerActive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) {
    if (isLowerActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::pruneLowerActive: Not Implemented!");
    }
  }

  virtual void pruneLowerActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) {
    if (isLowerActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::pruneLowerActive: Not Implemented!");
    }
  }


  // QUERY FUNCTIONS (VIRTUAL AND NONVIRTUAL)

  virtual const ROL::Ptr<const Vector<Real> > getLowerBound( void ) const {
    if (hasSetScalar_) {
      return lower_;
    }
    throw Exception::NotImplemented(">>> ROL::BoundConstraint::getLowerBound: Not implemented!");
  }

  virtual const ROL::Ptr<const Vector<Real> > getUpperBound( void ) const {
    if (hasSetScalar_) {
      return upper_;
    }
    throw Exception::NotImplemented(">>> ROL::BoundConstraint::getUpperBound: Not implemented!");
  }

  virtual bool isFeasible( const Vector<Real> &v ) { 
    if (isActivated()) {
      throw Exception::NotImplemented(">>> ROL::BoundConstraint::isFeasible: Not implemented!");
    }
    return true;
  }

  void activateLower(void) {
    Lactivated_ = true;
  }

  void activateUpper(void) {
    Uactivated_ = true;
  }

  void activate(void) {
    activateLower();
    activateUpper();
  }

  void deactivateLower(void) {
    Lactivated_ = false;
  }

  void deactivateUpper(void) {
    Uactivated_ = false;
  }

  void deactivate(void) {
    deactivateLower();
    deactivateUpper();
  }

  bool isLowerActivated(void) const {
    return Lactivated_;
  }

  bool isUpperActivated(void) const {
    return Uactivated_;
  }

  bool isActivated(void) const {
    return (isLowerActivated() || isUpperActivated());
  }


  // HELPER FUNCTIONS (NONVIRTUAL)

  void pruneActive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) {
    if (isActivated()) {
      pruneUpperActive(v,x,eps);
      pruneLowerActive(v,x,eps);
    }
  }

  void pruneActive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) {
    if (isActivated()) {
      pruneUpperActive(v,g,x,eps);
      pruneLowerActive(v,g,x,eps);
    }
  }

  void pruneLowerInactive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) {
    if (isLowerActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneLowerActive(*tmp,x,eps);
      v.axpy(-one,*tmp);
    }
  }

  void pruneUpperInactive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) { 
    if (isUpperActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneUpperActive(*tmp,x,eps);
      v.axpy(-one,*tmp);
    }
  }

  void pruneLowerInactive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) { 
    if (isLowerActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneLowerActive(*tmp,g,x,eps);
      v.axpy(-one,*tmp);
    }
  }

  void pruneUpperInactive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) { 
    if (isUpperActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneUpperActive(*tmp,g,x,eps);
      v.axpy(-one,*tmp);
    }
  }

  void pruneInactive( Vector<Real> &v, const Vector<Real> &x, Real eps = 0 ) { 
    if (isActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneActive(*tmp,x,eps);
      v.axpy(-one,*tmp);
    }
  }

  void pruneInactive( Vector<Real> &v, const Vector<Real> &g, const Vector<Real> &x, Real eps = 0 ) { 
    if (isActivated()) {
      const Real one(1);
      ROL::Ptr<Vector<Real> > tmp = v.clone(); 
      tmp->set(v);
      pruneActive(*tmp,g,x,eps);
      v.axpy(-one,*tmp);
    }
  }
 
  void computeProjectedGradient( Vector<Real> &g, const Vector<Real> &x ) {
    if (isActivated()) {
      ROL::Ptr<Vector<Real> > tmp = g.clone();
      tmp->set(g);
      pruneActive(g,*tmp,x);
    }
  }
 
  void computeProjectedStep( Vector<Real> &v, const Vector<Real> &x ) { 
    if (isActivated()) {
      const Real one(1);
      v.plus(x);
      project(v);
      v.axpy(-one,x);
    }
  }

}; // class BoundConstraint

} // namespace ROL

#endif