AmplTNLP.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2009 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
 
#ifndef __IPAMPLTNLP_HPP__
#define __IPAMPLTNLP_HPP__
 
#include "IpUtils.hpp"
#include "IpTNLP.hpp"
#include "IpJournalist.hpp"
#include "IpOptionsList.hpp"
 
#include <map>
#include <string>
 
/* non Ipopt forward declaration */
struct ASL_pfgh;
struct SufDecl;
struct SufDesc;
 
namespace Ipopt
{
 
class IPOPTAMPLINTERFACELIB_EXPORT AmplSuffixHandler: public ReferencedObject
{
public:
   AmplSuffixHandler();
 
   ~AmplSuffixHandler();
 
   enum Suffix_Type
   {
      Index_Type,
      Number_Type
   };
 
   enum Suffix_Source
   {
      Variable_Source,
      Constraint_Source,
      Objective_Source,
      Problem_Source
   };
 
   void AddAvailableSuffix(
      std::string   suffix_string,
      Suffix_Source source,
      Suffix_Type   type
   )
   {
      suffix_ids_.push_back(suffix_string);
      suffix_types_.push_back(type);
      suffix_sources_.push_back(source);
      //      suffix_values_.push_back();
   }
 
   const Index* GetIntegerSuffixValues(
      std::string   suffix_string,
      Suffix_Source source
   ) const;
 
   const Number* GetNumberSuffixValues(
      std::string   suffix_string,
      Suffix_Source source
   ) const;
 
   std::vector<Index> GetIntegerSuffixValues(
      Index         n,
      std::string   suffix_string,
      Suffix_Source source
   ) const;
 
   std::vector<Number> GetNumberSuffixValues(
      Index         n,
      std::string   suffix_string,
      Suffix_Source source
   ) const;
 
private:
 
   //AmplSuffixHandler();
   AmplSuffixHandler(
      const AmplSuffixHandler&
   );
 
   void operator=(
      const AmplSuffixHandler&
   );
 
   mutable ASL_pfgh* asl_;
 
   SufDecl* suftab_;
 
   std::vector<std::string> suffix_ids_;
   std::vector<Suffix_Type> suffix_types_;
   std::vector<Suffix_Source> suffix_sources_;
 
   void PrepareAmplForSuffixes(
      ASL_pfgh* asl
   );
 
   //    void RetrieveSuffixesFromAmpl(ASL_pfgh* asl);
   friend class AmplTNLP;
};
 
class IPOPTAMPLINTERFACELIB_EXPORT AmplOptionsList: public ReferencedObject
{
public:
   enum AmplOptionType
   {
      String_Option,
      Number_Option,
      Integer_Option,
      WS_Option,         
      HaltOnError_Option 
   };
 
   class IPOPTAMPLINTERFACELIB_EXPORT AmplOption: public ReferencedObject
   {
   public:
      AmplOption(
         const std::string ipopt_option_name,
         AmplOptionType    type,
         const std::string description);
 
      ~AmplOption()
      {
         delete[] description_;
      }
 
      const std::string& IpoptOptionName() const
      {
         return ipopt_option_name_;
      }
      AmplOptionType Type() const
      {
         return type_;
      }
      char* Description() const
      {
         return description_;
      }
   private:
 
      AmplOption();
 
      AmplOption(
         const AmplOption&);
 
      void operator=(
         const AmplOption&);
 
      const std::string ipopt_option_name_;
      const AmplOptionType type_;
      char* description_;
   };
 
   class PrivatInfo
   {
   public:
      PrivatInfo(
         const std::string          ipopt_name,
         SmartPtr<OptionsList>      options,
         SmartPtr<const Journalist> jnlst,
         void**                     nerror = NULL
      )
         : ipopt_name_(ipopt_name),
           options_(options),
           jnlst_(jnlst),
           nerror_(nerror)
      {
      }
      const std::string& IpoptName() const
      {
         return ipopt_name_;
      }
      const SmartPtr<OptionsList>& Options() const
      {
         return options_;
      }
      const SmartPtr<const Journalist>& Jnlst() const
      {
         return jnlst_;
      }
      void** NError()
      {
         return nerror_;
      }
   private:
      const std::string ipopt_name_;
      const SmartPtr<OptionsList> options_;
      const SmartPtr<const Journalist> jnlst_;
      void** nerror_;
   };
 
public:
   AmplOptionsList()
      : keywds_(NULL),
        nkeywds_(0)
   { }
 
