BonTNLP2FPNLP.hpp

Go to the documentation of this file.

// Copyright (C) 2004, International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
//
// Authors:  Pierre Bonami 06/10/2005

#ifndef _TNLP2FPNLP_HPP_
#define _TNLP2FPNLP_HPP_

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

namespace Bonmin
{
  class TNLP2FPNLP : public Ipopt::TNLP
  {
  public:
    TNLP2FPNLP(const Ipopt::SmartPtr<Ipopt::TNLP> tnlp, double objectiveScalingFactor = 100);

    TNLP2FPNLP(const Ipopt::SmartPtr<TNLP> tnlp, const Ipopt::SmartPtr<TNLP2FPNLP> other);

    virtual ~TNLP2FPNLP();
    void use(Ipopt::SmartPtr<TNLP> tnlp){
      tnlp_ = GetRawPtr(tnlp);}
    void set_use_feasibility_pump_objective(bool use_feasibility_pump_objective) 
    { use_feasibility_pump_objective_ = use_feasibility_pump_objective; }

    void set_use_cutoff_constraint(bool use_cutoff_constraint)
    { use_cutoff_constraint_ = use_cutoff_constraint; }

    void set_use_local_branching_constraint(bool use_local_branching_constraint)
    { use_local_branching_constraint_ = use_local_branching_constraint; }

    void set_cutoff(Ipopt::Number cutoff);

    void set_rhs_local_branching_constraint(double rhs_local_branching_constraint)
    { assert(rhs_local_branching_constraint >= 0);
      rhs_local_branching_constraint_ = rhs_local_branching_constraint; }

    void set_dist_to_point_obj(size_t n, const Ipopt::Number * vals, const Ipopt::Index * inds);

     void setSigma(double sigma){
       assert(sigma >= 0.);
       sigma_ = sigma;}
     void setLambda(double lambda){
       assert(lambda >= 0. && lambda <= 1.);
       lambda_ = lambda;}
     void setNorm(int norm){
       assert(norm >0 && norm < 3);
       norm_ = norm;}

    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)
    {
      int m2 = m;
      if(use_cutoff_constraint_) {
        m2--;
        if(lambda!=NULL)lambda[m2] = 0;
      }
      if(use_local_branching_constraint_) {
        m2--;
        if(lambda!= NULL)lambda[m2] = 0;
      }
      int ret_code = tnlp_->get_starting_point(n, init_x, x,
          init_z, z_L, z_U, m2, init_lambda, lambda);
      return ret_code;
    }

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

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

    virtual bool get_constraints_linearity(Ipopt::Index m, LinearityType* const_types)
    {
      int m2 = m;
      if(use_cutoff_constraint_) {
        m2--;
        const_types[m2] = Ipopt::TNLP::NON_LINEAR;
      } 
      if(use_local_branching_constraint_) {
        m2--;
        const_types[m2] = Ipopt::TNLP::LINEAR;
      }
      return tnlp_->get_constraints_linearity(m2, const_types);
    }
    void setObjectiveScaling(double value)
    {
      objectiveScalingFactor_ = value;
    }
    double getObjectiveScaling() const
    {
      return objectiveScalingFactor_;
    }

  private:
    double dist_to_point(const Ipopt::Number *x);

    TNLP2FPNLP();

    TNLP2FPNLP(const TNLP2FPNLP&);

    void operator=(const TNLP2FPNLP&);

    Ipopt::SmartPtr<TNLP> tnlp_;

    vector<Ipopt::Index> inds_;
    vector<Ipopt::Number> vals_;
    double lambda_;
    double sigma_;
   int norm_;

    double objectiveScalingFactor_;

    bool use_feasibility_pump_objective_;

    bool use_cutoff_constraint_;    

    bool use_local_branching_constraint_;

    double cutoff_;

    double rhs_local_branching_constraint_;

    Ipopt::TNLP::IndexStyleEnum index_style_;

  };

} // namespace Ipopt

#endif /*_TNLP2FPNLP_HPP_*/