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

Go to the documentation of this file.

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

#include "CbcBranchBase.hpp"
#include "CoinPackedMatrix.hpp"
class CbcIntegerBranchingObject;


class CbcClique : public CbcObject {

public:

  // Default Constructor 
  CbcClique ();

  CbcClique (CbcModel * model, int cliqueType, int numberMembers,
             const int * which, const char * type,
             int identifier,int slack=-1);
  
  // Copy constructor 
  CbcClique ( const CbcClique &);
   
  virtual CbcObject * clone() const;

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

  // Destructor 
  ~CbcClique ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

  using CbcObject::feasibleRegion ;
  virtual void feasibleRegion();

  using CbcObject::createBranch ;
  virtual CbcBranchingObject * createBranch(int way) ;
  inline int numberMembers() const
  {return numberMembers_;}

  inline int numberNonSOSMembers() const
  {return numberNonSOSMembers_;}

  inline const int * members() const
  {return members_;}

  inline char type(int index) const
  {if (type_) return type_[index]; else return 1;}

  inline int cliqueType() const
  {return cliqueType_;}
  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);

protected:
  int numberMembers_;

  int numberNonSOSMembers_;

  int * members_;

  char * type_;

   int cliqueType_;

  int slack_;
};

class CbcSOS : public CbcObject {

public:

  // Default Constructor 
  CbcSOS ();

  CbcSOS (CbcModel * model, int numberMembers,
           const int * which, const double * weights, int identifier,
          int type=1);
  
  // Copy constructor 
  CbcSOS ( const CbcSOS &);
   
  virtual CbcObject * clone() const;

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

  // Destructor 
  ~CbcSOS ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

  using CbcObject::feasibleRegion ;
  virtual void feasibleRegion();

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

  using CbcObject::solverBranch ;
  virtual OsiSolverBranch * solverBranch() const;
  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
  
  OsiSOS * osiObject(const OsiSolverInterface * solver) const;
  inline int numberMembers() const
  {return numberMembers_;}

  inline const int * members() const
  {return members_;}

  inline int sosType() const
  {return sosType_;}

  inline const double * weights() const
  { return weights_;}

  inline void setNumberMembers(int n)
  {numberMembers_ = n;}

  inline int * mutableMembers() const
  {return members_;}

  inline double * mutableWeights() const
  { return weights_;}

  virtual bool canDoHeuristics() const 
  {return (sosType_==1&&integerValued_);}
  inline void setIntegerValued(bool yesNo)
  { integerValued_=yesNo;}
private:

  int * members_;
  double * weights_;

  int numberMembers_;
   int sosType_;
  bool integerValued_;
};



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 
  ~CbcSimpleInteger ();
  OsiSimpleInteger * osiObject() const;
  using CbcObject::infeasibility ;
  virtual double infeasibility(const OsiSolverInterface * solver, 
                               const OsiBranchingInformation * info, int & preferredWay) const;

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

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

  virtual void feasibleRegion();

  virtual CbcBranchingObject * createBranch(int way) ;
  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_;
};
class CbcNWay : public CbcObject {

public:

  // Default Constructor 
  CbcNWay ();

  CbcNWay (CbcModel * model, int numberMembers,
             const int * which, int identifier);
  
  // Copy constructor 
  CbcNWay ( const CbcNWay &);
   
  virtual CbcObject * clone() const;

  CbcNWay & operator=( const CbcNWay& rhs);

  ~CbcNWay ();

  void setConsequence(int iColumn, const CbcConsequence & consequence);
  
  void applyConsequence(int iSequence, int state) const;
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

  using CbcObject::feasibleRegion ;
  virtual void feasibleRegion();

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

  inline int numberMembers() const
  {return numberMembers_;}

  inline const int * members() const
  {return members_;}
  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);

protected:
  int numberMembers_;

  int * members_;
  CbcConsequence ** consequence_;
};

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();

