BonTMINLP2TNLP.hpp

Go to the documentation of this file.

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

#ifndef __TMINLP2TNLP_HPP__
#define __TMINLP2TNLP_HPP__

#include "IpTNLP.hpp"
#include "BonTMINLP.hpp"
#include "IpSmartPtr.hpp"
#include "IpIpoptApplication.hpp"
#include "IpOptionsList.hpp"
#include "BonTypes.hpp"

namespace Bonmin
{
  class IpoptInteriorWarmStarter;

  class TMINLP2TNLP : public Ipopt::TNLP
  {
  public:
    TMINLP2TNLP(const Ipopt::SmartPtr<TMINLP> tminlp
#ifdef WARM_STARTER
        ,
        const OptionsList& options
#endif
        );

    TMINLP2TNLP(const TMINLP2TNLP&);

    virtual TMINLP2TNLP * clone() const{
       return new TMINLP2TNLP(*this);}

    virtual ~TMINLP2TNLP();


    inline Ipopt::Index num_variables() const
    {
      assert(x_l_.size() == x_u_.size());
      return static_cast<int>(x_l_.size());
    }

    inline Ipopt::Index num_constraints() const
    {
      assert(g_l_.size() == g_u_.size());
      return static_cast<int>(g_l_.size());
    }
    Ipopt::Index nnz_h_lag()
    {
      return nnz_h_lag_;
    }
    const TMINLP::VariableType* var_types()
    {
      return &var_types_[0];
    }

    const Ipopt::Number* x_l()
    {
      return &x_l_[0];
    }
    const Ipopt::Number* x_u()
    {
      return &x_u_[0];
    }

    const Ipopt::Number* orig_x_l() const
    {
      return &orig_x_l_[0];
    }
    const Ipopt::Number* orig_x_u() const
    {
      return orig_x_u_();
    }

    const Ipopt::Number* g_l()
    {
      return g_l_();
    }
    const Ipopt::Number* g_u()
    {
      return g_u_();
    }

    const Ipopt::Number * x_init() const
    {
      return x_init_();
    }

    const Ipopt::Number * x_init_user() const
    {
      return x_init_user_();
    }

    const Ipopt::Number * duals_init() const
    {
      return duals_init_;
    }

    const Ipopt::Number* x_sol() const
    {
      return x_sol_();
    }

    const Ipopt::Number* g_sol() const
    {
      return g_sol_();
    }

    const Ipopt::Number* duals_sol() const
    {
      return duals_sol_();
    }

    Ipopt::SolverReturn optimization_status() const
    {
      return return_status_;
    }

    Ipopt::Number obj_value() const
    {
      return obj_value_;
    }

    void set_obj_value(Ipopt::Number value)
    {
      obj_value_ = value;
    }

    void force_fractionnal_sol();

    void SetVariablesBounds(Ipopt::Index n,
                            const Ipopt::Number * x_l,
                            const Ipopt::Number * x_u);

    void SetVariablesLowerBounds(Ipopt::Index n,
                               const Ipopt::Number * x_l);

    void SetVariablesUpperBounds(Ipopt::Index n,
                                const Ipopt::Number * x_u);

    void SetVariableBounds(Ipopt::Index var_no, Ipopt::Number x_l, Ipopt::Number x_u);

    void SetVariableLowerBound(Ipopt::Index var_no, Ipopt::Number x_l);

    void SetVariableUpperBound(Ipopt::Index var_no, Ipopt::Number x_u);

    void resetStartingPoint();

    void setxInit(Ipopt::Index n,const Ipopt::Number* x_init);

    void setDualsInit(Ipopt::Index n, const Ipopt::Number* duals_init);

    int has_x_init(){
      if(x_init_.empty()) return 0;
      if(duals_init_) return 2;
      return 1;
    }
    void Set_x_sol(Ipopt::Index n, const Ipopt::Number* x_sol);

    void Set_dual_sol(Ipopt::Index n, const Ipopt::Number* dual_sol);

    void SetVariableType(Ipopt::Index n, TMINLP::VariableType type);

    void outputDiffs(const std::string& probName, const std::string* varNames);

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

    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_constraints_linearity(Ipopt::Index m, LinearityType* const_types)
    {
      return tminlp_->get_constraints_linearity(m, const_types);
    }

    virtual bool get_variables_linearity(Ipopt::Index n, LinearityType* var_types)
    {
      return tminlp_->get_variables_linearity(n, var_types);
    }

