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.
//
// $Id: AmplTNLP.hpp 2242 2013-04-24 19:26:30Z stefan $
//
// 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 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 AmplOptionsList : public ReferencedObject
  {
  public:
    enum AmplOptionType {
      String_Option,
      Number_Option,
      Integer_Option,
      WS_Option,  /* this is for AMPL's internal wantsol callback */
      HaltOnError_Option /* this is for our setting of the nerror_ member */
    };
 
  class 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);
 
    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 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&);
 
    SmartPtr<const Journalist> jnlst_;
 
    ASL_pfgh* asl_;
 
    double obj_sign_;
 
    Index nz_h_full_; // number of nonzeros in the full_x hessian
    /* 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