BonCutStrengthener.hpp

Go to the documentation of this file.

// Copyright (C) 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: BonCutStrengthener.hpp 1858 2011-06-18 20:13:40Z stefan $
//
// Author:   Andreas Waechter                 IBM    2007-03-29

#ifndef __BONCUTSTRENGTHENER_HPP__
#define __BONCUTSTRENGTHENER_HPP__

#include "BonTMINLP.hpp"
#include "CoinPackedVector.hpp"
#include "BonTNLPSolver.hpp"

namespace Bonmin
{
  enum CutStrengtheningType{
    CS_None=0,
    CS_StrengthenedGlobal=1,
    CS_UnstrengthenedGlobal_StrengthenedLocal=2,
    CS_StrengthenedGlobal_StrengthenedLocal=3
  };

  enum DisjunctiveCutType{
    DC_None=0,
    DC_MostFractional=1
  };

  class CutStrengthener: public Ipopt::ReferencedObject
  {
    class StrengtheningTNLP: public Ipopt::TNLP {
    public:
      StrengtheningTNLP(Ipopt::SmartPtr<TMINLP> tminlp,
                        const CoinPackedVector& cut,
                        bool lower_bound,
                        Ipopt::Index n,
                        const Ipopt::Number* starting_point,
                        const double* x_l_orig,
                        const double* x_u_orig,
                        Ipopt::Index constr_index,
                        Ipopt::Index nvar_constr ,
                        const Ipopt::Index* jCol);

      ~StrengtheningTNLP();

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

      Ipopt::Number StrengthenedBound() const;
      
    private:
      StrengtheningTNLP();
      StrengtheningTNLP(const StrengtheningTNLP&);
      StrengtheningTNLP& operator=(const StrengtheningTNLP&);

      const Ipopt::SmartPtr<TMINLP> tminlp_;

      Ipopt::Number* obj_grad_;

      const Ipopt::Index n_orig_;

      Ipopt::Index m_orig_;

      Ipopt::Number* starting_point_;

      Ipopt::Number* x_full_;

      Ipopt::Number* x_l_;

      Ipopt::Number* x_u_;

      const Ipopt::Index constr_index_;

      const Ipopt::Index nvar_constr_;

      Ipopt::Index* var_indices_;

      bool lower_bound_;

      bool have_final_bound_;

      Ipopt::Number strengthened_bound_;

      Ipopt::Number* grad_f_;

      void update_x_full(const Ipopt::Number *x);
    };

  public:
    CutStrengthener(Ipopt::SmartPtr<TNLPSolver> tnlp_solver,
                    Ipopt::SmartPtr<Ipopt::OptionsList> options);

    virtual ~CutStrengthener();

    bool ComputeCuts(OsiCuts &cs,
                     TMINLP* tminlp,
                     TMINLP2TNLP* problem,
                     const int gindex, CoinPackedVector& cut,
                     double& cut_lb, double& cut_ub,
                     const double g_val, const double g_lb,
                     const double g_ub,
                     int n, const double* x,
                     double infty);

  private:
    CutStrengthener();

    CutStrengthener(const CutStrengthener&);

    void operator=(const CutStrengthener&);

    bool StrengthenCut(Ipopt::SmartPtr<TMINLP> tminlp ,
                       int constr_index ,
                       const CoinPackedVector& row ,
                       int n ,
                       const double* x ,
                       const double* x_l ,
                       const double* x_u ,
                       double& lb,
                       double& ub);

    bool HandleOneCut(bool is_tight, TMINLP* tminlp,
                      TMINLP2TNLP* problem,
                      const double* minlp_lb,
                      const double* minlp_ub,
                      const int gindex, CoinPackedVector& cut,
                      double& cut_lb, double& cut_ub,
                      int n, const double* x,
                      double infty);

    Ipopt::SmartPtr<TNLPSolver> tnlp_solver_;

    int cut_strengthening_type_;
    int disjunctive_cut_type_;
    int oa_log_level_;
  };

} // namespace Ipopt
#endif