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

Go to the documentation of this file.

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

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

class CbcModel;
class OsiRowCut;
class OsiRowCutDebugger;

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

class CbcCutGenerator  {
  
public:
    
  bool generateCuts( OsiCuts &cs, bool 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 setHowOften(int value) ;

  inline int howOften() const
  { return whenCutGenerator_;}
  inline int howOftenInSub() const
  { return whenCutGeneratorInSub_;}

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

  inline bool normal() const
  { return normal_;}
  inline void setNormal(bool value) 
  { normal_=value;}
  inline bool atSolution() const
  { return atSolution_;}
  inline void setAtSolution(bool value) 
  { atSolution_=value;}
  inline bool whenInfeasible() const
  { return whenInfeasible_;}
  inline void setWhenInfeasible(bool value) 
  { whenInfeasible_=value;}
  inline bool timing() const
  { return timing_;}
  inline void setTiming(bool value) 
  { timing_=value; 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 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 generator_->needsOptimalBasis();}
  inline bool mustCallAgain() const
  { return mustCallAgain_;}
  inline void setMustCallAgain(bool yesNo)
  { mustCallAgain_=yesNo;}
  inline bool switchedOff() const
  { return switchedOff_;}
  inline void setSwitchedOff(bool yesNo)
  { switchedOff_=yesNo;}
  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 void setModel(CbcModel * model)
  { model_ = model;}
  
private:
  CbcModel *model_;

  // The CglCutGenerator object
  CglCutGenerator * generator_;

  int whenCutGenerator_;
  int whenCutGeneratorInSub_;
  int switchOffIfLessThan_;

  int depthCutGenerator_;

  int depthCutGeneratorInSub_;

  char * generatorName_;

  bool normal_;

  bool atSolution_;

  bool whenInfeasible_;
  bool mustCallAgain_;
  bool switchedOff_;
  bool timing_;
  double timeInCutGenerator_;
  
  int numberTimes_;
  int numberCuts_;
  int numberColumnCuts_;
  int numberCutsActive_;
  int numberCutsAtRoot_;
  int numberActiveCutsAtRoot_;
};
class CbcCutModifier {
public:
  CbcCutModifier ();

  // Copy constructor 
  CbcCutModifier ( const CbcCutModifier &);
   
  virtual ~CbcCutModifier();

  CbcCutModifier & operator=(const CbcCutModifier& rhs);
  virtual CbcCutModifier * clone() const = 0;

  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) =0;
  virtual void generateCpp( FILE * fp) {}
protected:
  
};

class CbcCutSubsetModifier  : public CbcCutModifier {
public:
  CbcCutSubsetModifier ();

  CbcCutSubsetModifier (int firstOdd);

  // Copy constructor 
  CbcCutSubsetModifier ( const CbcCutSubsetModifier &);
   
  virtual ~CbcCutSubsetModifier();

  CbcCutSubsetModifier & operator=(const CbcCutSubsetModifier& rhs);
  virtual CbcCutModifier * clone() const ;

  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) ;
  virtual void generateCpp( FILE * fp) {}
protected:
  int firstOdd_;
};

#endif

---