    virtual bool hasLinearObjective(){return tminlp_->hasLinearObjective();}
    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 get_scaling_parameters(Ipopt::Number& obj_scaling,
                                        bool& use_x_scaling, Ipopt::Index n,
                                        Ipopt::Number* x_scaling,
                                        bool& use_g_scaling, Ipopt::Index m,
                                        Ipopt::Number* g_scaling);


    virtual bool get_warm_start_iterate(Ipopt::IteratesVector& warm_start_iterate);

    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_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 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 void finalize_solution(Ipopt::SolverReturn status,
        Ipopt::Index n, const Ipopt::Number* x, const Ipopt::Number* z_L, const Ipopt::Number* z_U,
        Ipopt::Index m, const Ipopt::Number* g, const Ipopt::Number* lambda,
        Ipopt::Number obj_value,
        const Ipopt::IpoptData* ip_data,
        Ipopt::IpoptCalculatedQuantities* ip_cq);
    virtual bool intermediate_callback(Ipopt::AlgorithmMode mode,
        Ipopt::Index iter, Ipopt::Number obj_value,
        Ipopt::Number inf_pr, Ipopt::Number inf_du,
        Ipopt::Number mu, Ipopt::Number d_norm,
        Ipopt::Number regularization_size,
        Ipopt::Number alpha_du, Ipopt::Number alpha_pr,
        Ipopt::Index ls_trials,
        const Ipopt::IpoptData* ip_data,
        Ipopt::IpoptCalculatedQuantities* ip_cq);

    void SetWarmStarter(Ipopt::SmartPtr<IpoptInteriorWarmStarter> warm_starter);

      Ipopt::SmartPtr<IpoptInteriorWarmStarter> GetWarmStarter();

      
      virtual bool hasUpperBoundingObjective(){
        return tminlp_->hasUpperBoundingObjective();}

    double evaluateUpperBoundingFunction(const double * x);
    


   virtual void addCuts(unsigned int numberCuts, const OsiRowCut ** cuts){
    if(numberCuts > 0)
    throw CoinError("BonTMINLP2TNLP", "addCuts", "Not implemented");}


  virtual void addCuts(const OsiCuts &cuts){
    if(cuts.sizeRowCuts() > 0 || cuts.sizeColCuts() > 0)
    throw CoinError("BonTMINLP2TNLP", "addCuts", "Not implemented");}

  virtual void removeCuts(unsigned int number ,const int * toRemove){
    if(number > 0)
    throw CoinError("BonTMINLP2TNLP", "removeCuts", "Not implemented");}



  virtual const int * get_const_xtra_id() const{
     return tminlp_->get_const_xtra_id();
  }

    double check_solution(OsiObject ** objects = 0, int nObjects = -1);
   protected:
    vector<TMINLP::VariableType> var_types_;
    vector<Ipopt::Number> x_l_;
    vector<Ipopt::Number> x_u_;
    vector<Ipopt::Number> orig_x_l_;
    vector<Ipopt::Number> orig_x_u_;
    vector<Ipopt::Number> g_l_; 
    vector<Ipopt::Number> g_u_;
    vector<Ipopt::Number> x_init_;
    Ipopt::Number * duals_init_;
    vector<Ipopt::Number> x_init_user_;
    vector<Ipopt::Number> x_sol_;
    vector<Ipopt::Number> g_sol_;
    vector<Ipopt::Number> duals_sol_;
    Ipopt::Index nnz_h_lag() const{
     return nnz_h_lag_;}
    Ipopt::Index nnz_jac_g() const{
     return nnz_jac_g_;}

     TNLP::IndexStyleEnum index_style() const{
       return index_style_;}
  private:
    TMINLP2TNLP();

    TMINLP2TNLP& operator=(const TMINLP2TNLP&);

    Ipopt::SmartPtr<TMINLP> tminlp_;

    Ipopt::Index nnz_jac_g_;
    Ipopt::Index nnz_h_lag_;
    TNLP::IndexStyleEnum index_style_;

    Ipopt::SolverReturn return_status_;
    Ipopt::Number obj_value_;

    Ipopt::SmartPtr<IpoptInteriorWarmStarter> curr_warm_starter_;
    Ipopt::Number nlp_lower_bound_inf_;
    Ipopt::Number nlp_upper_bound_inf_;
    bool warm_start_entire_iterate_;
    bool need_new_warm_starter_;


    void throw_exception_on_bad_variable_bound(Ipopt::Index i);
    
    private:
    // Delete all arrays
    void gutsOfDelete();
    
    void gutsOfCopy(const TMINLP2TNLP &source);
  };

} // namespace Ipopt

#endif