CbcStrategy.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2005, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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 *) {}
  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 &) {}
  virtual void setupHeuristics(CbcModel &) {}
  virtual void setupPrinting(CbcModel &, int) {}
  virtual void setupOther(CbcModel &) {}
 
protected:
  // Data
private:
  CbcStrategyNull &operator=(const CbcStrategyNull &rhs);
};
 
class CbcStrategyDefault : public CbcStrategy {
public:
  // Default Constructor
  CbcStrategyDefault(int cutsOnlyAtRoot = 1,
    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 (-1 -> switch off totally)
  int 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, int cutsOnlyAtRoot = 1,
    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 (-1 -> switch off totally)
  int 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/