/home/coin/SVN-release/Cbc-2.4.0/Cbc/src/CbcBranchActual.hpp

Go to the documentation of this file.
00001 /* $Id: CbcBranchActual.hpp 1271 2009-11-05 15:57:25Z forrest $ */
00002 // Copyright (C) 2002, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 #ifndef CbcBranchActual_H
00005 #define CbcBranchActual_H
00006 
00007 #include "CbcBranchBase.hpp"
00008 #include "CoinPackedMatrix.hpp"
00009 class CbcIntegerBranchingObject;
00011 
00012 
00013 class CbcClique : public CbcObject {
00014 
00015 public:
00016 
00017   // Default Constructor 
00018   CbcClique ();
00019 
00024   CbcClique (CbcModel * model, int cliqueType, int numberMembers,
00025              const int * which, const char * type,
00026              int identifier,int slack=-1);
00027   
00028   // Copy constructor 
00029   CbcClique ( const CbcClique &);
00030    
00032   virtual CbcObject * clone() const;
00033 
00034   // Assignment operator 
00035   CbcClique & operator=( const CbcClique& rhs);
00036 
00037   // Destructor 
00038   virtual ~CbcClique ();
00039   
00041   virtual double infeasibility(const OsiBranchingInformation * info,
00042                                int &preferredWay) const;
00043 
00044   using CbcObject::feasibleRegion ;
00046   virtual void feasibleRegion();
00047 
00049   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
00051   inline int numberMembers() const
00052   {return numberMembers_;}
00053 
00055   inline int numberNonSOSMembers() const
00056   {return numberNonSOSMembers_;}
00057 
00059   inline const int * members() const
00060   {return members_;}
00061 
00064   inline char type(int index) const
00065   {if (type_) return type_[index]; else return 1;}
00066 
00068   inline int cliqueType() const
00069   {return cliqueType_;}
00071   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
00072 
00073 protected:
00076   int numberMembers_;
00077 
00079   int numberNonSOSMembers_;
00080 
00082   int * members_;
00083 
00085   char * type_;
00086 
00088    int cliqueType_;
00089 
00091   int slack_;
00092 };
00093 
00101 class CbcSOS : public CbcObject {
00102 
00103 public:
00104 
00105   // Default Constructor 
00106   CbcSOS ();
00107 
00112   CbcSOS (CbcModel * model, int numberMembers,
00113            const int * which, const double * weights, int identifier,
00114           int type=1);
00115   
00116   // Copy constructor 
00117   CbcSOS ( const CbcSOS &);
00118    
00120   virtual CbcObject * clone() const;
00121 
00122   // Assignment operator 
00123   CbcSOS & operator=( const CbcSOS& rhs);
00124 
00125   // Destructor 
00126   virtual ~CbcSOS ();
00127   
00129   virtual double infeasibility(const OsiBranchingInformation * info,
00130                                int &preferredWay) const;
00131 
00132   using CbcObject::feasibleRegion ;
00134   virtual void feasibleRegion();
00135 
00137   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
00138 
00139 
00140 
00144   virtual CbcObjectUpdateData createUpdateInformation(const OsiSolverInterface * solver, 
00145                                                         const CbcNode * node,
00146                                                         const CbcBranchingObject * branchingObject);
00148   virtual void updateInformation(const CbcObjectUpdateData & data) ;
00149   using CbcObject::solverBranch ;
00154   virtual OsiSolverBranch * solverBranch() const;
00156   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
00157   
00159   OsiSOS * osiObject(const OsiSolverInterface * solver) const;
00161   inline int numberMembers() const
00162   {return numberMembers_;}
00163 
00165   inline const int * members() const
00166   {return members_;}
00167 
00169   inline int sosType() const
00170   {return sosType_;}
00172   inline int numberTimesDown() const
00173   { return numberTimesDown_;}
00175   inline int numberTimesUp() const
00176   { return numberTimesUp_;}
00177 
00179   inline const double * weights() const
00180   { return weights_;}
00181 
00183   inline void setNumberMembers(int n)
00184   {numberMembers_ = n;}
00185 
00187   inline int * mutableMembers() const
00188   {return members_;}
00189 
00191   inline double * mutableWeights() const
00192   { return weights_;}
00193 
00196   virtual bool canDoHeuristics() const 
00197   {return (sosType_==1&&integerValued_);}
00199   inline void setIntegerValued(bool yesNo)
00200   { integerValued_=yesNo;}
00201 private:
00203 
00205   int * members_;
00207   double * weights_;
00209   mutable double shadowEstimateDown_;
00211   mutable double shadowEstimateUp_;
00213   double downDynamicPseudoRatio_;
00215   double upDynamicPseudoRatio_;
00217   int numberTimesDown_;
00219   int numberTimesUp_;
00221   int numberMembers_;
00223   int sosType_;
00225   bool integerValued_;
00226 };
00227 
00229 
00230 
00231 class CbcSimpleInteger : public CbcObject {
00232 
00233 public:
00234 
00235   // Default Constructor 
00236   CbcSimpleInteger ();
00237 
00238   // Useful constructor - passed model and index
00239   CbcSimpleInteger (CbcModel * model,  int iColumn, double breakEven=0.5);
00240   
00241   // Useful constructor - passed model and Osi object
00242   CbcSimpleInteger (CbcModel * model,  const OsiSimpleInteger * object);
00243   
00244   // Copy constructor 
00245   CbcSimpleInteger ( const CbcSimpleInteger &);
00246    
00248   virtual CbcObject * clone() const;
00249 
00250   // Assignment operator 
00251   CbcSimpleInteger & operator=( const CbcSimpleInteger& rhs);
00252 
00253   // Destructor 
00254   virtual ~CbcSimpleInteger ();
00256   OsiSimpleInteger * osiObject() const;
00258   virtual double infeasibility(const OsiBranchingInformation * info,
00259                                int &preferredWay) const;
00260 
00261   using CbcObject::feasibleRegion ;
00267   virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
00268 
00274   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
00276   void fillCreateBranch(CbcIntegerBranchingObject * branching, const OsiBranchingInformation * info, int way) ;
00277 
00278   using CbcObject::solverBranch ;
00283   virtual OsiSolverBranch * solverBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
00284 
00291   virtual void feasibleRegion();
00292 
00297   virtual int columnNumber() const;
00299   inline void setColumnNumber(int value)
00300   { columnNumber_ = value;}
00301 
00306   virtual void resetBounds(const OsiSolverInterface * solver) ;
00309   virtual void resetSequenceEtc(int numberColumns, const int * originalColumns) ;
00311   inline double originalLowerBound() const
00312   { return originalLower_;}
00313   inline void setOriginalLowerBound(double value)
00314   { originalLower_=value;}
00315   inline double originalUpperBound() const
00316   { return originalUpper_;}
00317   inline void setOriginalUpperBound(double value)
00318   { originalUpper_=value;}
00320   inline double breakEven() const
00321   { return breakEven_;}
00323   inline void setBreakEven(double value)
00324   { breakEven_=value;}
00325 
00326 
00327 protected:
00329 
00331   double originalLower_;
00333   double originalUpper_;
00335   double breakEven_;
00337   int columnNumber_;
00339   int preferredWay_;
00340 };
00347 class CbcNWay : public CbcObject {
00348 
00349 public:
00350 
00351   // Default Constructor 
00352   CbcNWay ();
00353 
00356   CbcNWay (CbcModel * model, int numberMembers,
00357              const int * which, int identifier);
00358   
00359   // Copy constructor 
00360   CbcNWay ( const CbcNWay &);
00361    
00363   virtual CbcObject * clone() const;
00364 
00366   CbcNWay & operator=( const CbcNWay& rhs);
00367 
00369   virtual ~CbcNWay ();
00370 
00372   void setConsequence(int iColumn, const CbcConsequence & consequence);
00373   
00375   void applyConsequence(int iSequence, int state) const;
00376   
00378   virtual double infeasibility(const OsiBranchingInformation * info,
00379                                int &preferredWay) const;
00380 
00381   using CbcObject::feasibleRegion ;
00383   virtual void feasibleRegion();
00384 
00386   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
00387 
00389   inline int numberMembers() const
00390   {return numberMembers_;}
00391 
00393   inline const int * members() const
00394   {return members_;}
00396   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
00397 
00398 protected:
00401   int numberMembers_;
00402 
00404   int * members_;
00406   CbcConsequence ** consequence_;
00407 };
00408 
00419 class CbcIntegerBranchingObject : public CbcBranchingObject {
00420 
00421 public:
00422 
00424   CbcIntegerBranchingObject ();
00425 
00433   CbcIntegerBranchingObject (CbcModel *model, int variable,
00434                              int way , double value) ;
00435   
00443   CbcIntegerBranchingObject (CbcModel *model, int variable, int way,
00444                              double lowerValue, double upperValue) ;
00445   
00447   CbcIntegerBranchingObject ( const CbcIntegerBranchingObject &);
00448    
00450   CbcIntegerBranchingObject & operator= (const CbcIntegerBranchingObject& rhs);
00451 
00453   virtual CbcBranchingObject * clone() const;
00454 
00456   virtual ~CbcIntegerBranchingObject ();
00457 
00459   void fillPart ( int variable, int way , double value) ;
00460   using CbcBranchingObject::branch ;
00465   virtual double branch();
00468   virtual void fix(OsiSolverInterface * solver,
00469                    double * lower, double * upper,
00470                    int branchState) const ;
00471 
00472 #if 0
00473   // No need to override. Default works fine.
00477   virtual void previousBranch();
00478 #endif
00479 
00480   using CbcBranchingObject::print ;
00483   virtual void print();
00484 
00486   inline const double * downBounds() const
00487   { return down_;}
00489   inline const double * upBounds() const
00490   { return up_;}
00492   inline void setDownBounds(const double bounds[2])
00493   { memcpy(down_,bounds,2*sizeof(double));}
00495   inline void setUpBounds(const double bounds[2])
00496   { memcpy(up_,bounds,2*sizeof(double));}
00497 #ifdef FUNNY_BRANCHING
00498 
00500   inline const int * variables() const
00501   { return variables_;}
00502   // New bound
00503   inline const double * newBounds() const
00504   { return newBounds_;}
00506   inline int numberExtraChangedBounds() const
00507   { return numberExtraChangedBounds_;}
00509   int applyExtraBounds(int iColumn, double lower, double upper, int way) ;
00511   void deactivate();
00513   inline bool active() const
00514   { return (down_[1]!=-COIN_DBL_MAX);}
00515 #endif
00516 
00518   virtual int type() const { return 100; }
00519 
00528   virtual CbcRangeCompare compareBranchingObject
00529   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
00530 
00531 protected:
00533   double down_[2];
00535   double up_[2];
00536 #ifdef FUNNY_BRANCHING
00537 
00539   int * variables_;
00540   // New bound
00541   double * newBounds_;
00543   int numberExtraChangedBounds_;
00544 #endif
00545 };
00546 
00547 
00549 
00550 
00551 class CbcSimpleIntegerPseudoCost : public CbcSimpleInteger {
00552 
00553 public:
00554 
00555   // Default Constructor 
00556   CbcSimpleIntegerPseudoCost ();
00557 
00558   // Useful constructor - passed model index
00559   CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, double breakEven=0.5);
00560   
00561   // Useful constructor - passed and model index and pseudo costs
00562   CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, 
00563                               double downPseudoCost, double upPseudoCost);
00564   // Useful constructor - passed and model index and pseudo costs
00565   CbcSimpleIntegerPseudoCost (CbcModel * model, int dummy,int iColumn, 
00566                               double downPseudoCost, double upPseudoCost);
00567   
00568   // Copy constructor 
00569   CbcSimpleIntegerPseudoCost ( const CbcSimpleIntegerPseudoCost &);
00570    
00572   virtual CbcObject * clone() const;
00573 
00574   // Assignment operator 
00575   CbcSimpleIntegerPseudoCost & operator=( const CbcSimpleIntegerPseudoCost& rhs);
00576 
00577   // Destructor 
00578   virtual ~CbcSimpleIntegerPseudoCost ();
00579   
00581   virtual double infeasibility(const OsiBranchingInformation * info,
00582                                int &preferredWay) const;
00583 
00585   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
00586 
00588   inline double downPseudoCost() const
00589   { return downPseudoCost_;}
00591   inline void setDownPseudoCost(double value)
00592   { downPseudoCost_=value;}
00593 
00595   inline double upPseudoCost() const
00596   { return upPseudoCost_;}
00598   inline void setUpPseudoCost(double value)
00599   { upPseudoCost_=value;}
00600 
00602   inline double upDownSeparator() const
00603   { return upDownSeparator_;}
00605   inline void setUpDownSeparator(double value)
00606   { upDownSeparator_=value;}
00607 
00609   virtual double upEstimate() const;
00611   virtual double downEstimate() const;
00612   
00614   inline int method() const
00615   { return method_;}
00617   inline void setMethod(int value)
00618   { method_=value;}
00619 
00620 protected:
00622 
00624   double downPseudoCost_;
00626   double upPseudoCost_;
00631   double upDownSeparator_;
00638   int method_;
00639 };
00640 
00641 
00652 class CbcIntegerPseudoCostBranchingObject : public CbcIntegerBranchingObject {
00653 
00654 public:
00655 
00657   CbcIntegerPseudoCostBranchingObject ();
00658 
00666   CbcIntegerPseudoCostBranchingObject (CbcModel *model, int variable,
00667                              int way , double value) ;
00668   
00676   CbcIntegerPseudoCostBranchingObject (CbcModel *model, int variable, int way,
00677                              double lowerValue, double upperValue) ;
00678   
00680   CbcIntegerPseudoCostBranchingObject ( const CbcIntegerPseudoCostBranchingObject &);
00681    
00683   CbcIntegerPseudoCostBranchingObject & operator= (const CbcIntegerPseudoCostBranchingObject& rhs);
00684 
00686   virtual CbcBranchingObject * clone() const;
00687 
00689   virtual ~CbcIntegerPseudoCostBranchingObject ();
00690   
00691   using CbcBranchingObject::branch ;
00696   virtual double branch();
00697 
00699   inline double changeInGuessed() const
00700   { return changeInGuessed_;}
00702   inline void setChangeInGuessed(double value)
00703   { changeInGuessed_=value;}
00704 
00706   virtual int type() const { return 101; }
00707 
00716   virtual CbcRangeCompare compareBranchingObject
00717   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
00718 
00719 protected:
00721   double changeInGuessed_;
00722 };
00723 
00724 
00733 class CbcCliqueBranchingObject : public CbcBranchingObject {
00734 
00735 public:
00736 
00737   // Default Constructor 
00738   CbcCliqueBranchingObject ();
00739 
00740   // Useful constructor
00741   CbcCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
00742                             int way,
00743                             int numberOnDownSide, const int * down,
00744                             int numberOnUpSide, const int * up);
00745   
00746   // Copy constructor 
00747   CbcCliqueBranchingObject ( const CbcCliqueBranchingObject &);
00748    
00749   // Assignment operator 
00750   CbcCliqueBranchingObject & operator=( const CbcCliqueBranchingObject& rhs);
00751 
00753   virtual CbcBranchingObject * clone() const;
00754 
00755   // Destructor 
00756   virtual ~CbcCliqueBranchingObject ();
00757   
00758   using CbcBranchingObject::branch ;
00760   virtual double branch();
00761 
00762 #if 0
00763   // No need to override. Default works fine.
00767   virtual void previousBranch();
00768 #endif
00769 
00770   using CbcBranchingObject::print ;
00773   virtual void print();
00774 
00776   virtual int type() const { return 102; }
00777 
00785   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
00786 
00795   virtual CbcRangeCompare compareBranchingObject
00796   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
00797 
00798 private:
00800   const CbcClique * clique_;
00802   unsigned int downMask_[2];
00804   unsigned int upMask_[2];
00805 };
00806 
00807 
00812 class CbcLongCliqueBranchingObject : public CbcBranchingObject {
00813 
00814 public:
00815 
00816   // Default Constructor 
00817   CbcLongCliqueBranchingObject ();
00818 
00819   // Useful constructor
00820   CbcLongCliqueBranchingObject (CbcModel * model,  const CbcClique * clique,
00821                                  int way,
00822                             int numberOnDownSide, const int * down,
00823                             int numberOnUpSide, const int * up);
00824   
00825   // Copy constructor 
00826   CbcLongCliqueBranchingObject ( const CbcLongCliqueBranchingObject &);
00827    
00828   // Assignment operator 
00829   CbcLongCliqueBranchingObject & operator=( const CbcLongCliqueBranchingObject& rhs);
00830 
00832   virtual CbcBranchingObject * clone() const;
00833 
00834   // Destructor 
00835   virtual ~CbcLongCliqueBranchingObject ();
00836   
00837   using CbcBranchingObject::branch ;
00839   virtual double branch();
00840 
00841 #if 0
00842   // No need to override. Default works fine.
00846   virtual void previousBranch();
00847 #endif
00848 
00849   using CbcBranchingObject::print ;
00852   virtual void print();
00853 
00855   virtual int type() const { return 103; }
00856 
00864   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
00865 
00874   virtual CbcRangeCompare compareBranchingObject
00875   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
00876 
00877 private:
00879   const CbcClique * clique_;
00881   unsigned int * downMask_;
00883   unsigned int * upMask_;
00884 };
00885 
00891 class CbcSOSBranchingObject : public CbcBranchingObject {
00892 
00893 public:
00894 
00895   // Default Constructor 
00896   CbcSOSBranchingObject ();
00897 
00898   // Useful constructor
00899   CbcSOSBranchingObject (CbcModel * model,  const CbcSOS * clique,
00900                             int way,
00901                          double separator);
00902   
00903   // Copy constructor 
00904   CbcSOSBranchingObject ( const CbcSOSBranchingObject &);
00905    
00906   // Assignment operator 
00907   CbcSOSBranchingObject & operator=( const CbcSOSBranchingObject& rhs);
00908 
00910   virtual CbcBranchingObject * clone() const;
00911 
00912   // Destructor 
00913   virtual ~CbcSOSBranchingObject ();
00914   
00915   using CbcBranchingObject::branch ;
00917   virtual double branch();
00920   virtual void fix(OsiSolverInterface * solver,
00921                    double * lower, double * upper,
00922                    int branchState) const ;
00923 
00927   virtual void previousBranch() {
00928     CbcBranchingObject::previousBranch();
00929     computeNonzeroRange();
00930   }
00931 
00932   using CbcBranchingObject::print ;
00935   virtual void print();
00936 
00938   virtual int type() const { return 104; }
00939 
00947   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
00948 
00957   virtual CbcRangeCompare compareBranchingObject
00958   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
00959 
00961   void computeNonzeroRange();
00962 
00963 private:
00965   const CbcSOS * set_;
00967   double separator_;
00973   int firstNonzero_;
00974   int lastNonzero_;
00975 };
00976 
00980 class CbcNWayBranchingObject : public CbcBranchingObject {
00981 
00982 public:
00983 
00984   // Default Constructor 
00985   CbcNWayBranchingObject ();
00986 
00991   CbcNWayBranchingObject (CbcModel * model,  const CbcNWay * nway,
00992                           int numberBranches, const int * order);
00993   
00994   // Copy constructor 
00995   CbcNWayBranchingObject ( const CbcNWayBranchingObject &);
00996    
00997   // Assignment operator 
00998   CbcNWayBranchingObject & operator=( const CbcNWayBranchingObject& rhs);
00999 
01001   virtual CbcBranchingObject * clone() const;
01002 
01003   // Destructor 
01004   virtual ~CbcNWayBranchingObject ();
01005   
01006   using CbcBranchingObject::branch ;
01008   virtual double branch();
01009 
01010 #if 0
01011   // FIXME: what do we need to do here?
01015   virtual void previousBranch();
01016 #endif
01017 
01018   using CbcBranchingObject::print ;
01021   virtual void print();
01024   virtual int numberBranches() const
01025   {return numberInSet_;}
01027   virtual bool twoWay() const
01028   { return false;}
01029 
01031   virtual int type() const { return 105; }
01032 
01040   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
01041 
01050   virtual CbcRangeCompare compareBranchingObject
01051   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
01052 
01053 private:
01055   int * order_;
01057   const CbcNWay * object_;
01059   int numberInSet_;
01060 };
01061 
01068 class CbcBranchDefaultDecision : public CbcBranchDecision {
01069 public:
01070   // Default Constructor 
01071   CbcBranchDefaultDecision ();
01072 
01073   // Copy constructor 
01074   CbcBranchDefaultDecision ( const CbcBranchDefaultDecision &);
01075 
01076   virtual ~CbcBranchDefaultDecision();
01077 
01079   virtual CbcBranchDecision * clone() const;
01080 
01082   virtual void initialize(CbcModel * model);
01083 
01103   virtual int betterBranch(CbcBranchingObject * thisOne,
01104                             CbcBranchingObject * bestSoFar,
01105                             double changeUp, int numInfUp,
01106                             double changeDn, int numInfDn);
01108   virtual void setBestCriterion(double value);
01109   virtual double getBestCriterion() const;
01110 
01117   virtual int
01118   bestBranch (CbcBranchingObject ** objects, int numberObjects, int numberUnsatisfied,
01119               double * changeUp, int * numberInfeasibilitiesUp,
01120               double * changeDown, int * numberInfeasibilitiesDown,
01121               double objectiveValue) ;
01122 private:
01123   
01125   CbcBranchDefaultDecision & operator=(const CbcBranchDefaultDecision& rhs);
01126 
01128 
01130   double bestCriterion_;
01131 
01133   double bestChangeUp_;
01134 
01136   int bestNumberUp_;
01137 
01139   double bestChangeDown_;
01140 
01142   CbcBranchingObject * bestObject_;
01143 
01145   int bestNumberDown_;
01146 
01147 };
01148 
01160 class CbcFollowOn : public CbcObject {
01161 
01162 public:
01163 
01164   // Default Constructor 
01165   CbcFollowOn ();
01166 
01169   CbcFollowOn (CbcModel * model);
01170   
01171   // Copy constructor 
01172   CbcFollowOn ( const CbcFollowOn &);
01173    
01175   virtual CbcObject * clone() const;
01176 
01177   // Assignment operator 
01178   CbcFollowOn & operator=( const CbcFollowOn& rhs);
01179 
01180   // Destructor 
01181   ~CbcFollowOn ();
01182   
01184   virtual double infeasibility(const OsiBranchingInformation * info,
01185                                int &preferredWay) const;
01186 
01187   using CbcObject::feasibleRegion ;
01189   virtual void feasibleRegion();
01190 
01192   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
01194   virtual int gutsOfFollowOn(int & otherRow, int & preferredWay) const;
01195 
01196 protected:
01199   CoinPackedMatrix matrix_;
01201   CoinPackedMatrix matrixByRow_; 
01203   int * rhs_;
01204 };
01208 class CbcFixingBranchingObject : public CbcBranchingObject {
01209 
01210 public:
01211 
01212   // Default Constructor 
01213   CbcFixingBranchingObject ();
01214 
01215   // Useful constructor
01216   CbcFixingBranchingObject (CbcModel * model, 
01217                             int way,
01218                             int numberOnDownSide, const int * down,
01219                             int numberOnUpSide, const int * up);
01220   
01221   // Copy constructor 
01222   CbcFixingBranchingObject ( const CbcFixingBranchingObject &);
01223    
01224   // Assignment operator 
01225   CbcFixingBranchingObject & operator=( const CbcFixingBranchingObject& rhs);
01226 
01228   virtual CbcBranchingObject * clone() const;
01229 
01230   // Destructor 
01231   virtual ~CbcFixingBranchingObject ();
01232   
01233   using CbcBranchingObject::branch ;
01235   virtual double branch();
01236 
01237 #if 0
01238   // No need to override. Default works fine.
01242   virtual void previousBranch();
01243 #endif
01244 
01245   using CbcBranchingObject::print ;
01248   virtual void print();
01249 
01251   virtual int type() const { return 106; }
01252 
01260   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
01261 
01270   virtual CbcRangeCompare compareBranchingObject
01271   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
01272 
01273 private:
01276   int numberDown_;
01278   int numberUp_;
01280   int * downList_;
01282   int * upList_;
01283 };
01294 class CbcFixVariable : public CbcConsequence {
01295 
01296 public:
01297 
01298   // Default Constructor 
01299   CbcFixVariable ();
01300 
01301   // One useful Constructor 
01302   CbcFixVariable (int numberStates,const int * states, const int * numberNewLower, const int ** newLowerValue,
01303                   const int ** lowerColumn,
01304                   const int * numberNewUpper, const int ** newUpperValue,
01305                   const int ** upperColumn);
01306 
01307   // Copy constructor 
01308   CbcFixVariable ( const CbcFixVariable & rhs);
01309    
01310   // Assignment operator 
01311   CbcFixVariable & operator=( const CbcFixVariable & rhs);
01312 
01314   virtual CbcConsequence * clone() const;
01315 
01317   virtual ~CbcFixVariable ();
01318 
01321   virtual void applyToSolver(OsiSolverInterface * solver, int state) const;
01322   
01323 protected:
01325   int numberStates_;
01327   int * states_;
01329   int * startLower_;
01331   int * startUpper_;
01333   double * newBound_;
01335   int * variable_;
01336 };
01343 class CbcDummyBranchingObject : public CbcBranchingObject {
01344 
01345 public:
01346 
01348   CbcDummyBranchingObject (CbcModel * model=NULL);
01349 
01351   CbcDummyBranchingObject ( const CbcDummyBranchingObject &);
01352    
01354   CbcDummyBranchingObject & operator= (const CbcDummyBranchingObject& rhs);
01355 
01357   virtual CbcBranchingObject * clone() const;
01358 
01360   virtual ~CbcDummyBranchingObject ();
01361   
01362   using CbcBranchingObject::branch ;
01365   virtual double branch();
01366 
01367 #if 0
01368   // No need to override. Default works fine.
01372   virtual void previousBranch();
01373 #endif
01374 
01375   using CbcBranchingObject::print ;
01378   virtual void print();
01379 
01381   virtual int type() const { return 107; }
01382 
01390   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
01391 
01400   virtual CbcRangeCompare compareBranchingObject
01401   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
01402 
01403 };
01404 
01410 class CbcGeneral : public CbcObject {
01411 
01412 public:
01413 
01414   // Default Constructor 
01415   CbcGeneral ();
01416 
01420   CbcGeneral (CbcModel * model);
01421   
01422   // Copy constructor 
01423   CbcGeneral ( const CbcGeneral &);
01424    
01426   virtual CbcObject * clone() const=0;
01427 
01428   // Assignment operator 
01429   CbcGeneral & operator=( const CbcGeneral& rhs);
01430 
01431   // Destructor 
01432   ~CbcGeneral ();
01433   
01435   virtual double infeasibility(const OsiBranchingInformation * info,
01436                                int &preferredWay) const;
01437 
01438   using CbcObject::feasibleRegion ;
01440   virtual void feasibleRegion()=0;
01441 
01443   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
01444 
01446   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns)=0;
01447 
01448 protected:
01450 };
01451 #ifdef COIN_HAS_CLP
01452 
01456 #include "ClpSimplex.hpp"
01457 #include "ClpNode.hpp"
01458 
01459 class CbcGeneralDepth : public CbcGeneral {
01460 
01461 public:
01462 
01463   // Default Constructor 
01464   CbcGeneralDepth ();
01465 
01472   CbcGeneralDepth (CbcModel * model, int maximumDepth);
01473   
01474   // Copy constructor 
01475   CbcGeneralDepth ( const CbcGeneralDepth &);
01476    
01478   virtual CbcObject * clone() const;
01479 
01480   // Assignment operator 
01481   CbcGeneralDepth & operator=( const CbcGeneralDepth& rhs);
01482 
01483   // Destructor 
01484   ~CbcGeneralDepth ();
01485   
01487   virtual double infeasibility(const OsiBranchingInformation * info,
01488                                int &preferredWay) const;
01489 
01490   using CbcObject::feasibleRegion ;
01492   virtual void feasibleRegion();
01493 
01495   virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver,const OsiBranchingInformation * info, int way) ;
01497   inline int maximumNodes() const
01498   { return maximumNodes_;}
01500   inline int maximumDepth() const
01501   {return maximumDepth_;}
01503   inline void setMaximumDepth(int value)
01504   {maximumDepth_ = value;}
01506   inline int whichSolution() const
01507   {return whichSolution_;}
01509   inline ClpNode * nodeInfo(int which)
01510   { return nodeInfo_->nodeInfo_[which];}
01511 
01513   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
01514 
01515 protected:
01518   int maximumDepth_;
01520   int maximumNodes_;
01522   mutable int whichSolution_;
01524   mutable int numberNodes_;
01526   mutable ClpNodeStuff * nodeInfo_;
01527 };
01528 
01532 class CoinWarmStartDiff;
01533 class CbcSubProblem {
01534 
01535 public:
01536 
01538   CbcSubProblem ();
01539 
01541   CbcSubProblem (const OsiSolverInterface * solver,
01542                  const double * lowerBefore,
01543                  const double * upperBefore,
01544                  const unsigned char * status,
01545                  int depth);
01546 
01548   CbcSubProblem ( const CbcSubProblem &);
01549    
01551   CbcSubProblem & operator= (const CbcSubProblem& rhs);
01552 
01554   virtual ~CbcSubProblem ();
01555 
01557   void apply(OsiSolverInterface * model, int what=3) const;
01558 
01559 public:
01561   double objectiveValue_;
01563   double sumInfeasibilities_;
01566   int * variables_;
01568   double * newBounds_;
01570   mutable CoinWarmStartBasis * status_;
01572   int depth_;
01574   int numberChangedBounds_;
01576   int numberInfeasibilities_;
01577 };
01578 
01582 class CbcNode;
01583 class CbcGeneralBranchingObject : public CbcBranchingObject {
01584 
01585 public:
01586 
01587   // Default Constructor 
01588   CbcGeneralBranchingObject ();
01589 
01590   // Useful constructor
01591   CbcGeneralBranchingObject (CbcModel * model);
01592   
01593   // Copy constructor 
01594   CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
01595    
01596   // Assignment operator 
01597   CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
01598 
01600   virtual CbcBranchingObject * clone() const;
01601 
01602   // Destructor 
01603   virtual ~CbcGeneralBranchingObject ();
01604   
01605   using CbcBranchingObject::branch ;
01607   virtual double branch();
01610   virtual void checkIsCutoff(double cutoff);
01611 
01612   using CbcBranchingObject::print ;
01615   virtual void print();
01617   void state(double & objectiveValue,double & sumInfeasibilities,
01618              int & numberUnsatisfied,int which) const;
01620   inline void setNode(CbcNode * node)
01621   { node_ = node;}
01623   virtual int type() const { return 108; }
01624 
01632   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
01633 
01642   virtual CbcRangeCompare compareBranchingObject
01643   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
01645   inline int numberSubProblems() const
01646   { return numberSubProblems_;}
01648   inline int decrementNumberLeft()
01649   { numberSubLeft_--; return numberSubLeft_;}
01651   inline int whichNode() const
01652   { return whichNode_;}
01654   inline void setWhichNode(int value)
01655   { whichNode_ = value;}
01656   // Sub problem
01657   const CbcSubProblem * subProblem(int which) const
01658   { return subProblems_+which;}
01659 
01660 public:
01662   // Sub problems
01663   CbcSubProblem * subProblems_;
01665   CbcNode * node_;
01667   int numberSubProblems_;
01669   int numberSubLeft_;
01671   int whichNode_;
01673   int numberRows_;
01674 };
01675 
01679 class CbcOneGeneralBranchingObject : public CbcBranchingObject {
01680 
01681 public:
01682 
01683   // Default Constructor 
01684   CbcOneGeneralBranchingObject ();
01685 
01686   // Useful constructor
01687   CbcOneGeneralBranchingObject (CbcModel * model,
01688                                  CbcGeneralBranchingObject * object,
01689                                  int whichOne);
01690   
01691   // Copy constructor 
01692   CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
01693    
01694   // Assignment operator 
01695   CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
01696 
01698   virtual CbcBranchingObject * clone() const;
01699 
01700   // Destructor 
01701   virtual ~CbcOneGeneralBranchingObject ();
01702   
01703   using CbcBranchingObject::branch ;
01705   virtual double branch();
01708   virtual void checkIsCutoff(double cutoff);
01709 
01710   using CbcBranchingObject::print ;
01713   virtual void print();
01715   virtual int type() const { return 110; }
01716 
01724   virtual int compareOriginalObject(const CbcBranchingObject* brObj) const;
01725 
01734   virtual CbcRangeCompare compareBranchingObject
01735   (const CbcBranchingObject* brObj, const bool replaceIfOverlap = false);
01736 
01737 public:
01740   CbcGeneralBranchingObject * object_;
01742   int whichOne_;
01743 };
01744 #endif
01745 #endif

Generated on Tue Jan 19 03:02:15 2010 by  doxygen 1.4.7