#if 0
  // 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 int type() const { return 100; }

  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 CbcSimpleIntegerPseudoCost : public CbcSimpleInteger {

public:

  // Default Constructor 
  CbcSimpleIntegerPseudoCost ();

  // Useful constructor - passed model index
  CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, double breakEven=0.5);
  
  // Useful constructor - passed and model index and pseudo costs
  CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, 
                              double downPseudoCost, double upPseudoCost);
  // Useful constructor - passed and model index and pseudo costs
  CbcSimpleIntegerPseudoCost (CbcModel * model, int dummy,int iColumn, 
                              double downPseudoCost, double upPseudoCost);
  
  // Copy constructor 
  CbcSimpleIntegerPseudoCost ( const CbcSimpleIntegerPseudoCost &);
   
  virtual CbcObject * clone() const;

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

  // Destructor 
  ~CbcSimpleIntegerPseudoCost ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

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

  inline double downPseudoCost() const
  { return downPseudoCost_;}
  inline void setDownPseudoCost(double value)
  { downPseudoCost_=value;}

  inline double upPseudoCost() const
  { return upPseudoCost_;}
  inline void setUpPseudoCost(double value)
  { upPseudoCost_=value;}

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

  virtual double upEstimate() const;
  virtual double downEstimate() const;
  
  inline int method() const
  { return method_;}
  inline void setMethod(int value)
  { method_=value;}

protected:

  double downPseudoCost_;
  double upPseudoCost_;
  double upDownSeparator_;
  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 int type() const { return 101; }

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

protected:
  double changeInGuessed_;
};


class CbcCliqueBranchingObject : public CbcBranchingObject {

public:

  // Default Constructor 
  CbcCliqueBranchingObject ();

