NLPInterfacePack_NLP.hpp

// @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.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// 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