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

Go to the documentation of this file.

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

#include "CbcModel.hpp"
class CglPreProcess;
class CbcNodeInfo;
class CbcNode;
class CoinWarmStartDiff;

//#############################################################################
class CbcStrategy {
public:
  // Default Constructor 
  CbcStrategy ();

  virtual ~CbcStrategy();

  virtual CbcStrategy * clone() const=0;

  virtual void setupCutGenerators(CbcModel & model)=0;
  virtual void setupHeuristics(CbcModel & model)=0;
  virtual void setupPrinting(CbcModel & model,int modelLogLevel)=0;
  virtual void setupOther(CbcModel & model)=0;
  inline void setNested(int depth)
  { depth_=depth;}
  inline int getNested() const
  { return depth_;}
  inline void setPreProcessState(int state)
  { preProcessState_=state;}
  inline int preProcessState() const
  { return preProcessState_;}
  inline CglPreProcess * process() const
  { return process_;}
  void deletePreProcess();
  virtual CbcNodeInfo * fullNodeInfo(CbcModel * model,int numberRowsAtContinuous) const;
  virtual CbcNodeInfo * partialNodeInfo(CbcModel * model, CbcNodeInfo * parent, CbcNode * owner,
                                        int numberChangedBounds,const int * variables,
                                        const double * boundChanges,
                                        const CoinWarmStartDiff *basisDiff) const;
  virtual void generateCpp( FILE * fp) {}
  virtual int status(CbcModel * model, CbcNodeInfo * parent, int whereFrom);
private:
  
  CbcStrategy & operator=(const CbcStrategy& rhs);
protected:
  // Data
  int depth_;
  int preProcessState_;
  CglPreProcess * process_;
};

class CbcStrategyNull : public CbcStrategy {
public:

  // Default Constructor 
  CbcStrategyNull () {}

  // Copy constructor 
  CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {}
   
  // Destructor 
  ~CbcStrategyNull () {}
  
  virtual CbcStrategy * clone() const { return new CbcStrategyNull(*this);}

  virtual void setupCutGenerators(CbcModel & model) {}
  virtual void setupHeuristics(CbcModel & model) {}
  virtual void setupPrinting(CbcModel & model,int modelLogLevel) {}
  virtual void setupOther(CbcModel & model) {}

protected:
  // Data
private:
  CbcStrategyNull & operator=(const CbcStrategyNull& rhs);
};

class CbcStrategyDefault : public CbcStrategy {
public:

  // Default Constructor 
  CbcStrategyDefault (bool cutsOnlyAtRoot=true,
                      int numberStrong=5,
                      int numberBeforeTrust=0,
                      int printLevel=0);

  // Copy constructor 
  CbcStrategyDefault ( const CbcStrategyDefault &);
   
  // Destructor 
  ~CbcStrategyDefault ();
  
  virtual CbcStrategy * clone() const;

  virtual void setupCutGenerators(CbcModel & model);
  virtual void setupHeuristics(CbcModel & model);
  virtual void setupPrinting(CbcModel & model,int modelLogLevel) ;
  virtual void setupOther(CbcModel & model);
  inline void setupPreProcessing(int desired=1, int passes=10)
  { desiredPreProcess_=desired;preProcessPasses_=passes;}
  inline int desiredPreProcess() const
  { return desiredPreProcess_;}
  inline int preProcessPasses() const
  { return preProcessPasses_;}
  virtual void generateCpp( FILE * fp) ;

protected:
  // Data

  // Whether to do cuts only at root
  bool cutsOnlyAtRoot_;

  // How much strong branching to do 
  int numberStrong_;

  // Number branches needed to trust with dynamic pseudo costs
  int numberBeforeTrust_;

  // Print level 0 little, 1 medium
  int printLevel_;

  int desiredPreProcess_;
  int preProcessPasses_;

private:
  CbcStrategyDefault & operator=(const CbcStrategyDefault& rhs);
};


class CbcStrategyDefaultSubTree : public CbcStrategy {
public:

  // Default Constructor 
  CbcStrategyDefaultSubTree (CbcModel * parent=NULL,bool cutsOnlyAtRoot=true,
                      int numberStrong=5,
                      int numberBeforeTrust=0,
                      int printLevel=0);

  // Copy constructor 
  CbcStrategyDefaultSubTree ( const CbcStrategyDefaultSubTree &);
   
  // Destructor 
  ~CbcStrategyDefaultSubTree ();
  
  virtual CbcStrategy * clone() const;

  virtual void setupCutGenerators(CbcModel & model);
  virtual void setupHeuristics(CbcModel & model);
  virtual void setupPrinting(CbcModel & model,int modelLogLevel) ;
  virtual void setupOther(CbcModel & model);
protected:
  // Data
  // Parent model
  CbcModel * parentModel_;
  // Whether to do cuts only at root
  bool cutsOnlyAtRoot_;

  // How much strong branching to do 
  int numberStrong_;

  // Number branches needed to trust with dynamic pseudo costs
  int numberBeforeTrust_;

  // Print level 0 little, 1 medium
  int printLevel_;

private:
  CbcStrategyDefaultSubTree & operator=(const CbcStrategyDefaultSubTree& rhs);
};


#endif

---