CbcSimpleIntegerDynamicPseudoCost.hpp

Go to the documentation of this file.

// Edwin 11/17/2009 - carved out of CbcBranchDynamic
#ifndef CbcSimpleIntegerDynamicPseudoCost_H
#define CbcSimpleIntegerDynamicPseudoCost_H

#include "CbcSimpleInteger.hpp"

#define TYPERATIO 0.9
#define MINIMUM_MOVEMENT 0.1
#define TYPE2 0
// was 1 - but that looks flakey
#define INFEAS 1
#define MOD_SHADOW 1
// weight at 1.0 is max min
#define WEIGHT_AFTER 0.8
#define WEIGHT_BEFORE 0.1
//Stolen from Constraint Integer Programming book (with epsilon change)
#define WEIGHT_PRODUCT


class CbcSimpleIntegerDynamicPseudoCost : public CbcSimpleInteger {

public:

    // Default Constructor
    CbcSimpleIntegerDynamicPseudoCost ();

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

    // Useful constructor - passed  model index and pseudo costs
    CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int iColumn,
                                       double downDynamicPseudoCost, double upDynamicPseudoCost);

    // Useful constructor - passed  model index and pseudo costs
    CbcSimpleIntegerDynamicPseudoCost (CbcModel * model, int dummy, int iColumn,
                                       double downDynamicPseudoCost, double upDynamicPseudoCost);

    // Copy constructor
    CbcSimpleIntegerDynamicPseudoCost ( const CbcSimpleIntegerDynamicPseudoCost &);

    virtual CbcObject * clone() const;

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

    // Destructor
    virtual ~CbcSimpleIntegerDynamicPseudoCost ();

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

    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;


    void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ;


    virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver,
            const CbcNode * node,
            const CbcBranchingObject * branchingObject);
    virtual void updateInformation(const CbcObjectUpdateData & data) ;
    void copySome(const CbcSimpleIntegerDynamicPseudoCost * otherObject);
    virtual void updateBefore(const OsiObject * rhs) ;
    virtual void updateAfter(const OsiObject * rhs, const OsiObject * baseObject) ;
    void updateAfterMini(int numberDown, int numberDownInfeasible, double sumDown,
                         int numberUp, int numberUpInfeasible, double sumUp);

    using CbcSimpleInteger::solverBranch ;
    virtual OsiSolverBranch * solverBranch() const;

    inline double downDynamicPseudoCost() const {
        return downDynamicPseudoCost_;
    }
    void setDownDynamicPseudoCost(double value) ;
    void updateDownDynamicPseudoCost(double value);

    inline double upDynamicPseudoCost() const {
        return upDynamicPseudoCost_;
    }
    void setUpDynamicPseudoCost(double value);
    void updateUpDynamicPseudoCost(double value);

    inline double downShadowPrice() const {
        return downShadowPrice_;
    }
    inline void setDownShadowPrice(double value) {
        downShadowPrice_ = value;
    }
    inline double upShadowPrice() const {
        return upShadowPrice_;
    }
    inline void setUpShadowPrice(double value) {
        upShadowPrice_ = value;
    }

    inline double upDownSeparator() const {
        return upDownSeparator_;
    }
    inline void setUpDownSeparator(double value) {
        upDownSeparator_ = value;
    }

    inline double sumDownCost() const {
        return sumDownCost_;
    }
    inline void setSumDownCost(double value) {
        sumDownCost_ = value;
    }
    inline void addToSumDownCost(double value) {
        sumDownCost_ += value;
        lastDownCost_ = value;
    }

    inline double sumUpCost() const {
        return sumUpCost_;
    }
    inline void setSumUpCost(double value) {
        sumUpCost_ = value;
    }
    inline void addToSumUpCost(double value) {
        sumUpCost_ += value;
        lastUpCost_ = value;
    }

    inline double sumDownChange() const {
        return sumDownChange_;
    }
    inline void setSumDownChange(double value) {
        sumDownChange_ = value;
    }
    inline void addToSumDownChange(double value) {
        sumDownChange_ += value;
    }

    inline double sumUpChange() const {
        return sumUpChange_;
    }
    inline void setSumUpChange(double value) {
        sumUpChange_ = value;
    }
    inline void addToSumUpChange(double value) {
        sumUpChange_ += value;
    }

    inline double sumDownDecrease() const {
        return sumDownDecrease_;
    }
    inline void setSumDownDecrease(double value) {
        sumDownDecrease_ = value;
    }
    inline void addToSumDownDecrease(double value) {
        sumDownDecrease_ += value;/*lastDownDecrease_ = (int) value;*/
    }

    inline double sumUpDecrease() const {
        return sumUpDecrease_;
    }
    inline void setSumUpDecrease(double value) {
        sumUpDecrease_ = value;
    }
    inline void addToSumUpDecrease(double value) {
        sumUpDecrease_ += value;/*lastUpDecrease_ = (int) value;*/
    }

    inline int numberTimesDown() const {
        return numberTimesDown_;
    }
    inline void setNumberTimesDown(int value) {
        numberTimesDown_ = value;
    }
    inline void incrementNumberTimesDown() {
        numberTimesDown_++;
    }

    inline int numberTimesUp() const {
        return numberTimesUp_;
    }
    inline void setNumberTimesUp(int value) {
        numberTimesUp_ = value;
    }
    inline void incrementNumberTimesUp() {
        numberTimesUp_++;
    }

    inline int numberTimesDownInfeasible() const {
        return numberTimesDownInfeasible_;
    }
    inline void setNumberTimesDownInfeasible(int value) {
        numberTimesDownInfeasible_ = value;
    }
    inline void incrementNumberTimesDownInfeasible() {
        numberTimesDownInfeasible_++;
    }

    inline int numberTimesUpInfeasible() const {
        return numberTimesUpInfeasible_;
    }
    inline void setNumberTimesUpInfeasible(int value) {
        numberTimesUpInfeasible_ = value;
    }
    inline void incrementNumberTimesUpInfeasible() {
        numberTimesUpInfeasible_++;
    }

    inline int numberBeforeTrust() const {
        return numberBeforeTrust_;
    }
    inline void setNumberBeforeTrust(int value) {
        numberBeforeTrust_ = value;
    }
    inline void incrementNumberBeforeTrust() {
        numberBeforeTrust_++;
    }

    virtual double upEstimate() const;
    virtual double downEstimate() const;

    inline int method() const {
        return method_;
    }
    inline void setMethod(int value) {
        method_ = value;
    }

    void setDownInformation(double changeObjectiveDown, int changeInfeasibilityDown);
    void setUpInformation(double changeObjectiveUp, int changeInfeasibilityUp);
    void setProbingInformation(int fixedDown, int fixedUp);

    void print(int type = 0, double value = 0.0) const;
    bool same(const CbcSimpleIntegerDynamicPseudoCost * obj) const;
