CbcBranchingObject.hpp

Go to the documentation of this file.

// Edwin 11/12/2009 carved from CbcBranchBase
#ifndef CbcBranchingObject_H
#define CbcBranchingObject_H

#include <string>
#include <vector>
#include "CbcBranchBase.hpp"
#include "OsiBranchingObject.hpp"


// The types of objects that will be derived from this class.
enum CbcBranchObjType
  {
    SimpleIntegerBranchObj = 100,
    SimpleIntegerDynamicPseudoCostBranchObj = 101,
    CliqueBranchObj = 102,
    LongCliqueBranchObj = 103,
    SoSBranchObj = 104,
    NWayBranchObj = 105,
    FollowOnBranchObj = 106,
    DummyBranchObj = 107,
    GeneralDepthBranchObj = 108,
    OneGeneralBranchingObj = 110,
    CutBranchingObj = 200,
    LotsizeBranchObj = 300,
    DynamicPseudoCostBranchObj = 400
  };

class CbcBranchingObject : public OsiBranchingObject {

public:

    CbcBranchingObject ();

    CbcBranchingObject (CbcModel * model, int variable, int way , double value);

    CbcBranchingObject ( const CbcBranchingObject &);

    CbcBranchingObject & operator=( const CbcBranchingObject& rhs);

    virtual CbcBranchingObject * clone() const = 0;

    virtual ~CbcBranchingObject ();

    virtual int fillStrongInfo( CbcStrongInfo & ) {
        return 0;
    }
    inline void resetNumberBranchesLeft() {
        branchIndex_ = 0;
    }
    inline void setNumberBranches(int value) {
        branchIndex_ = 0;
        numberBranches_ = value;
    }

    virtual double branch() = 0;
    virtual double branch(OsiSolverInterface * ) {
        return branch();
    }
    virtual void fix(OsiSolverInterface * ,
                     double * , double * ,
                     int ) const {}

    virtual bool tighten(OsiSolverInterface * ) {return false;}

    virtual void previousBranch() {
        assert(branchIndex_ > 0);
        branchIndex_--;
        way_ = -way_;
    }

    using OsiBranchingObject::print ;
    virtual void print() const {}

    inline int variable() const {
        return variable_;
    }

    inline int way() const {
        return way_;
    }

    inline void way(int way) {
        way_ = way;
    }

    inline void setModel(CbcModel * model) {
        model_ = model;
    }
    inline CbcModel * model() const {
        return  model_;
    }

    inline CbcObject * object() const {
        return  originalCbcObject_;
    }
    inline void setOriginalObject(CbcObject * object) {
        originalCbcObject_ = object;
    }

    // Methods used in heuristics

    virtual CbcBranchObjType type() const = 0;

    virtual int compareOriginalObject(const CbcBranchingObject* brObj) const {
        const CbcBranchingObject* br = dynamic_cast<const CbcBranchingObject*>(brObj);
        return variable() - br->variable();
    }

    virtual CbcRangeCompare compareBranchingObject
    (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false) = 0;

protected:

    CbcModel * model_;
    CbcObject * originalCbcObject_;

    int variable_;
    // was - Way to branch - -1 down (first), 1 up, -2 down (second), 2 up (second)
    int way_;

};
#endif