# OsiChooseVariable.hpp

Go to the documentation of this file.

    00001 // Copyright (C) 2006, International Business Machines
    00002 // Corporation and others.  All Rights Reserved.
    00003 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00004
    00005 #ifndef OsiChooseVariable_H
    00006 #define OsiChooseVariable_H
    00007
    00008 #include <string>
    00009 #include <vector>
    00010
    00011 #include "CoinWarmStartBasis.hpp"
    00012 #include "OsiBranchingObject.hpp"
    00013
    00014 class OsiSolverInterface;
    00015 class OsiHotInfo;
    00016
    00033 class OsiChooseVariable  {
    00034
    00035 public:
    00036
    00038   OsiChooseVariable ();
    00039
    00041   OsiChooseVariable (const OsiSolverInterface * solver);
    00042
    00044   OsiChooseVariable (const OsiChooseVariable &);
    00045
    00047   OsiChooseVariable & operator= (const OsiChooseVariable& rhs);
    00048
    00050   virtual OsiChooseVariable * clone() const;
    00051
    00053   virtual ~OsiChooseVariable ();
    00054
    00059   virtual int setupList ( OsiBranchingInformation *info, bool initialize);
    00073   virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
    00075   virtual bool feasibleSolution(const OsiBranchingInformation * info,
    00076                         const double * solution,
    00077                         int numberObjects,
    00078                         const OsiObject ** objects);
    00080   void saveSolution(const OsiSolverInterface * solver);
    00082   void clearGoodSolution();
    00084   virtual void updateInformation( const OsiBranchingInformation *info,
    00085                                   int branch, OsiHotInfo * hotInfo);
    00086 #if 1
    00088   virtual void updateInformation( int whichObject, int branch,
    00089                                   double changeInObjective, double changeInValue,
    00090                                   int status);
    00091 #endif
    00093   inline double goodObjectiveValue() const
    00094   { return goodObjectiveValue_;}
    00096   inline double upChange() const
    00097   { return upChange_;}
    00099   inline double downChange() const
    00100   { return downChange_;}
    00102   inline const double * goodSolution() const
    00103   { return goodSolution_;}
    00105   inline int bestObjectIndex() const
    00106   { return bestObjectIndex_;}
    00108   inline void setBestObjectIndex(int value)
    00109   { bestObjectIndex_ = value;}
    00111   inline int bestWhichWay() const
    00112   { return bestWhichWay_;}
    00114   inline void setBestWhichWay(int value)
    00115   { bestWhichWay_ = value;}
    00117   inline int firstForcedObjectIndex() const
    00118   { return firstForcedObjectIndex_;}
    00120   inline void setFirstForcedObjectIndex(int value)
    00121   { firstForcedObjectIndex_ = value;}
    00123   inline int firstForcedWhichWay() const
    00124   { return firstForcedWhichWay_;}
    00126   inline void setFirstForcedWhichWay(int value)
    00127   { firstForcedWhichWay_ = value;}
    00129   inline int numberUnsatisfied() const
    00130   {return numberUnsatisfied_;}
    00132   inline int numberStrong() const
    00133   { return numberStrong_;}
    00135   inline void setNumberStrong(int value)
    00136   { numberStrong_ = value;}
    00138   inline int numberOnList() const
    00139   { return numberOnList_;}
    00141   inline int numberStrongDone() const
    00142   { return numberStrongDone_;}
    00144   inline int numberStrongIterations() const
    00145   { return numberStrongIterations_;}
    00147   inline int numberStrongFixed() const
    00148   { return numberStrongFixed_;}
    00150   inline const int * candidates() const
    00151   { return list_;}
    00153   inline bool trustStrongForBound() const
    00154   { return trustStrongForBound_;}
    00156   inline void setTrustStrongForBound(bool yesNo)
    00157   { trustStrongForBound_ = yesNo;}
    00159   inline bool trustStrongForSolution() const
    00160   { return trustStrongForSolution_;}
    00162   inline void setTrustStrongForSolution(bool yesNo)
    00163   { trustStrongForSolution_ = yesNo;}
    00165   void setSolver (const OsiSolverInterface * solver);
    00177   inline int status() const
    00178   { return status_;}
    00179   inline void setStatus(int value)
    00180   { status_ = value;}
    00181
    00182
    00183 protected:
    00184   // Data
    00186   double goodObjectiveValue_;
    00188   double upChange_;
    00190   double downChange_;
    00192   double * goodSolution_;
    00194   int * list_;
    00196   double * useful_;
    00198   const OsiSolverInterface * solver_;
    00199   /* Status -
    00200      -1 Node is infeasible
    00201      0  Normal termination - we have a candidate
    00202      1  All looks satisfied - no candidate
    00203      2  We can change the bound on a variable - but we also have a strong branching candidate
    00204      3  We can change the bound on a variable - but we have a non-strong branching candidate
    00205      4  We can change the bound on a variable - no other candidates
    00206   */
    00207   int status_;
    00209   int bestObjectIndex_;
    00211   int bestWhichWay_;
    00213   int firstForcedObjectIndex_;
    00215   int firstForcedWhichWay_;
    00217   int numberUnsatisfied_;
    00219   int numberStrong_;
    00221   int numberOnList_;
    00223   int numberStrongDone_;
    00225   int numberStrongIterations_;
    00227   int numberStrongFixed_;
    00230   bool trustStrongForBound_;
    00232   bool trustStrongForSolution_;
    00233 };
    00234
    00240 class OsiPseudoCosts {
    00241 protected:
    00242    // Data
    00244   double * upTotalChange_;
    00246   double * downTotalChange_;
    00248   int * upNumber_;
    00250   int * downNumber_;
    00252   int numberObjects_;
    00254   int numberBeforeTrusted_;
    00255
    00256 private:
    00257   void gutsOfDelete();
    00258   void gutsOfCopy(const OsiPseudoCosts& rhs);
    00259
    00260 public:
    00261   OsiPseudoCosts();
    00262   virtual ~OsiPseudoCosts();
    00263   OsiPseudoCosts(const OsiPseudoCosts& rhs);
    00264   OsiPseudoCosts& operator=(const OsiPseudoCosts& rhs);
    00265
    00267   inline int numberBeforeTrusted() const
    00268   { return numberBeforeTrusted_; }
    00270   inline void setNumberBeforeTrusted(int value)
    00271   { numberBeforeTrusted_ = value; }
    00273   void initialize(int n);
    00275   inline int numberObjects() const
    00276   { return numberObjects_; }
    00277
    00280   inline double* upTotalChange()               { return upTotalChange_; }
    00281   inline const double* upTotalChange() const   { return upTotalChange_; }
    00282
    00283   inline double* downTotalChange()             { return downTotalChange_; }
    00284   inline const double* downTotalChange() const { return downTotalChange_; }
    00285
    00286   inline int* upNumber()                       { return upNumber_; }
    00287   inline const int* upNumber() const           { return upNumber_; }
    00288
    00289   inline int* downNumber()                     { return downNumber_; }
    00290   inline const int* downNumber() const         { return downNumber_; }
    00292
    00294   virtual void updateInformation(const OsiBranchingInformation *info,
    00295                                   int branch, OsiHotInfo * hotInfo);
    00296 #if 1
    00298   virtual void updateInformation( int whichObject, int branch,
    00299                                   double changeInObjective, double changeInValue,
    00300                                   int status);
    00301 #endif
    00302 };
    00303
    00318 class OsiChooseStrong  : public OsiChooseVariable {
    00319
    00320 public:
    00321
    00323   OsiChooseStrong ();
    00324
    00326   OsiChooseStrong (const OsiSolverInterface * solver);
    00327
    00329   OsiChooseStrong (const OsiChooseStrong &);
    00330
    00332   OsiChooseStrong & operator= (const OsiChooseStrong& rhs);
    00333
    00335   virtual OsiChooseVariable * clone() const;
    00336
    00338   virtual ~OsiChooseStrong ();
    00339
    00344   virtual int setupList ( OsiBranchingInformation *info, bool initialize);
    00358   virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables);
    00359
    00366   inline int shadowPriceMode() const
    00367   { return shadowPriceMode_;}
    00369   inline void setShadowPriceMode(int value)
    00370   { shadowPriceMode_ = value;}
    00371
    00373   const OsiPseudoCosts& pseudoCosts() const
    00374   { return pseudoCosts_; }
    00375
    00377   OsiPseudoCosts& pseudoCosts()
    00378   { return pseudoCosts_; }
    00379
    00382   inline int numberBeforeTrusted() const {
    00383     return pseudoCosts_.numberBeforeTrusted(); }
    00384   inline void setNumberBeforeTrusted(int value) {
    00385     pseudoCosts_.setNumberBeforeTrusted(value); }
    00386   inline int numberObjects() const {
    00387     return pseudoCosts_.numberObjects(); }
    00388
    00389 protected:
    00390
    00403   int doStrongBranching( OsiSolverInterface * solver,
    00404                          OsiBranchingInformation *info,
    00405                          int numberToDo, int returnCriterion);
    00406
    00408   void resetResults(int num);
    00409
    00410 protected:
    00416   int shadowPriceMode_;
    00417
    00419   OsiPseudoCosts pseudoCosts_;
    00420
    00423   OsiHotInfo* results_;
    00425   int numResults_;
    00426 };
    00427
    00432 class OsiHotInfo  {
    00433
    00434 public:
    00435
    00437   OsiHotInfo ();
    00438
    00440   OsiHotInfo ( OsiSolverInterface * solver,
    00441                const OsiBranchingInformation *info,
    00442                const OsiObject * const * objects,
    00443                int whichObject);
    00444
    00446   OsiHotInfo (const OsiHotInfo &);
    00447
    00449   OsiHotInfo & operator= (const OsiHotInfo& rhs);
    00450
    00452   virtual OsiHotInfo * clone() const;
    00453
    00455   virtual ~OsiHotInfo ();
    00456
    00460   int updateInformation( const OsiSolverInterface * solver, const OsiBranchingInformation * info,
    00461                          OsiChooseVariable * choose);
    00463   inline double originalObjectiveValue() const
    00464   { return originalObjectiveValue_;}
    00466   inline double upChange() const
    00467   { assert (branchingObject_->numberBranches()==2); return changes_[1];}
    00469   inline double downChange() const
    00470   { assert (branchingObject_->numberBranches()==2); return changes_[0];}
    00472   inline void setUpChange(double value)
    00473   { assert (branchingObject_->numberBranches()==2); changes_[1] = value;}
    00475   inline void setDownChange(double value)
    00476   { assert (branchingObject_->numberBranches()==2); changes_[0] = value;}
    00478   inline double change(int k) const
    00479   { return changes_[k];}
    00480
    00482   inline int upIterationCount() const
    00483   { assert (branchingObject_->numberBranches()==2); return iterationCounts_[1];}
    00485   inline int downIterationCount() const
    00486   { assert (branchingObject_->numberBranches()==2); return iterationCounts_[0];}
    00488   inline int iterationCount(int k) const
    00489   { return iterationCounts_[k];}
    00490
    00492   inline int upStatus() const
    00493   { assert (branchingObject_->numberBranches()==2); return statuses_[1];}
    00495   inline int downStatus() const
    00496   { assert (branchingObject_->numberBranches()==2); return statuses_[0];}
    00498   inline void setUpStatus(int value)
    00499   { assert (branchingObject_->numberBranches()==2); statuses_[1] = value;}
    00501   inline void setDownStatus(int value)
    00502   { assert (branchingObject_->numberBranches()==2); statuses_[0] = value;}
    00504   inline int status(int k) const
    00505   { return statuses_[k];}
    00507   inline OsiBranchingObject * branchingObject() const
    00508   { return branchingObject_;}
    00509   inline int whichObject() const
    00510   { return whichObject_;}
    00511
    00512 protected:
    00513   // Data
    00515   double originalObjectiveValue_;
    00517   double * changes_;
    00519   int * iterationCounts_;
    00526   int * statuses_;
    00528   OsiBranchingObject * branchingObject_;
    00530   int whichObject_;
    00531 };
    00532
    00533
    00534 #endif

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines