BonNWayObject.hpp

Go to the documentation of this file.

// $Id$
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

// Pierre Bonami 13/10/2011 copy and modify CbcNWay to adapt to use an OsiObject for Bonmin
//
// Edwin 11/9/2009-- carved out of CbcBranchActual

#ifndef BonNWayObject_H
#define BonNWayObject_H
#include "OsiBranchingObject.hpp"
#include "CbcConsequence.hpp"
#include <list>

namespace Bonmin {
class n_way_consequences {
public:
  std::vector<int> indices;

   n_way_consequences(): indices(){
   }

   n_way_consequences(const n_way_consequences& rhs): 
        indices(rhs.indices){
   }

   n_way_consequences& operator=(const n_way_consequences& rhs){
     if(this != &rhs){
       indices = rhs.indices;
     }
     return *this;
   }

  n_way_consequences * clone() const{
     return new n_way_consequences(*this);
  }

  void applyToSolver(OsiSolverInterface * solver, int state) const{
     if(state < 0) return;
     int num_one = 0;
     for(size_t i = 0 ; i < indices.size() ; i++){
         if(solver->getColLower()[indices[i]] > 0.9) num_one++;
         solver->setColUpper(indices[i],solver->getColLower()[indices[i]]);
     }
     assert(num_one == 0);
  }

};

class BonNWayObject : public OsiObject {

public:

    // Default Constructor
    BonNWayObject ();

    BonNWayObject (int numberMembers,
             const int * which, int identifier);

    // Copy constructor
    BonNWayObject ( const BonNWayObject &);

    virtual OsiObject * clone() const;

    BonNWayObject & operator=( const BonNWayObject& rhs);

    virtual ~BonNWayObject ();

    void setConsequence(int iMember, const n_way_consequences & consequence);

    void applyConsequence(OsiSolverInterface * solver,
                          int iSequence, int state) const;

    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;

    virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;

    inline size_t numberMembers() const {
        return members_.size();
    }

    inline const int * members() const {
        return members_.data();
    }

    void set_bounds(std::vector<double> & bounds) const{
      bounds_ = bounds;
    }

    void make_quick(){quicky_ = true;}

    void set_only_frac_branches(int depth){
      only_frac_branch_ = depth;
    }
private:

    std::vector<int> members_;
    n_way_consequences ** consequence_;

    mutable std::vector<double> bounds_;

    bool quicky_;
    int only_frac_branch_;
};
class BonNWayBranchingObject : public OsiBranchingObject {

public:

    // Default Constructor
    BonNWayBranchingObject ();

    BonNWayBranchingObject (OsiSolverInterface * solver,  const BonNWayObject * nway,
                            const std::vector<int>& order, const std::list<int>& skipped);

    // Copy constructor
    BonNWayBranchingObject ( const BonNWayBranchingObject &);

    // Assignment operator
    BonNWayBranchingObject & operator=( const BonNWayBranchingObject& rhs);

    virtual OsiBranchingObject * clone() const;

    // Destructor
    virtual ~BonNWayBranchingObject ();

    using OsiBranchingObject::branch ;
    virtual double branch(OsiSolverInterface * solver);

    virtual double branch(OsiSolverInterface * solver, int state);

    virtual int numberBranches() const {
        return static_cast<int>(order_.size()) + (!skipped_.empty());
    }
    virtual bool twoWay() const {
        return false;
    }

    inline int var_branched_on(){
      if(branchIndex_ > 0)
        return object_->members()[order_[branchIndex_ - 1]];
      return -1;
    }

    inline int seq_branched_on(){
      if(branchIndex_ > 0)
      return order_[branchIndex_ - 1];
      return -1;
    }

    inline int state_branched_on(){
      return branchIndex_ - 1;
    }
private:
    const BonNWayObject * object_;
    std::vector<int> order_;
    std::list<int> skipped_;
};

}

#endif