  // Useful constructor
  CbcCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
                            int way,
                            int numberOnDownSide, const int * down,
                            int numberOnUpSide, const int * up);
  
  // Copy constructor 
  CbcCliqueBranchingObject ( const CbcCliqueBranchingObject &);
   
  // Assignment operator 
  CbcCliqueBranchingObject & operator=( const CbcCliqueBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  // Destructor 
  virtual ~CbcCliqueBranchingObject ();
  
  using CbcBranchingObject::branch ;
  virtual double branch();

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

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

  virtual int type() const { return 102; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

private:
  const CbcClique * clique_;
  unsigned int downMask_[2];
  unsigned int upMask_[2];
};


class CbcLongCliqueBranchingObject : public CbcBranchingObject {

public:

  // Default Constructor 
  CbcLongCliqueBranchingObject ();

  // Useful constructor
  CbcLongCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
                                 int way,
                            int numberOnDownSide, const int * down,
                            int numberOnUpSide, const int * up);
  
  // Copy constructor 
  CbcLongCliqueBranchingObject ( const CbcLongCliqueBranchingObject &);
   
  // Assignment operator 
  CbcLongCliqueBranchingObject & operator=( const CbcLongCliqueBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  // Destructor 
  virtual ~CbcLongCliqueBranchingObject ();
  
  using CbcBranchingObject::branch ;
  virtual double branch();

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

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

  virtual int type() const { return 103; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

private:
  const CbcClique * clique_;
  unsigned int * downMask_;
  unsigned int * upMask_;
};

class CbcSOSBranchingObject : public CbcBranchingObject {

public:

  // Default Constructor 
  CbcSOSBranchingObject ();

  // Useful constructor
  CbcSOSBranchingObject (CbcModel * model,  const CbcSOS * clique,
                            int way,
                         double separator);
  
  // Copy constructor 
  CbcSOSBranchingObject ( const CbcSOSBranchingObject &);
   
  // Assignment operator 
  CbcSOSBranchingObject & operator=( const CbcSOSBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  // Destructor 
  virtual ~CbcSOSBranchingObject ();
  
  using CbcBranchingObject::branch ;
  virtual double branch();

  virtual void previousBranch() {
    CbcBranchingObject::previousBranch();
    computeNonzeroRange();
  }

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

  virtual int type() const { return 104; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

  void computeNonzeroRange();

private:
  const CbcSOS * set_;
  double separator_;
  int firstNonzero_;
  int lastNonzero_;
};

class CbcNWayBranchingObject : public CbcBranchingObject {

public:

  // Default Constructor 
  CbcNWayBranchingObject ();

  CbcNWayBranchingObject (CbcModel * model,  const CbcNWay * nway,
                          int numberBranches, const int * order);
  
  // Copy constructor 
  CbcNWayBranchingObject ( const CbcNWayBranchingObject &);
   
  // Assignment operator 
  CbcNWayBranchingObject & operator=( const CbcNWayBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  // Destructor 
  virtual ~CbcNWayBranchingObject ();
  
  using CbcBranchingObject::branch ;
  virtual double branch();

#if 0
  // FIXME: what do we need to do here?
  virtual void previousBranch();
#endif

  using CbcBranchingObject::print ;
  virtual void print();
  virtual int numberBranches() const
  {return numberInSet_;}
  virtual bool twoWay() const
  { return false;}

  virtual int type() const { return 105; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

private:
  int * order_;
  const CbcNWay * object_;
  int numberInSet_;
};

class CbcBranchDefaultDecision : public CbcBranchDecision {
public:
  // Default Constructor 
  CbcBranchDefaultDecision ();

  // Copy constructor 
  CbcBranchDefaultDecision ( const CbcBranchDefaultDecision &);

  virtual ~CbcBranchDefaultDecision();

  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
  bestBranch (CbcBranchingObject ** objects, int numberObjects, int numberUnsatisfied,
              double * changeUp, int * numberInfeasibilitiesUp,
              double * changeDown, int * numberInfeasibilitiesDown,
              double objectiveValue) ;
private:
  
  CbcBranchDefaultDecision & operator=(const CbcBranchDefaultDecision& rhs);


  double bestCriterion_;

  double bestChangeUp_;

  int bestNumberUp_;

  double bestChangeDown_;

  CbcBranchingObject * bestObject_;

  int bestNumberDown_;

};

class CbcFollowOn : public CbcObject {

public:

  // Default Constructor 
  CbcFollowOn ();

  CbcFollowOn (CbcModel * model);
  
  // Copy constructor 
  CbcFollowOn ( const CbcFollowOn &);
   
  virtual CbcObject * clone() const;

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

  // Destructor 
  ~CbcFollowOn ();
  
  using CbcObject::infeasibility ;
  virtual double infeasibility(int & preferredWay) const;

  using CbcObject::feasibleRegion ;
  virtual void feasibleRegion();

  using CbcObject::createBranch ;
  virtual CbcBranchingObject * createBranch(int way) ;
  virtual int gutsOfFollowOn(int & otherRow, int & preferredWay) const;

protected:
  CoinPackedMatrix matrix_;
  CoinPackedMatrix matrixByRow_; 
  int * rhs_;
};
class CbcFixingBranchingObject : public CbcBranchingObject {

public:

  // Default Constructor 
  CbcFixingBranchingObject ();

  // Useful constructor
  CbcFixingBranchingObject (CbcModel * model, 
                            int way,
                            int numberOnDownSide, const int * down,
                            int numberOnUpSide, const int * up);
  
  // Copy constructor 
  CbcFixingBranchingObject ( const CbcFixingBranchingObject &);
   
  // Assignment operator 
  CbcFixingBranchingObject & operator=( const CbcFixingBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

  // Destructor 
  virtual ~CbcFixingBranchingObject ();
  
  using CbcBranchingObject::branch ;
  virtual double branch();

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

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

  virtual int type() const { return 106; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

private:
  int numberDown_;
  int numberUp_;
  int * downList_;
  int * upList_;
};
class CbcFixVariable : public CbcConsequence {

public:

  // Default Constructor 
  CbcFixVariable ();

  // One useful Constructor 
  CbcFixVariable (int numberStates,const int * states, const int * numberNewLower, const int ** newLowerValue,
                  const int ** lowerColumn,
                  const int * numberNewUpper, const int ** newUpperValue,
                  const int ** upperColumn);

  // Copy constructor 
  CbcFixVariable ( const CbcFixVariable & rhs);
   
  // Assignment operator 
  CbcFixVariable & operator=( const CbcFixVariable & rhs);

  virtual CbcConsequence * clone() const;

  virtual ~CbcFixVariable ();

  virtual void applyToSolver(OsiSolverInterface * solver, int state) const;
  
protected:
  int numberStates_;
  int * states_;
  int * startLower_;
  int * startUpper_;
  double * newBound_;
  int * variable_;
};
class CbcDummyBranchingObject : public CbcBranchingObject {

public:

  CbcDummyBranchingObject (CbcModel * model=NULL);

  CbcDummyBranchingObject ( const CbcDummyBranchingObject &);
   
  CbcDummyBranchingObject & operator= (const CbcDummyBranchingObject& rhs);

  virtual CbcBranchingObject * clone() const;

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

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

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

  virtual int type() const { return 107; }

  virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;

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

};


#endif

---