CbcSimpleInteger.hpp

Go to the documentation of this file.

// Edwin 11/9/2009-- carved out of CbcBranchActual

#ifndef CbcSimpleInteger_H
#define CbcSimpleInteger_H

class CbcIntegerBranchingObject : public CbcBranchingObject {

public:

    CbcIntegerBranchingObject ();

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

    CbcIntegerBranchingObject (CbcModel *model, int variable, int way,
                               double lowerValue, double upperValue) ;

    CbcIntegerBranchingObject ( const CbcIntegerBranchingObject &);

    CbcIntegerBranchingObject & operator= (const CbcIntegerBranchingObject& rhs);

    virtual CbcBranchingObject * clone() const;

    virtual ~CbcIntegerBranchingObject ();

    void fillPart ( int variable, int way , double value) ;
    using CbcBranchingObject::branch ;
    virtual double branch();
    virtual void fix(OsiSolverInterface * solver,
                     double * lower, double * upper,
                     int branchState) const ;
    virtual bool tighten(OsiSolverInterface * ) ;

#ifdef JJF_ZERO
    // No need to override. Default works fine.
    virtual void previousBranch();
#endif

    using CbcBranchingObject::print ;
    virtual void print();

    inline const double * downBounds() const {
        return down_;
    }
    inline const double * upBounds() const {
        return up_;
    }
    inline void setDownBounds(const double bounds[2]) {
        memcpy(down_, bounds, 2*sizeof(double));
    }
    inline void setUpBounds(const double bounds[2]) {
        memcpy(up_, bounds, 2*sizeof(double));
    }
#ifdef FUNNY_BRANCHING

    inline const int * variables() const {
        return variables_;
    }
    // New bound
    inline const double * newBounds() const {
        return newBounds_;
    }
    inline int numberExtraChangedBounds() const {
        return numberExtraChangedBounds_;
    }
    int applyExtraBounds(int iColumn, double lower, double upper, int way) ;
    void deactivate();
    inline bool active() const {
        return (down_[1] != -COIN_DBL_MAX);
    }
#endif

    virtual CbcBranchObjType type() const {
        return SimpleIntegerBranchObj;
    }

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

protected:
    double down_[2];
    double up_[2];
#ifdef FUNNY_BRANCHING

    int * variables_;
    // New bound
    double * newBounds_;
    int numberExtraChangedBounds_;
#endif
};



class CbcSimpleInteger : public CbcObject {

public:

    // Default Constructor
    CbcSimpleInteger ();

    // Useful constructor - passed model and index
    CbcSimpleInteger (CbcModel * model,  int iColumn, double breakEven = 0.5);

    // Useful constructor - passed model and Osi object
    CbcSimpleInteger (CbcModel * model,  const OsiSimpleInteger * object);

    // Copy constructor
    CbcSimpleInteger ( const CbcSimpleInteger &);

    virtual CbcObject * clone() const;

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

    // Destructor
    virtual ~CbcSimpleInteger ();
    OsiSimpleInteger * osiObject() const;
    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;

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

    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
    void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ;

    using CbcObject::solverBranch ;
    virtual OsiSolverBranch * solverBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;

    virtual void feasibleRegion();

    virtual int columnNumber() const;
    inline void setColumnNumber(int value) {
        columnNumber_ = value;
    }

    virtual void resetBounds(const OsiSolverInterface * solver) ;

    virtual void resetSequenceEtc(int numberColumns, const int * originalColumns) ;
    inline double originalLowerBound() const {
        return originalLower_;
    }
    inline void setOriginalLowerBound(double value) {
        originalLower_ = value;
    }
    inline double originalUpperBound() const {
        return originalUpper_;
    }
    inline void setOriginalUpperBound(double value) {
        originalUpper_ = value;
    }
    inline double breakEven() const {
        return breakEven_;
    }
    inline void setBreakEven(double value) {
        breakEven_ = value;
    }


protected:

    double originalLower_;
    double originalUpper_;
    double breakEven_;
    int columnNumber_;
    int preferredWay_;
};
#endif