BonAmplTMINLP.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation and
// Carnegie Mellon University 2004, 2007
//
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors :
// Carl D. Laird, Carnegie Mellon University,
// Andreas Waechter, International Business Machines Corporation
// Pierre Bonami, Carnegie Mellon University,
//
// Date : 12/01/2004

#ifndef __IPAMPLTMINLP_HPP__
#define __IPAMPLTMINLP_HPP__

#include "BonTMINLP.hpp"
#include "IpSmartPtr.hpp"
#include "CoinPackedMatrix.hpp"
#include "OsiCuts.hpp"
#include "BonRegisteredOptions.hpp"
#include "BonTypes.hpp"

/* non Ipopt forward declaration */
struct ASL_pfgh;
struct SufDecl;
struct SufDesc;


// Declarations, so that we don't have to include the Ipopt AMPL headers
namespace Ipopt
{
  class AmplSuffixHandler;
  class AmplOptionsList;
  class AmplTNLP;
}

namespace Bonmin
{

  class AmplTMINLP : public TMINLP
  {
  public:
    AmplTMINLP(const Ipopt::SmartPtr<const Ipopt::Journalist>& jnlst,
        const Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
        const Ipopt::SmartPtr<Ipopt::OptionsList> options,
        char**& argv,
        Ipopt::AmplSuffixHandler* suffix_handler = NULL,
        const std::string& appName = "bonmin",
        std::string* nl_file_content = NULL);

    virtual void Initialize(const Ipopt::SmartPtr<const Ipopt::Journalist>& jnlst,
        const Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions,
        const Ipopt::SmartPtr<Ipopt::OptionsList> options,
        char**& argv,
        Ipopt::AmplSuffixHandler* suffix_handler =NULL,
        const std::string& appName = "bonmin",
        std::string* nl_file_content = NULL);

    void read_priorities();

    void read_sos();

    void read_convexities();

    void read_onoff();

    void read_obj_suffixes();

    AmplTMINLP();

    virtual AmplTMINLP * createEmpty()
    {
      AmplTMINLP * tminlp = new AmplTMINLP;
      return tminlp;
    }

    virtual ~AmplTMINLP();

    const ASL_pfgh* AmplSolverObject() const;


    virtual bool get_nlp_info(Ipopt::Index& n, Ipopt::Index& m, Ipopt::Index& nnz_jac_g,
        Ipopt::Index& nnz_h_lag,
        Ipopt::TNLP::IndexStyleEnum& index_style);

    virtual bool get_variables_types(Ipopt::Index n, VariableType* var_types);

    virtual bool get_variables_linearity(Ipopt::Index n, Ipopt::TNLP::LinearityType * var_types);

    virtual bool get_constraints_linearity(Ipopt::Index m,
        Ipopt::TNLP::LinearityType* const_types);

    virtual bool get_bounds_info(Ipopt::Index n, Ipopt::Number* x_l, Ipopt::Number* x_u,
        Ipopt::Index m, Ipopt::Number* g_l, Ipopt::Number* g_u);

    virtual bool get_starting_point(Ipopt::Index n, bool init_x, Ipopt::Number* x,
        bool init_z, Ipopt::Number* z_L, Ipopt::Number* z_U,
        Ipopt::Index m, bool init_lambda, Ipopt::Number* lambda);

    virtual bool eval_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Number& obj_value);

    virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Number* grad_f);

    virtual bool eval_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Index m, Ipopt::Number* g);

    virtual bool eval_jac_g(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Index m, Ipopt::Index nele_jac, Ipopt::Index* iRow,
        Ipopt::Index *jCol, Ipopt::Number* values);

    virtual bool eval_h(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Number obj_factor, Ipopt::Index m, const Ipopt::Number* lambda,
        bool new_lambda, Ipopt::Index nele_hess, Ipopt::Index* iRow,
        Ipopt::Index* jCol, Ipopt::Number* values);

    virtual bool eval_gi(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Index i, Ipopt::Number& gi);
    virtual bool eval_grad_gi(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Index i, Ipopt::Index& nele_grad_gi, Ipopt::Index* jCol,
        Ipopt::Number* values);

    virtual void finalize_solution(TMINLP::SolverReturn status,
        Ipopt::Index n, const Ipopt::Number* x, Ipopt::Number obj_value);

    void write_solution(const std::string & message, const Ipopt::Number *x_sol);



    virtual const BranchingInfo * branchingInfo() const
    {
      return &branch_;
    }

    virtual const SosInfo * sosConstraints() const
    {
      return &sos_;
    }

    virtual const PerturbInfo* perturbInfo() const
    {
      return &perturb_info_;
    }

    virtual void fillApplicationOptions(Ipopt::AmplOptionsList* amplOptList)
    {}


    virtual void getLinearPartOfObjective(double * obj);


    virtual bool hasUpperBoundingObjective()
    {
      return upperBoundingObj_ != -1;
    }

    virtual bool eval_upper_bound_f(Ipopt::Index n, const Ipopt::Number* x,
        Ipopt::Number& obj_value);

    virtual bool get_constraint_convexities(int m, TMINLP::Convexity * constraints_convexities)const
    {
      if (constraintsConvexities_ != NULL) {
        CoinCopyN(constraintsConvexities_, m, constraints_convexities);
      }
      else {
        CoinFillN(constraints_convexities, m, TMINLP::Convex);
      }
      return true;
    }
    virtual bool get_number_nonconvex(int & number_non_conv, int & number_concave) const
    {
      number_non_conv = numberNonConvex_;
      number_concave = numberSimpleConcave_;
      return true;
    }
    virtual bool get_constraint_convexities(int number_non_conv, MarkedNonConvex * non_convexes) const
    {
      assert(number_non_conv == numberNonConvex_);
      CoinCopyN( nonConvexConstraintsAndRelaxations_, number_non_conv, non_convexes);
      return true;
    }
    virtual bool get_simple_concave_constraints(int number_concave, SimpleConcaveConstraint * simple_concave) const
    {
      assert(number_concave == numberSimpleConcave_);
      CoinCopyN(simpleConcaves_, numberSimpleConcave_, simple_concave);
      return true;
    }

    virtual bool hasLinearObjective()
    {
      return hasLinearObjective_;
    }

  virtual const int * get_const_xtra_id() const{
    return c_extra_id_();
  }
  private:

    AmplTMINLP(const AmplTMINLP&);

    void operator=(const AmplTMINLP&);

    std::string appName_;

    int upperBoundingObj_;
    Ipopt::AmplTNLP* ampl_tnlp_;
    Ipopt::SmartPtr<const Ipopt::Journalist> jnlst_;

    BranchingInfo branch_;
    SosInfo sos_;
    PerturbInfo perturb_info_;
    Ipopt::SmartPtr<Ipopt::AmplSuffixHandler> suffix_handler_;

    TMINLP::Convexity * constraintsConvexities_;

    vector<int> c_extra_id_; 

    int numberNonConvex_;
    MarkedNonConvex * nonConvexConstraintsAndRelaxations_;
    int numberSimpleConcave_;
    SimpleConcaveConstraint * simpleConcaves_;

    bool hasLinearObjective_;

    int writeAmplSolFile_;
  };
} // namespace Ipopt

#endif