/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcBranchDynamic.hpp

Go to the documentation of this file.

// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcBranchDynamic_H
#define CbcBranchDynamic_H

#include "CbcBranchActual.hpp"
#include "CoinPackedMatrix.hpp"


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 
  ~CbcSimpleIntegerDynamicPseudoCost ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

  using CbcObject::createBranch ;
  virtual CbcBranchingObject * createBranch(int way) ;

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


  virtual CbcBranchingObject * createBranch(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) ;

  using CbcSimpleInteger::solverBranch ;
  virtual OsiSolverBranch * solverBranch() const;
  
  inline double downDynamicPseudoCost() const
  { return downDynamicPseudoCost_;}
  inline void setDownDynamicPseudoCost(double value)
  { downDynamicPseudoCost_=value;}

  inline double upDynamicPseudoCost() const
  { return upDynamicPseudoCost_;}
  inline void setUpDynamicPseudoCost(double value)
  { upDynamicPseudoCost_=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;sumDownCostSquared_ += value*value;}

  inline double sumUpCost() const
  { return sumUpCost_;}
  inline void setSumUpCost(double value)
  { sumUpCost_=value;}
  inline void addToSumUpCost(double value)
  { sumUpCost_+=value;lastUpCost_=value;sumUpCostSquared_ += value*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;}

  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 sumDownCostSquared_;
  mutable double sumUpCostSquared_;
  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_;
#define CBC_INSTRUMENT
#ifdef CBC_INSTRUMENT
  mutable int numberTimesInfeasible_;
#endif

  int method_;
};


class CbcDynamicPseudoCostBranchingObject : public CbcIntegerBranchingObject {

public:

  CbcDynamicPseudoCostBranchingObject ();

  CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable,
                                       int way , double value, 
                                       CbcSimpleIntegerDynamicPseudoCost * object) ;
  
  CbcDynamicPseudoCostBranchingObject (CbcModel *model, int variable, int way,
                             double lowerValue, double upperValue) ;
  
  CbcDynamicPseudoCostBranchingObject ( const CbcDynamicPseudoCostBranchingObject &);
   
  CbcDynamicPseudoCostBranchingObject & operator= (const CbcDynamicPseudoCostBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  virtual ~CbcDynamicPseudoCostBranchingObject ();

  void fillPart (int variable,
             int way , double value, 
             CbcSimpleIntegerDynamicPseudoCost * object) ;
  
  using CbcBranchingObject::branch ;
  virtual double branch();

  virtual int fillStrongInfo( CbcStrongInfo & info);

  inline double changeInGuessed() const
  { return changeInGuessed_;}
  inline void setChangeInGuessed(double value)
  { changeInGuessed_=value;}
  inline CbcSimpleIntegerDynamicPseudoCost * object() const
  { return object_;}
  inline void setObject(CbcSimpleIntegerDynamicPseudoCost * object)
  { object_=object;}

  virtual int type() const { return 400; }

  // LL: compareOriginalObject and compareBranchingObject are inherited from
  // CbcIntegerBranchingObject thus need not be declared/defined here. After
  // all, this kind of branching object is simply using pseudocosts to make
  // decisions, but once the decisions are made they are the same kind as in
  // the underlying class.

protected:
  double changeInGuessed_;
  CbcSimpleIntegerDynamicPseudoCost * object_;

};
class CbcBranchDynamicDecision : public CbcBranchDecision {
public:
  // Default Constructor 
  CbcBranchDynamicDecision ();

  // Copy constructor 
  CbcBranchDynamicDecision ( const CbcBranchDynamicDecision &);

  virtual ~CbcBranchDynamicDecision();

  virtual CbcBranchDecision * clone() const;

  virtual void initialize(CbcModel * model);

  virtual int betterBranch(CbcBranchingObject * thisOne,
                            CbcBranchingObject * bestSoFar,
                            double changeUp, int numInfUp,
                            double changeDn, int numInfDn);
  virtual void setBestCriterion(double value);
  virtual double getBestCriterion() const;
  virtual int whichMethod() {return 3;}

  virtual void saveBranchingObject(OsiBranchingObject * object) ;
  virtual void updateInformation(OsiSolverInterface * solver,
                                 const CbcNode * node);


private:
  
  CbcBranchDynamicDecision & operator=(const CbcBranchDynamicDecision& rhs);


  double bestCriterion_;

  double bestChangeUp_;

  int bestNumberUp_;

  double bestChangeDown_;

  int bestNumberDown_;

  CbcBranchingObject * bestObject_;
};
#endif

---