   ~AmplOptionsList();
 
   void AddAmplOption(
      const std::string               ampl_option_name,
      const std::string               ipopt_option_name,
      AmplOptionsList::AmplOptionType type,
      const std::string               description
   )
   {
      SmartPtr<AmplOption> new_option = new AmplOption(ipopt_option_name, type, description);
      ampl_options_map_[ampl_option_name] = ConstPtr(new_option);
   }
 
   Index NumberOfAmplOptions()
   {
      return (Index) ampl_options_map_.size();
   }
 
   void* Keywords(
      const SmartPtr<OptionsList>& options,
      SmartPtr<const Journalist>   jnlst,
      void**                       nerror
   );
 
private:
 
   //AmplOptionsList();
   AmplOptionsList(
      const AmplOptionsList&
   );
 
   void operator=(
      const AmplOptionsList&
   );
 
   void MakeValidLatexString(
      std::string  source,
      std::string& dest
   ) const;
 
   void PrintLatex(
      SmartPtr<const Journalist> jnlst
   );
 
   void PrintDoxygen(
      SmartPtr<const Journalist> jnlst
   );
 
   std::map<std::string, SmartPtr<const AmplOption> > ampl_options_map_;
   // AW: I think it should be with const like in the following line
   //     but with const the AIX compiler fails
   // std::map<const std::string, SmartPtr<const AmplOption> > ampl_options_map_;
 
   void* keywds_;
 
   Index nkeywds_;
};
 
class IPOPTAMPLINTERFACELIB_EXPORT AmplTNLP: public TNLP
{
public:
 
   AmplTNLP(
      const SmartPtr<const Journalist>& jnlst,
      const SmartPtr<OptionsList>       options,
      char**&                           argv,
      SmartPtr<AmplSuffixHandler>       suffix_handler = NULL,
      bool                              allow_discrete = false,
      SmartPtr<AmplOptionsList>         ampl_options_list = NULL,
      const char*                       ampl_option_string = NULL,
      const char*                       ampl_invokation_string = NULL,
      const char*                       ampl_banner_string = NULL,
      std::string*                      nl_file_content = NULL
   );
 
   virtual ~AmplTNLP();
 
   DECLARE_STD_EXCEPTION(NONPOSITIVE_SCALING_FACTOR);
 
   virtual bool get_nlp_info(
      Index&          n,
      Index&          m,
      Index&          nnz_jac_g,
      Index&          nnz_h_lag,
      IndexStyleEnum& index_style
   );
 
   virtual bool get_var_con_metadata(
      Index                   n,
      StringMetaDataMapType&  var_string_md,
      IntegerMetaDataMapType& var_integer_md,
      NumericMetaDataMapType& var_numeric_md,
      Index                   m,
      StringMetaDataMapType&  con_string_md,
      IntegerMetaDataMapType& con_integer_md,
      NumericMetaDataMapType& con_numeric_md
   );
 
   virtual bool get_bounds_info(
      Index   n,
      Number* x_l,
      Number* x_u,
      Index   m,
      Number* g_l,
      Number* g_u
   );
 
   virtual bool get_constraints_linearity(
      Index          m,
      LinearityType* const_types
   );
 
   virtual bool get_starting_point(
      Index   n,
      bool    init_x,
      Number* x,
      bool    init_z,
      Number* z_L,
      Number* z_U,
      Index   m,
      bool    init_lambda,
      Number* lambda
   );
 
   virtual bool eval_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number&       obj_value
   );
 
   virtual bool eval_grad_f(
      Index         n,
      const Number* x,
      bool          new_x,
      Number*       grad_f
   );
 
   virtual bool eval_g(
      Index         n,
      const Number* x,
      bool          new_x,
      Index         m,
      Number*       g
   );
 
   virtual bool eval_jac_g(
      Index         n,
      const Number* x,
      bool          new_x,
      Index         m,
      Index         nele_jac,
      Index*        iRow,
      Index*        jCol,
      Number*       values
   );
 
   virtual bool eval_h(
      Index         n,
      const Number* x,
      bool          new_x,
      Number        obj_factor,
      Index         m,
      const Number* lambda,
      bool          new_lambda,
      Index         nele_hess,
      Index*        iRow,
      Index*        jCol,
      Number*       values
   );
 
