BonTMINLPLinObj.hpp

Go to the documentation of this file.

// (C) Copyright International Business Machines Corporation 2007
// All Rights Reserved.
//
// Authors :
// Pierre Bonami, International Business Machines Corporation
//
// Date : 08/16/2007


#ifndef TMINLPLinObj_H
#define TMINLPLinObj_H

#include "BonTMINLP.hpp"

namespace Bonmin {
class TMINLPLinObj: public Bonmin::TMINLP {
  public:
   TMINLPLinObj();

  virtual ~TMINLPLinObj();

  void setTminlp(Ipopt::SmartPtr<TMINLP> tminlp);
  
        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_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_variables_types(Ipopt::Index n, VariableType* var_types){
      assert(IsValid(tminlp_));
      assert(n == n_);
      var_types[n-1] = TMINLP::CONTINUOUS;
      return tminlp_->get_variables_types(n - 1, 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){
        assert(n == n_);
        obj_value = x[n-1];
       return true;}

    virtual bool eval_grad_f(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
        Ipopt::Number* grad_f){
       assert(IsValid(tminlp_));
       assert(n == n_);
       n--;
       for(int  i = 0 ; i < n ; i++){
        grad_f[i] = 0;}
       grad_f[n] = 1;
       return true;}

    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 bool get_variables_linearity(Ipopt::Index n, Ipopt::TNLP::LinearityType* c){
      assert(IsValid(tminlp_));
      assert(n == n_);
      bool r_val = tminlp_->get_variables_linearity(n-1, c);
      c[n - 1] = Ipopt::TNLP::LINEAR;
      return r_val;
    }


    virtual void finalize_solution(TMINLP::SolverReturn status,
                                   Ipopt::Index n, const Ipopt::Number* x, Ipopt::Number obj_value){
       return tminlp_->finalize_solution(status, n - 1, x,
                                  obj_value);
    }
    
    virtual const BranchingInfo * branchingInfo() const{
      return tminlp_->branchingInfo();
    }

    virtual const SosInfo * sosConstraints() const{
      return tminlp_->sosConstraints();
    }
    virtual const PerturbInfo* perturbInfo() const
    {
      return tminlp_->perturbInfo();
    }

    virtual bool hasUpperBoundingObjective(){
      assert(IsValid(tminlp_));
      return tminlp_->hasUpperBoundingObjective();}
    
    virtual bool eval_upper_bound_f(Ipopt::Index n, const Ipopt::Number* x,
                                    Ipopt::Number& obj_value){
       assert(IsValid(tminlp_));
       return tminlp_->eval_upper_bound_f(n - 1, x, obj_value); }

  virtual bool hasLinearObjective(){return true;}
  Ipopt::SmartPtr<TMINLP> tminlp(){return tminlp_;}
  private:
   void gutsOfDestructor();

  Ipopt::SmartPtr<TMINLP> tminlp_;
  int m_;
  int n_;
  int nnz_jac_;
  int offset_;
   
};


}/* Ends Bonmin namepsace.*/

#endif