CbcSimpleIntegerDynamicPseudoCost.hpp

Go to the documentation of this file.

// $Id$
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/