00001
00002
00003
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
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
00029 CbcClique ( const CbcClique &);
00030
00032 virtual CbcObject * clone() const;
00033
00034
00035 CbcClique & operator=( const CbcClique& rhs);
00036
00037
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
00106 CbcSOS ();
00107
00112 CbcSOS (CbcModel * model, int numberMembers,
00113 const int * which, const double * weights, int identifier,
00114 int type=1);
00115
00116
00117 CbcSOS ( const CbcSOS &);
00118
00120 virtual CbcObject * clone() const;
00121
00122
00123 CbcSOS & operator=( const CbcSOS& rhs);
00124
00125
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
00236 CbcSimpleInteger ();
00237
00238
00239 CbcSimpleInteger (CbcModel * model, int iColumn, double breakEven=0.5);
00240
00241
00242 CbcSimpleInteger (CbcModel * model, const OsiSimpleInteger * object);
00243
00244
00245 CbcSimpleInteger ( const CbcSimpleInteger &);
00246
00248 virtual CbcObject * clone() const;
00249
00250
00251 CbcSimpleInteger & operator=( const CbcSimpleInteger& rhs);
00252
00253
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
00352 CbcNWay ();
00353
00356 CbcNWay (CbcModel * model, int numberMembers,
00357 const int * which, int identifier);
00358
00359
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
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
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
00541 double * newBounds_;
00543 int numberExtraChangedBounds_;
00544 #endif
00545 };
00546
00547
00549
00550
00551 class CbcSimpleIntegerPseudoCost : public CbcSimpleInteger {
00552
00553 public:
00554
00555
00556 CbcSimpleIntegerPseudoCost ();
00557
00558
00559 CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn, double breakEven=0.5);
00560
00561
00562 CbcSimpleIntegerPseudoCost (CbcModel * model, int iColumn,
00563 double downPseudoCost, double upPseudoCost);
00564
00565 CbcSimpleIntegerPseudoCost (CbcModel * model, int dummy,int iColumn,
00566 double downPseudoCost, double upPseudoCost);
00567
00568
00569 CbcSimpleIntegerPseudoCost ( const CbcSimpleIntegerPseudoCost &);
00570
00572 virtual CbcObject * clone() const;
00573
00574
00575 CbcSimpleIntegerPseudoCost & operator=( const CbcSimpleIntegerPseudoCost& rhs);
00576
00577
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
00738 CbcCliqueBranchingObject ();
00739
00740
00741 CbcCliqueBranchingObject (CbcModel * model, const CbcClique * clique,
00742 int way,
00743 int numberOnDownSide, const int * down,
00744 int numberOnUpSide, const int * up);
00745
00746
00747 CbcCliqueBranchingObject ( const CbcCliqueBranchingObject &);
00748
00749
00750 CbcCliqueBranchingObject & operator=( const CbcCliqueBranchingObject& rhs);
00751
00753 virtual CbcBranchingObject * clone() const;
00754
00755
00756 virtual ~CbcCliqueBranchingObject ();
00757
00758 using CbcBranchingObject::branch ;
00760 virtual double branch();
00761
00762 #if 0
00763
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
00817 CbcLongCliqueBranchingObject ();
00818
00819
00820 CbcLongCliqueBranchingObject (CbcModel * model, const CbcClique * clique,
00821 int way,
00822 int numberOnDownSide, const int * down,
00823 int numberOnUpSide, const int * up);
00824
00825
00826 CbcLongCliqueBranchingObject ( const CbcLongCliqueBranchingObject &);
00827
00828
00829 CbcLongCliqueBranchingObject & operator=( const CbcLongCliqueBranchingObject& rhs);
00830
00832 virtual CbcBranchingObject * clone() const;
00833
00834
00835 virtual ~CbcLongCliqueBranchingObject ();
00836
00837 using CbcBranchingObject::branch ;
00839 virtual double branch();
00840
00841 #if 0
00842
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
00896 CbcSOSBranchingObject ();
00897
00898
00899 CbcSOSBranchingObject (CbcModel * model, const CbcSOS * clique,
00900 int way,
00901 double separator);
00902
00903
00904 CbcSOSBranchingObject ( const CbcSOSBranchingObject &);
00905
00906
00907 CbcSOSBranchingObject & operator=( const CbcSOSBranchingObject& rhs);
00908
00910 virtual CbcBranchingObject * clone() const;
00911
00912
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
00985 CbcNWayBranchingObject ();
00986
00991 CbcNWayBranchingObject (CbcModel * model, const CbcNWay * nway,
00992 int numberBranches, const int * order);
00993
00994
00995 CbcNWayBranchingObject ( const CbcNWayBranchingObject &);
00996
00997
00998 CbcNWayBranchingObject & operator=( const CbcNWayBranchingObject& rhs);
00999
01001 virtual CbcBranchingObject * clone() const;
01002
01003
01004 virtual ~CbcNWayBranchingObject ();
01005
01006 using CbcBranchingObject::branch ;
01008 virtual double branch();
01009
01010 #if 0
01011
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
01071 CbcBranchDefaultDecision ();
01072
01073
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
01165 CbcFollowOn ();
01166
01169 CbcFollowOn (CbcModel * model);
01170
01171
01172 CbcFollowOn ( const CbcFollowOn &);
01173
01175 virtual CbcObject * clone() const;
01176
01177
01178 CbcFollowOn & operator=( const CbcFollowOn& rhs);
01179
01180
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
01213 CbcFixingBranchingObject ();
01214
01215
01216 CbcFixingBranchingObject (CbcModel * model,
01217 int way,
01218 int numberOnDownSide, const int * down,
01219 int numberOnUpSide, const int * up);
01220
01221
01222 CbcFixingBranchingObject ( const CbcFixingBranchingObject &);
01223
01224
01225 CbcFixingBranchingObject & operator=( const CbcFixingBranchingObject& rhs);
01226
01228 virtual CbcBranchingObject * clone() const;
01229
01230
01231 virtual ~CbcFixingBranchingObject ();
01232
01233 using CbcBranchingObject::branch ;
01235 virtual double branch();
01236
01237 #if 0
01238
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
01299 CbcFixVariable ();
01300
01301
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
01308 CbcFixVariable ( const CbcFixVariable & rhs);
01309
01310
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
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
01415 CbcGeneral ();
01416
01420 CbcGeneral (CbcModel * model);
01421
01422
01423 CbcGeneral ( const CbcGeneral &);
01424
01426 virtual CbcObject * clone() const=0;
01427
01428
01429 CbcGeneral & operator=( const CbcGeneral& rhs);
01430
01431
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
01464 CbcGeneralDepth ();
01465
01472 CbcGeneralDepth (CbcModel * model, int maximumDepth);
01473
01474
01475 CbcGeneralDepth ( const CbcGeneralDepth &);
01476
01478 virtual CbcObject * clone() const;
01479
01480
01481 CbcGeneralDepth & operator=( const CbcGeneralDepth& rhs);
01482
01483
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
01588 CbcGeneralBranchingObject ();
01589
01590
01591 CbcGeneralBranchingObject (CbcModel * model);
01592
01593
01594 CbcGeneralBranchingObject ( const CbcGeneralBranchingObject &);
01595
01596
01597 CbcGeneralBranchingObject & operator=( const CbcGeneralBranchingObject& rhs);
01598
01600 virtual CbcBranchingObject * clone() const;
01601
01602
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
01657 const CbcSubProblem * subProblem(int which) const
01658 { return subProblems_+which;}
01659
01660 public:
01662
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
01684 CbcOneGeneralBranchingObject ();
01685
01686
01687 CbcOneGeneralBranchingObject (CbcModel * model,
01688 CbcGeneralBranchingObject * object,
01689 int whichOne);
01690
01691
01692 CbcOneGeneralBranchingObject ( const CbcOneGeneralBranchingObject &);
01693
01694
01695 CbcOneGeneralBranchingObject & operator=( const CbcOneGeneralBranchingObject& rhs);
01696
01698 virtual CbcBranchingObject * clone() const;
01699
01700
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