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(
      const 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 int* GetIntegerSuffixValues(
      const std::string& suffix_string,
      Suffix_Source      source
   ) const;

   const Number* GetNumberSuffixValues(
      const std::string& suffix_string,
      Suffix_Source      source
   ) const;

   std::vector<int> GetIntegerSuffixValues(
      Index         n,
      const std::string& suffix_string,
      Suffix_Source      source
   ) const;

   std::vector<Number> GetNumberSuffixValues(
      Index         n,
      const 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<RegisteredOptions> regoptions,                    
      const SmartPtr<OptionsList>       options,                       
      const char* const*                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,        
      bool                              checkinterrupt = false         
   );

   IPOPT_DEPRECATED
   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 bool intermediate_callback(
      AlgorithmMode              mode,
      Index                      iter,
      Number                     obj_value,
      Number                     inf_pr,
      Number                     inf_du,
      Number                     mu,
      Number                     d_norm,
      Number                     regularization_size,
      Number                     alpha_du,
      Number                     alpha_pr,
      Index                      ls_trials,
      const IpoptData*           ip_data,
      IpoptCalculatedQuantities* ip_cq
   );

   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_;
   }

   // ToDo Maybe this should be at a different place, or collect the numbers itself?
   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(
      const std::string&              tag,
      const std::vector<std::string>& meta_data
   )
   {
      var_string_md_[tag] = meta_data;
   }

   void set_integer_metadata_for_var(
      const std::string&        tag,
      const std::vector<Index>& meta_data
   )
   {
      var_integer_md_[tag] = meta_data;
   }

   void set_numeric_metadata_for_var(
      const std::string&         tag,
      const std::vector<Number>& meta_data
   )
   {
      var_numeric_md_[tag] = meta_data;
   }

   void set_string_metadata_for_con(
      const std::string&              tag,
      const std::vector<std::string>& meta_data
   )
   {
      con_string_md_[tag] = meta_data;
   }

   void set_integer_metadata_for_con(
      const std::string&        tag,
      const std::vector<Index>& meta_data
   )
   {
      con_integer_md_[tag] = meta_data;
   }

   void set_numeric_metadata_for_con(
      const std::string&         tag,
      const 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&
   );

   void gutsOfConstructor(
      const SmartPtr<RegisteredOptions> regoptions,
      const SmartPtr<OptionsList>       options,
      const char* const*                argv,
      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 */
   );

protected:
   SmartPtr<const Journalist> jnlst_;

   ASL_pfgh* asl_;

   Number 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 checkinterrupt_;
   bool interrupted_;

   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<RegisteredOptions> regoptions,        
      const SmartPtr<OptionsList>& options,                
      SmartPtr<AmplOptionsList>&   ampl_options_list,      
      const char*                  ampl_option_string,     
      const char*                  ampl_invokation_string, 
      const char*                  ampl_banner_string,     
      const char* const*           argv                    
   );

   IPOPT_DEPRECATED
   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,
      // cppcheck-suppress constParameter
      char**&                      argv
   )
   {
      return get_options(NULL, options, ampl_options_list, ampl_option_string, ampl_invokation_string, ampl_banner_string, 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