   virtual bool get_scaling_parameters(
      Number& obj_scaling,
      bool&   use_x_scaling,
      Index   n,
      Number* x_scaling,
      bool&   use_g_scaling,
      Index   m,
      Number* g_scaling
   );
 
   virtual void finalize_solution(
      SolverReturn               status,
      Index                      n,
      const Number*              x,
      const Number*              z_L,
      const Number*              z_U,
      Index                      m,
      const Number*              g,
      const Number*              lambda,
      Number                     obj_value,
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq
   );
 
   virtual Index get_number_of_nonlinear_variables();
   virtual bool get_list_of_nonlinear_variables(
      Index  num_nonlin_vars,
      Index* pos_nonlin_vars
   );
 
 
   ASL_pfgh* AmplSolverObject()
   {
      return asl_;
   }
 
   void write_solution_file(
      const std::string& message
   ) const;
 
   void get_discrete_info(
      Index& nlvb_,
      Index& nlvbi_,
      Index& nlvc_,
      Index& nlvci_,
      Index& nlvo_,
      Index& nlvoi_,
      Index& nbv_,
      Index& niv_
   ) const;
 
   void set_active_objective(
      Index obj_no
   );
 
   void set_string_metadata_for_var(
      std::string              tag,
      std::vector<std::string> meta_data)
   {
      var_string_md_[tag] = meta_data;
   }
 
   void set_integer_metadata_for_var(
      std::string        tag,
      std::vector<Index> meta_data)
   {
      var_integer_md_[tag] = meta_data;
   }
 
   void set_numeric_metadata_for_var(
      std::string         tag,
      std::vector<Number> meta_data)
   {
      var_numeric_md_[tag] = meta_data;
   }
 
   void set_string_metadata_for_con(
      std::string              tag,
      std::vector<std::string> meta_data)
   {
      con_string_md_[tag] = meta_data;
   }
 
   void set_integer_metadata_for_con(
      std::string        tag,
      std::vector<Index> meta_data)
   {
      con_integer_md_[tag] = meta_data;
   }
 
   void set_numeric_metadata_for_con(
      std::string         tag,
      std::vector<Number> meta_data)
   {
      con_numeric_md_[tag] = meta_data;
   }
 
   SmartPtr<AmplSuffixHandler> get_suffix_handler()
   {
      return suffix_handler_;
   }
 
private:
 
   AmplTNLP();
 
   AmplTNLP(
      const AmplTNLP&
   );
 
   void operator=(
      const AmplTNLP&
   );
 
protected:
   SmartPtr<const Journalist> jnlst_;
 
   ASL_pfgh* asl_;
 
   double obj_sign_;
 
 
   Index nz_h_full_;
   /* the rest of the problem size data is available easily through the ampl variables */
 
   Number* x_sol_;
   Number* z_L_sol_;
   Number* z_U_sol_;
   Number* g_sol_;
   Number* lambda_sol_;
   Number  obj_sol_;
 
 
   bool objval_called_with_current_x_;
   bool conval_called_with_current_x_;
   bool hesset_called_;
   bool set_active_objective_called_;
 
   void* Oinfo_ptr_;
 
   void* nerror_;
 
   SmartPtr<AmplSuffixHandler> suffix_handler_;
 
   bool internal_objval(
      const Number* x,
      Number&       obj_val
   );
 
   bool internal_conval(
      const Number* x,
      Index         m,
      Number*       g = NULL
   );
 
   bool apply_new_x(
      bool          new_x,
      Index         n,
      const Number* x
   );
 
   char* get_options(
      const SmartPtr<OptionsList>& options,
      SmartPtr<AmplOptionsList>&   ampl_options_list,
      const char*                  ampl_option_string,
      const char*                  ampl_invokation_string,
      const char*                  ampl_banner_string,
      char**&                      argv
   );
 
   bool nerror_ok(
      void* nerror
   );
 
   void call_hesset();
 
   StringMetaDataMapType var_string_md_;
   IntegerMetaDataMapType var_integer_md_;
   NumericMetaDataMapType var_numeric_md_;
   StringMetaDataMapType con_string_md_;
   IntegerMetaDataMapType con_integer_md_;
   NumericMetaDataMapType con_numeric_md_;
};
 
} // namespace Ipopt
 
#endif