CbcSimpleIntegerDynamicPseudoCost.hpp

Go to the documentation of this file.

// $Id: CbcSimpleIntegerDynamicPseudoCost.hpp 2094 2014-11-18 11:15:36Z forrest $
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
// 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 numberTimesBranched() const {
        return numberTimesDown_ + 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_;
};
#ifdef SWITCH_VARIABLES
 
class CbcSwitchingBinary : public CbcSimpleIntegerDynamicPseudoCost {
 
public:
 
    // Default Constructor
    CbcSwitchingBinary ();
 
    // Useful constructor 
    CbcSwitchingBinary (CbcSimpleIntegerDynamicPseudoCost * oldObject,
                        int nOdd,const int * other, const int * otherRow);
 
 
    // Copy constructor
    CbcSwitchingBinary ( const CbcSwitchingBinary &);
 
    virtual CbcObject * clone() const;
 
    // Assignment operator
    CbcSwitchingBinary & operator=( const CbcSwitchingBinary& rhs);
 
    // Destructor
    virtual ~CbcSwitchingBinary ();
 
    void addZeroSwitches(int nAdd,const int * columns);
    virtual double infeasibility(const OsiBranchingInformation * info,
                                 int &preferredWay) const;
 
    bool same(const CbcSwitchingBinary * obj) const;
    virtual int setAssociatedBounds(OsiSolverInterface * solver=NULL,
                          int cleanBasis=0) const;
    int checkAssociatedBounds(const OsiSolverInterface * solver,const double * solution,
                              int printLevel, int state[3], int & nBadFixed) const;
    inline const double * zeroLowerBound() const
    { return zeroLowerBound_; }
    inline const double * oneLowerBound() const
    { return oneLowerBound_; }
    inline const double * zeroUpperBound() const
    { return zeroUpperBound_; }
    inline const double * oneUpperBound() const
    { return oneUpperBound_; }
    inline const int * otherVariable() const
    { return otherVariable_;}
    inline int numberOther() const
    { return numberOther_;}
    inline int type() const
    { return type_;}
protected:
 
    double * zeroLowerBound_;
    double * oneLowerBound_;
    double * zeroUpperBound_;
    double * oneUpperBound_;
    int * otherVariable_;
    int numberOther_;
    int type_;
};
#endif
#endif