NLPInterfacePack_NLP.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) 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 Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef NLP_H
#define NLP_H

#include <stdexcept>
#include <string>

#include "NLPInterfacePack_Types.hpp"
#include "AbstractLinAlgPack_VectorMutable.hpp"
#include "AbstractLinAlgPack_Permutation.hpp"
#include "StandardCompositionRelationshipsPack.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_VerboseObject.hpp"

namespace OptionsFromStreamPack {
  class OptionsFromStream;
}

namespace NLPInterfacePack {

class NLP : virtual public Teuchos::VerboseObject<NLP> {
public:
  
  typedef AbstractLinAlgPack::Vector         Vector;         // doxygen likes typedef?
  typedef AbstractLinAlgPack::VectorMutable  VectorMutable;  // doxygen likes typedef?
  
  typedef Teuchos::RCP<const VectorSpace>  vec_space_ptr_t;

  typedef Teuchos::RCP<
    const OptionsFromStreamPack::OptionsFromStream>             options_ptr_t;


  class UnInitialized : public std::logic_error
  {public: UnInitialized(const std::string& what_arg) : std::logic_error(what_arg) {}};

  class InvalidInitialization : public std::logic_error
  {public: InvalidInitialization(const std::string& what_arg) : std::logic_error(what_arg) {}};

  class IncompatibleType : public std::logic_error
  {public: IncompatibleType(const std::string& what_arg) : std::logic_error(what_arg) {}};

  class NoBounds : public std::logic_error
  {public: NoBounds(const std::string& what_arg) : std::logic_error(what_arg) {}};


  static value_type infinite_bound();


  NLP();
  virtual ~NLP();

  

  virtual void force_xinit_in_bounds(bool force_xinit_in_bounds) = 0;
  virtual bool force_xinit_in_bounds() const = 0;
  virtual void set_options( const options_ptr_t& options );
  virtual const options_ptr_t& get_options() const;
  virtual void initialize( bool test_setup = false );
  virtual bool is_initialized() const = 0;



  virtual size_type n() const;
  virtual size_type m() const;



  virtual vec_space_ptr_t space_x() const = 0;
  virtual vec_space_ptr_t space_c() const = 0;



  virtual size_type num_bounded_x() const = 0;
  virtual const Vector& xl() const = 0;
  virtual const Vector& xu() const = 0;

  virtual value_type max_var_bounds_viol() const = 0;



  virtual const Vector& xinit() const = 0;
  virtual void get_init_lagrange_mult(
    VectorMutable*   lambda
    ,VectorMutable*  nu
    ) const;



  virtual void set_f(value_type* f);
  virtual value_type* get_f();
  virtual value_type& f();
   virtual const value_type& f() const;



  virtual void set_c(VectorMutable* c);
  virtual VectorMutable* get_c();
  virtual VectorMutable& c();
  virtual const Vector& c() const;


  
  virtual void unset_quantities();



  virtual void scale_f( value_type scale_f ) = 0;
  virtual value_type scale_f() const = 0;
  virtual void calc_f(const Vector& x, bool newx = true) const;
  virtual void calc_c(const Vector& x, bool newx = true) const;



  virtual void report_final_solution(
    const Vector&    x
    ,const Vector*   lambda
    ,const Vector*   nu
    ,bool            is_optimal
    );



  virtual size_type num_f_evals() const;
  virtual size_type num_c_evals() const;



  virtual size_type ns() const;

  virtual vec_space_ptr_t space_c_breve() const;

  virtual vec_space_ptr_t space_h_breve() const;

  virtual const Vector& hl_breve() const;

  virtual const Vector& hu_breve() const;

  virtual void set_c_breve(VectorMutable* c_breve);
  virtual VectorMutable* get_c_breve();
  virtual VectorMutable& c_breve();
  virtual const Vector& c_breve() const;

  virtual void set_h_breve(VectorMutable* h_breve);
  virtual VectorMutable* get_h_breve();
  virtual VectorMutable& h_breve();
  virtual const Vector& h_breve() const;

  virtual const Permutation& P_var() const;

  virtual const Permutation& P_equ() const;

  virtual void calc_c_breve(const Vector& x, bool newx = true) const;

  virtual void calc_h_breve(const Vector& x, bool newx = true) const;


  struct ZeroOrderInfo {
  public:
        ZeroOrderInfo() : f(NULL), c(NULL), h(NULL)
    {}
    ZeroOrderInfo( value_type* f_in, VectorMutable* c_in, VectorMutable* h_in )
      : f(f_in), c(c_in), h(h_in)
    {}
    value_type*           f;
    VectorMutable*  c;
    VectorMutable*  h;
  }; // end struct ZeroOrderInfo

  const ZeroOrderInfo zero_order_info() const;

  const ZeroOrderInfo zero_order_info_breve() const;

protected:


  virtual void imp_calc_f(const Vector& x, bool newx, const ZeroOrderInfo& zero_order_info) const = 0;
  virtual void imp_calc_c(const Vector& x, bool newx, const ZeroOrderInfo& zero_order_info) const = 0;
  virtual void imp_calc_c_breve(const Vector& x, bool newx, const ZeroOrderInfo& zero_order_info_breve) const;
  virtual void imp_calc_h_breve(const Vector& x, bool newx, const ZeroOrderInfo& zero_order_info_breve) const;


  template<class T>
  void assert_ref_set(T* p, std::string info) const {
    StandardCompositionRelationshipsPack::assert_role_name_set(p, false, info);
  }

private:

  // ////////////////////////////////////////
  // Private data members

#ifdef DOXYGEN_COMPILE
  AbstractLinAlgPack::VectorSpace *space_x;
  AbstractLinAlgPack::VectorSpace *space_c;
  AbstractLinAlgPack::VectorSpace *space_c_breve;
  AbstractLinAlgPack::VectorSpace *space_h_breve;
  Permutation                     *P_var;
  Permtuation                     *P_equ;
#else
  Teuchos::RCP<Permutation>  P_var_;
  Teuchos::RCP<Permutation>  P_equ_;
#endif
  mutable ZeroOrderInfo           first_order_info_;
  mutable ZeroOrderInfo           first_order_info_breve_;
  mutable size_type       num_f_evals_;
  mutable size_type       num_c_evals_;
  
};  // end class NLP

// /////////////////
// Inline members

inline
const NLP::ZeroOrderInfo NLP::zero_order_info() const
{
  return first_order_info_;
}

inline
const NLP::ZeroOrderInfo NLP::zero_order_info_breve() const
{
  return first_order_info_breve_;
}

} // end namespace NLPInterfacePack 

#endif // NLP_H