CbcCutGenerator.hpp

Go to the documentation of this file.

/* $Id: CbcCutGenerator.hpp 2465 2019-01-03 19:26:52Z unxusr $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef CbcCutGenerator_H
#define CbcCutGenerator_H

#include "OsiSolverInterface.hpp"
#include "OsiCuts.hpp"
#include "CglCutGenerator.hpp"
#include "CbcCutModifier.hpp"

class CbcModel;
class OsiRowCut;
class OsiRowCutDebugger;

//#############################################################################

class CbcCutGenerator {

public:
  bool generateCuts(OsiCuts &cs, int fullScan, OsiSolverInterface *solver,
    CbcNode *node);

  CbcCutGenerator();

  CbcCutGenerator(CbcModel *model, CglCutGenerator *generator,
    int howOften = 1, const char *name = NULL,
    bool normal = true, bool atSolution = false,
    bool infeasible = false, int howOftenInsub = -100,
    int whatDepth = -1, int whatDepthInSub = -1, int switchOffIfLessThan = 0);

  CbcCutGenerator(const CbcCutGenerator &);

  CbcCutGenerator &operator=(const CbcCutGenerator &rhs);

  ~CbcCutGenerator();

  void refreshModel(CbcModel *model);

  inline const char *cutGeneratorName() const
  {
    return generatorName_;
  }

  void generateTuning(FILE *fp);
  void setHowOften(int value);

  inline int howOften() const
  {
    return whenCutGenerator_;
  }
  inline int howOftenInSub() const
  {
    return whenCutGeneratorInSub_;
  }
  inline int inaccuracy() const
  {
    return inaccuracy_;
  }
  inline void setInaccuracy(int level)
  {
    inaccuracy_ = level;
  }

  void setWhatDepth(int value);
  void setWhatDepthInSub(int value);
  inline int whatDepth() const
  {
    return depthCutGenerator_;
  }
  inline int whatDepthInSub() const
  {
    return depthCutGeneratorInSub_;
  }
  inline void setMaximumTries(int value)
  {
    maximumTries_ = value;
  }
  inline int maximumTries() const
  {
    return maximumTries_;
  }

  inline int switches() const
  {
    return switches_;
  }
  inline void setSwitches(int value)
  {
    switches_ = value;
  }
  inline bool normal() const
  {
    return (switches_ & 1) != 0;
  }
  inline void setNormal(bool value)
  {
    switches_ &= ~1;
    switches_ |= value ? 1 : 0;
  }
  inline bool atSolution() const
  {
    return (switches_ & 2) != 0;
  }
  inline void setAtSolution(bool value)
  {
    switches_ &= ~2;
    switches_ |= value ? 2 : 0;
  }
  inline bool whenInfeasible() const
  {
    return (switches_ & 4) != 0;
  }
  inline void setWhenInfeasible(bool value)
  {
    switches_ &= ~4;
    switches_ |= value ? 4 : 0;
  }
  inline bool timing() const
  {
    return (switches_ & 64) != 0;
  }
  inline void setTiming(bool value)
  {
    switches_ &= ~64;
    switches_ |= value ? 64 : 0;
    timeInCutGenerator_ = 0.0;
  }
  inline double timeInCutGenerator() const
  {
    return timeInCutGenerator_;
  }
  inline void incrementTimeInCutGenerator(double value)
  {
    timeInCutGenerator_ += value;
  }
  inline CglCutGenerator *generator() const
  {
    return generator_;
  }
  inline int numberTimesEntered() const
  {
    return numberTimes_;
  }
  inline void setNumberTimesEntered(int value)
  {
    numberTimes_ = value;
  }
  inline void incrementNumberTimesEntered(int value = 1)
  {
    numberTimes_ += value;
  }
  inline int numberCutsInTotal() const
  {
    return numberCuts_;
  }
  inline void setNumberCutsInTotal(int value)
  {
    numberCuts_ = value;
  }
  inline void incrementNumberCutsInTotal(int value = 1)
  {
    numberCuts_ += value;
  }
  inline int numberElementsInTotal() const
  {
    return numberElements_;
  }
  inline void setNumberElementsInTotal(int value)
  {
    numberElements_ = value;
  }
  inline void incrementNumberElementsInTotal(int value = 1)
  {
    numberElements_ += value;
  }
  inline int numberColumnCuts() const
  {
    return numberColumnCuts_;
  }
  inline void setNumberColumnCuts(int value)
  {
    numberColumnCuts_ = value;
  }
  inline void incrementNumberColumnCuts(int value = 1)
  {
    numberColumnCuts_ += value;
  }
  inline int numberCutsActive() const
  {
    return numberCutsActive_;
  }
  inline void setNumberCutsActive(int value)
  {
    numberCutsActive_ = value;
  }
  inline void incrementNumberCutsActive(int value = 1)
  {
    numberCutsActive_ += value;
  }
  inline void setSwitchOffIfLessThan(int value)
  {
    switchOffIfLessThan_ = value;
  }
  inline int switchOffIfLessThan() const
  {
    return switchOffIfLessThan_;
  }
  inline bool needsOptimalBasis() const
  {
    return (switches_ & 128) != 0;
  }
  inline void setNeedsOptimalBasis(bool yesNo)
  {
    switches_ &= ~128;
    switches_ |= yesNo ? 128 : 0;
  }
  inline bool mustCallAgain() const
  {
    return (switches_ & 8) != 0;
  }
  inline void setMustCallAgain(bool yesNo)
  {
    switches_ &= ~8;
    switches_ |= yesNo ? 8 : 0;
  }
  inline bool switchedOff() const
  {
    return (switches_ & 16) != 0;
  }
  inline void setSwitchedOff(bool yesNo)
  {
    switches_ &= ~16;
    switches_ |= yesNo ? 16 : 0;
  }
  inline bool ineffectualCuts() const
  {
    return (switches_ & 512) != 0;
  }
  inline void setIneffectualCuts(bool yesNo)
  {
    switches_ &= ~512;
    switches_ |= yesNo ? 512 : 0;
  }
  inline bool whetherToUse() const
  {
    return (switches_ & 1024) != 0;
  }
  inline void setWhetherToUse(bool yesNo)
  {
    switches_ &= ~1024;
    switches_ |= yesNo ? 1024 : 0;
  }
  inline bool whetherInMustCallAgainMode() const
  {
    return (switches_ & 2048) != 0;
  }
  inline void setWhetherInMustCallAgainMode(bool yesNo)
  {
    switches_ &= ~2048;
    switches_ |= yesNo ? 2048 : 0;
  }
  inline bool whetherCallAtEnd() const
  {
    return (switches_ & 4096) != 0;
  }
  inline void setWhetherCallAtEnd(bool yesNo)
  {
    switches_ &= ~4096;
    switches_ |= yesNo ? 4096 : 0;
  }
  inline bool needsRefresh() const
  {
    return (switches_ & 8192) != 0;
  }
  inline void setNeedsRefresh(bool yesNo)
  {
    switches_ &= ~8192;
    switches_ |= yesNo ? 8192 : 0;
  }
  inline int numberCutsAtRoot() const
  {
    return numberCutsAtRoot_;
  }
  inline void setNumberCutsAtRoot(int value)
  {
    numberCutsAtRoot_ = value;
  }
  inline int numberActiveCutsAtRoot() const
  {
    return numberActiveCutsAtRoot_;
  }
  inline void setNumberActiveCutsAtRoot(int value)
  {
    numberActiveCutsAtRoot_ = value;
  }
  inline int numberShortCutsAtRoot() const
  {
    return numberShortCutsAtRoot_;
  }
  inline void setNumberShortCutsAtRoot(int value)
  {
    numberShortCutsAtRoot_ = value;
  }
  inline void setModel(CbcModel *model)
  {
    model_ = model;
  }
  inline bool globalCutsAtRoot() const
  {
    return (switches_ & 32) != 0;
  }
  inline void setGlobalCutsAtRoot(bool yesNo)
  {
    switches_ &= ~32;
    switches_ |= yesNo ? 32 : 0;
  }
  inline bool globalCuts() const
  {
    return (switches_ & 256) != 0;
  }
  inline void setGlobalCuts(bool yesNo)
  {
    switches_ &= ~256;
    switches_ |= yesNo ? 256 : 0;
  }
  void addStatistics(const CbcCutGenerator *other);
  void scaleBackStatistics(int factor);

private:

  OsiCuts savedCuts_;
  double timeInCutGenerator_;
  CbcModel *model_;

  // The CglCutGenerator object
  CglCutGenerator *generator_;

  char *generatorName_;

  int whenCutGenerator_;
  int whenCutGeneratorInSub_;
  int switchOffIfLessThan_;

  int depthCutGenerator_;

  int depthCutGeneratorInSub_;

  int inaccuracy_;
  int numberTimes_;
  int numberCuts_;
  int numberElements_;
  int numberColumnCuts_;
  int numberCutsActive_;
  int numberCutsAtRoot_;
  int numberActiveCutsAtRoot_;
  int numberShortCutsAtRoot_;
  int switches_;
  int maximumTries_;
};

// How often to do if mostly switched off (A)
#define SCANCUTS 1000
// How often to do if mostly switched off (probing B)
#define SCANCUTS_PROBING 1000

#endif

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/