CbcStrategy.hpp

Go to the documentation of this file.

/* $Id: CbcStrategy.hpp 2465 2019-01-03 19:26:52Z unxusr $ */
// 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
*/