/home/coin/SVN-release/Cbc-1.1.1/Cbc/src/CbcStrategy.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2005, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
00003 #ifndef CbcStrategy_H
00004 #define CbcStrategy_H
00005 
00006 #include "CbcModel.hpp"
00007 class CglPreProcess;
00008 class CbcNodeInfo;
00009 class CbcNode;
00010 class CoinWarmStartDiff;
00011 
00012 //#############################################################################
00015 class CbcStrategy {
00016 public:
00017   // Default Constructor 
00018   CbcStrategy ();
00019 
00020   virtual ~CbcStrategy();
00021 
00023   virtual CbcStrategy * clone() const=0;
00024 
00026   virtual void setupCutGenerators(CbcModel & model)=0;
00028   virtual void setupHeuristics(CbcModel & model)=0;
00030   virtual void setupPrinting(CbcModel & model,int modelLogLevel)=0;
00032   virtual void setupOther(CbcModel & model)=0;
00034   inline void setNested(int depth)
00035   { depth_=depth;};
00037   inline int getNested() const
00038   { return depth_;};
00040   inline void setPreProcessState(int state)
00041   { preProcessState_=state;};
00043   inline int preProcessState() const
00044   { return preProcessState_;};
00046   inline CglPreProcess * process() const
00047   { return process_;};
00049   void deletePreProcess();
00051   virtual CbcNodeInfo * fullNodeInfo(CbcModel * model,int numberRowsAtContinuous) const;
00053   virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
00054                                         int numberChangedBounds,const int * variables,
00055                                         const double * boundChanges,
00056                                         const CoinWarmStartDiff *basisDiff) const;
00058   virtual void generateCpp( FILE * fp) {};
00065   virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
00066 private:
00067   
00069   CbcStrategy & operator=(const CbcStrategy& rhs);
00070 protected:
00071   // Data
00073   int depth_;
00079   int preProcessState_;
00081   CglPreProcess * process_;
00082 };
00083 
00087 class CbcStrategyNull : public CbcStrategy {
00088 public:
00089 
00090   // Default Constructor 
00091   CbcStrategyNull () {}
00092 
00093   // Copy constructor 
00094   CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {};
00095    
00096   // Destructor 
00097   ~CbcStrategyNull () {};
00098   
00100   virtual CbcStrategy * clone() const { return new CbcStrategyNull(*this);};
00101 
00103   virtual void setupCutGenerators(CbcModel & model) {};
00105   virtual void setupHeuristics(CbcModel & model) {};
00107   virtual void setupPrinting(CbcModel & model,int modelLogLevel) {};
00109   virtual void setupOther(CbcModel & model) {};
00110 
00111 protected:
00112   // Data
00113 private:
00115   CbcStrategyNull & operator=(const CbcStrategyNull& rhs);
00116 };
00117 
00121 class CbcStrategyDefault : public CbcStrategy {
00122 public:
00123 
00124   // Default Constructor 
00125   CbcStrategyDefault (bool cutsOnlyAtRoot=true,
00126                       int numberStrong=5,
00127                       int numberBeforeTrust=0,
00128                       int printLevel=0);
00129 
00130   // Copy constructor 
00131   CbcStrategyDefault ( const CbcStrategyDefault &);
00132    
00133   // Destructor 
00134   ~CbcStrategyDefault ();
00135   
00137   virtual CbcStrategy * clone() const;
00138 
00140   virtual void setupCutGenerators(CbcModel & model);
00142   virtual void setupHeuristics(CbcModel & model);
00144   virtual void setupPrinting(CbcModel & model,int modelLogLevel) ;
00146   virtual void setupOther(CbcModel & model);
00148   inline void setupPreProcessing(int desired=1, int passes=10)
00149   { desiredPreProcess_=desired;preProcessPasses_=passes;};
00151   inline int desiredPreProcess() const
00152   { return desiredPreProcess_;};
00154   inline int preProcessPasses() const
00155   { return preProcessPasses_;};
00157   virtual void generateCpp( FILE * fp) ;
00158 
00159 protected:
00160   // Data
00161 
00162   // Whether to do cuts only at root
00163   bool cutsOnlyAtRoot_;
00164 
00165   // How much strong branching to do 
00166   int numberStrong_;
00167 
00168   // Number branches needed to trust with dynamic pseudo costs
00169   int numberBeforeTrust_;
00170 
00171   // Print level 0 little, 1 medium
00172   int printLevel_;
00173 
00179   int desiredPreProcess_;
00181   int preProcessPasses_;
00182 
00183 private:
00185   CbcStrategyDefault & operator=(const CbcStrategyDefault& rhs);
00186 };
00187 
00188 
00192 class CbcStrategyDefaultSubTree : public CbcStrategy {
00193 public:
00194 
00195   // Default Constructor 
00196   CbcStrategyDefaultSubTree (CbcModel * parent=NULL,bool cutsOnlyAtRoot=true,
00197                       int numberStrong=5,
00198                       int numberBeforeTrust=0,
00199                       int printLevel=0);
00200 
00201   // Copy constructor 
00202   CbcStrategyDefaultSubTree ( const CbcStrategyDefaultSubTree &);
00203    
00204   // Destructor 
00205   ~CbcStrategyDefaultSubTree ();
00206   
00208   virtual CbcStrategy * clone() const;
00209 
00211   virtual void setupCutGenerators(CbcModel & model);
00213   virtual void setupHeuristics(CbcModel & model);
00215   virtual void setupPrinting(CbcModel & model,int modelLogLevel) ;
00217   virtual void setupOther(CbcModel & model);
00218 protected:
00219   // Data
00220   // Parent model
00221   CbcModel * parentModel_;
00222   // Whether to do cuts only at root
00223   bool cutsOnlyAtRoot_;
00224 
00225   // How much strong branching to do 
00226   int numberStrong_;
00227 
00228   // Number branches needed to trust with dynamic pseudo costs
00229   int numberBeforeTrust_;
00230 
00231   // Print level 0 little, 1 medium
00232   int printLevel_;
00233 
00234 private:
00236   CbcStrategyDefaultSubTree & operator=(const CbcStrategyDefaultSubTree& rhs);
00237 };
00238 
00239 
00240 #endif

Generated on Thu May 15 21:59:04 2008 by  doxygen 1.4.7