protected:

    double downDynamicPseudoCost_;
    double upDynamicPseudoCost_;
    double upDownSeparator_;
    double sumDownCost_;
    double sumUpCost_;
    double sumDownChange_;
    double sumUpChange_;
    mutable double downShadowPrice_;
    mutable double upShadowPrice_;
    double sumDownDecrease_;
    double sumUpDecrease_;
    double lastDownCost_;
    double lastUpCost_;
    mutable int lastDownDecrease_;
    mutable int lastUpDecrease_;
    int numberTimesDown_;
    int numberTimesUp_;
    int numberTimesDownInfeasible_;
    int numberTimesUpInfeasible_;
    int numberBeforeTrust_;
    int numberTimesDownLocalFixed_;
    int numberTimesUpLocalFixed_;
    double numberTimesDownTotalFixed_;
    double numberTimesUpTotalFixed_;
    int numberTimesProbingTotal_;

    int method_;
};
class CbcIntegerPseudoCostBranchingObject : public CbcIntegerBranchingObject {

public:

    CbcIntegerPseudoCostBranchingObject ();

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

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

    CbcIntegerPseudoCostBranchingObject ( const CbcIntegerPseudoCostBranchingObject &);

    CbcIntegerPseudoCostBranchingObject & operator= (const CbcIntegerPseudoCostBranchingObject& rhs);

    virtual CbcBranchingObject * clone() const;

    virtual ~CbcIntegerPseudoCostBranchingObject ();

    using CbcBranchingObject::branch ;
    virtual double branch();

    inline double changeInGuessed() const {
        return changeInGuessed_;
    }
    inline void setChangeInGuessed(double value) {
        changeInGuessed_ = value;
    }

    virtual CbcBranchObjType type() const {
        return SimpleIntegerDynamicPseudoCostBranchObj;
    }

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

protected:
    double changeInGuessed_;
};
#endif