BonTMINLP.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 Common 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 __TMINLP_HPP__
#define __TMINLP_HPP__

#include "IpUtils.hpp"
#include "IpReferenced.hpp"
#include "IpException.hpp"
#include "IpAlgTypes.hpp"
#include "CoinPackedMatrix.hpp"
#include "OsiCuts.hpp"
#include "IpTNLP.hpp"
#include "CoinError.hpp"
#include "CoinHelperFunctions.hpp"

namespace Bonmin
{
  DECLARE_STD_EXCEPTION(TMINLP_INVALID);
  DECLARE_STD_EXCEPTION(TMINLP_INVALID_VARIABLE_BOUNDS);

  class TMINLP : public Ipopt::ReferencedObject
  {
  public:
    friend class TMINLP2TNLP;
    enum SolverReturn{
      SUCCESS,
      INFEASIBLE,
      CONTINUOUS_UNBOUNDED,
      LIMIT_EXCEEDED,
      USER_INTERRUPT,
      MINLP_ERROR};
    struct SosInfo
    {
      int num;
      char * types;
      int * priorities;
      
      int numNz;
      int * starts;
      int * indices;
      double * weights;
      SosInfo();
      SosInfo(const SosInfo & source);
      

      ~SosInfo()
      {
        gutsOfDestructor();
      }


      void gutsOfDestructor();

    };

    struct BranchingInfo
    {
      int size;
      int * priorities;
      int * branchingDirections;
      double * upPsCosts;
      double * downPsCosts;
      BranchingInfo():
      size(0),
      priorities(NULL),
      branchingDirections(NULL),
      upPsCosts(NULL),
      downPsCosts(NULL)
      {}
      BranchingInfo(const BranchingInfo &other)
      {
        gutsOfDestructor();
        size = other.size;
        priorities = CoinCopyOfArray(other.priorities, size);
        branchingDirections = CoinCopyOfArray(other.branchingDirections, size);
        upPsCosts = CoinCopyOfArray(other.upPsCosts, size);
        downPsCosts = CoinCopyOfArray(other.downPsCosts, size);
      }
      void gutsOfDestructor()
      {
      if (priorities != NULL) delete [] priorities;
      priorities = NULL;
      if (branchingDirections != NULL) delete [] branchingDirections;  
      branchingDirections = NULL;
      if (upPsCosts != NULL) delete [] upPsCosts;
      upPsCosts = NULL;
      if (downPsCosts != NULL) delete [] downPsCosts;
      downPsCosts = NULL;
      }
      ~BranchingInfo()
      {
        gutsOfDestructor();
      }
    };

    class PerturbInfo
    {
    public:
      PerturbInfo() :
        perturb_radius_(NULL)
      {}

      ~PerturbInfo()
      {
        delete [] perturb_radius_;
      }

      void SetPerturbationArray(Ipopt::Index numvars, const double* perturb_radius);

      const double* GetPerturbationArray() const {
        return perturb_radius_;
      }

    private:
      PerturbInfo(const PerturbInfo & source);

      double* perturb_radius_;
    };

    enum VariableType
    {
      CONTINUOUS,
      BINARY,
      INTEGER
    };

    TMINLP();

    virtual ~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)=0;

    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)
    {
      return false;
    }


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

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

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

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

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

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

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

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

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

    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)=0;
    virtual bool eval_gi(Ipopt::Index n, const Ipopt::Number* x, bool new_x,
                         Ipopt::Index i, Ipopt::Number& gi)
    {
      std::cerr << "Method eval_gi not overloaded from TMINLP\n";
      throw -1;
    }
    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)
    {
      std::cerr << "Method eval_grad_gi not overloaded from TMINLP\n";
      throw -1;
    }

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

    virtual const SosInfo * sosConstraints() const = 0;

    virtual const PerturbInfo* perturbInfo() const
    {
      return NULL;
    }

    virtual bool hasUpperBoundingObjective(){
      return false;}
    
    virtual bool eval_upper_bound_f(Ipopt::Index n, const Ipopt::Number* x,
                                    Ipopt::Number& obj_value){ return false; }

   enum Convexity {
     Convex,
     NonConvex,
     SimpleConcave};

   struct MarkedNonConvex {
         MarkedNonConvex():
         cIdx(-1), cRelaxIdx(-1){}
      int cIdx;
         int cRelaxIdx;};
   struct SimpleConcaveConstraint{
         SimpleConcaveConstraint():
           xIdx(-1), yIdx(-1), cIdx(-1){}
      int xIdx;
         int yIdx;
         int cIdx;};
    virtual bool get_constraint_convexities(int m, TMINLP::Convexity * constraints_convexities)const {
      CoinFillN(constraints_convexities, m, TMINLP::Convex);
      return true;}
  virtual bool get_number_nonconvex(int & number_non_conv, int & number_concave) const{
    number_non_conv = 0;
    number_concave = 0;
    return true;} 
  virtual bool get_constraint_convexities(int number_non_conv, MarkedNonConvex * non_convs) const{
    assert(number_non_conv == 0);
    return true;}
  virtual bool get_simple_concave_constraints(int number_concave, SimpleConcaveConstraint * simple_concave) const{
    assert(number_concave == 0);
    return true;}

  virtual bool hasLinearObjective(){return false;}

  bool hasGeneralInteger();

  virtual const int * get_const_xtra_id() const{
    return NULL;
  }
  protected:
    TMINLP(const TMINLP&);

    void operator=(const TMINLP&);

  private:
  };

} // namespace Ipopt

#endif