Cbc  2.8.12
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
CbcCutGenerator.hpp
Go to the documentation of this file.
1 /* $Id: CbcCutGenerator.hpp 1883 2013-04-06 13:33:15Z stefan $ */
2 // Copyright (C) 2003, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef CbcCutGenerator_H
7 #define CbcCutGenerator_H
8 
9 #include "OsiSolverInterface.hpp"
10 #include "OsiCuts.hpp"
11 #include "CglCutGenerator.hpp"
12 #include "CbcCutModifier.hpp"
13 
14 class CbcModel;
15 class OsiRowCut;
16 class OsiRowCutDebugger;
17 
18 //#############################################################################
19 
50 
51 public:
52 
71  bool generateCuts( OsiCuts &cs, int fullScan, OsiSolverInterface * solver,
72  CbcNode * node);
74 
75 
78  CbcCutGenerator ();
80 
82  CbcCutGenerator(CbcModel * model, CglCutGenerator * generator,
83  int howOften = 1, const char * name = NULL,
84  bool normal = true, bool atSolution = false,
85  bool infeasible = false, int howOftenInsub = -100,
86  int whatDepth = -1, int whatDepthInSub = -1, int switchOffIfLessThan = 0);
87 
90 
93 
97 
105  void refreshModel(CbcModel * model);
106 
108  inline const char * cutGeneratorName() const {
109  return generatorName_;
110  }
111 
113  void generateTuning( FILE * fp);
128  void setHowOften(int value) ;
129 
131  inline int howOften() const {
132  return whenCutGenerator_;
133  }
135  inline int howOftenInSub() const {
136  return whenCutGeneratorInSub_;
137  }
139  inline int inaccuracy() const {
140  return inaccuracy_;
141  }
143  inline void setInaccuracy(int level) {
144  inaccuracy_ = level;
145  }
146 
157  void setWhatDepth(int value) ;
159  void setWhatDepthInSub(int value) ;
161  inline int whatDepth() const {
162  return depthCutGenerator_;
163  }
165  inline int whatDepthInSub() const {
166  return depthCutGeneratorInSub_;
167  }
169  inline void setMaximumTries(int value)
170  { maximumTries_ = value;}
172  inline int maximumTries() const
173  { return maximumTries_;}
174 
176  inline int switches() const {
177  return switches_;
178  }
180  inline bool normal() const {
181  return (switches_&1) != 0;
182  }
184  inline void setNormal(bool value) {
185  switches_ &= ~1;
186  switches_ |= value ? 1 : 0;
187  }
189  inline bool atSolution() const {
190  return (switches_&2) != 0;
191  }
193  inline void setAtSolution(bool value) {
194  switches_ &= ~2;
195  switches_ |= value ? 2 : 0;
196  }
200  inline bool whenInfeasible() const {
201  return (switches_&4) != 0;
202  }
206  inline void setWhenInfeasible(bool value) {
207  switches_ &= ~4;
208  switches_ |= value ? 4 : 0;
209  }
211  inline bool timing() const {
212  return (switches_&64) != 0;
213  }
215  inline void setTiming(bool value) {
216  switches_ &= ~64;
217  switches_ |= value ? 64 : 0;
218  timeInCutGenerator_ = 0.0;
219  }
221  inline double timeInCutGenerator() const {
222  return timeInCutGenerator_;
223  }
224  inline void incrementTimeInCutGenerator(double value) {
225  timeInCutGenerator_ += value;
226  }
228  inline CglCutGenerator * generator() const {
229  return generator_;
230  }
232  inline int numberTimesEntered() const {
233  return numberTimes_;
234  }
235  inline void setNumberTimesEntered(int value) {
236  numberTimes_ = value;
237  }
238  inline void incrementNumberTimesEntered(int value = 1) {
239  numberTimes_ += value;
240  }
242  inline int numberCutsInTotal() const {
243  return numberCuts_;
244  }
245  inline void setNumberCutsInTotal(int value) {
246  numberCuts_ = value;
247  }
248  inline void incrementNumberCutsInTotal(int value = 1) {
249  numberCuts_ += value;
250  }
252  inline int numberElementsInTotal() const {
253  return numberElements_;
254  }
255  inline void setNumberElementsInTotal(int value) {
256  numberElements_ = value;
257  }
258  inline void incrementNumberElementsInTotal(int value = 1) {
259  numberElements_ += value;
260  }
262  inline int numberColumnCuts() const {
263  return numberColumnCuts_;
264  }
265  inline void setNumberColumnCuts(int value) {
266  numberColumnCuts_ = value;
267  }
268  inline void incrementNumberColumnCuts(int value = 1) {
269  numberColumnCuts_ += value;
270  }
272  inline int numberCutsActive() const {
273  return numberCutsActive_;
274  }
275  inline void setNumberCutsActive(int value) {
276  numberCutsActive_ = value;
277  }
278  inline void incrementNumberCutsActive(int value = 1) {
279  numberCutsActive_ += value;
280  }
281  inline void setSwitchOffIfLessThan(int value) {
282  switchOffIfLessThan_ = value;
283  }
284  inline int switchOffIfLessThan() const {
285  return switchOffIfLessThan_;
286  }
288  inline bool needsOptimalBasis() const {
289  return (switches_&128) != 0;
290  }
292  inline void setNeedsOptimalBasis(bool yesNo) {
293  switches_ &= ~128;
294  switches_ |= yesNo ? 128 : 0;
295  }
297  inline bool mustCallAgain() const {
298  return (switches_&8) != 0;
299  }
301  inline void setMustCallAgain(bool yesNo) {
302  switches_ &= ~8;
303  switches_ |= yesNo ? 8 : 0;
304  }
306  inline bool switchedOff() const {
307  return (switches_&16) != 0;
308  }
310  inline void setSwitchedOff(bool yesNo) {
311  switches_ &= ~16;
312  switches_ |= yesNo ? 16 : 0;
313  }
315  inline bool ineffectualCuts() const {
316  return (switches_&512) != 0;
317  }
319  inline void setIneffectualCuts(bool yesNo) {
320  switches_ &= ~512;
321  switches_ |= yesNo ? 512 : 0;
322  }
324  inline bool whetherToUse() const {
325  return (switches_&1024) != 0;
326  }
328  inline void setWhetherToUse(bool yesNo) {
329  switches_ &= ~1024;
330  switches_ |= yesNo ? 1024 : 0;
331  }
333  inline bool whetherInMustCallAgainMode() const {
334  return (switches_&2048) != 0;
335  }
337  inline void setWhetherInMustCallAgainMode(bool yesNo) {
338  switches_ &= ~2048;
339  switches_ |= yesNo ? 2048 : 0;
340  }
342  inline bool whetherCallAtEnd() const {
343  return (switches_&4096) != 0;
344  }
346  inline void setWhetherCallAtEnd(bool yesNo) {
347  switches_ &= ~4096;
348  switches_ |= yesNo ? 4096 : 0;
349  }
351  inline int numberCutsAtRoot() const {
352  return numberCutsAtRoot_;
353  }
354  inline void setNumberCutsAtRoot(int value) {
355  numberCutsAtRoot_ = value;
356  }
358  inline int numberActiveCutsAtRoot() const {
359  return numberActiveCutsAtRoot_;
360  }
361  inline void setNumberActiveCutsAtRoot(int value) {
362  numberActiveCutsAtRoot_ = value;
363  }
365  inline int numberShortCutsAtRoot() const {
366  return numberShortCutsAtRoot_;
367  }
368  inline void setNumberShortCutsAtRoot(int value) {
369  numberShortCutsAtRoot_ = value;
370  }
372  inline void setModel(CbcModel * model) {
373  model_ = model;
374  }
376  inline bool globalCutsAtRoot() const {
377  return (switches_&32) != 0;
378  }
380  inline void setGlobalCutsAtRoot(bool yesNo) {
381  switches_ &= ~32;
382  switches_ |= yesNo ? 32 : 0;
383  }
385  inline bool globalCuts() const {
386  return (switches_&256) != 0;
387  }
389  inline void setGlobalCuts(bool yesNo) {
390  switches_ &= ~256;
391  switches_ |= yesNo ? 256 : 0;
392  }
394  void addStatistics(const CbcCutGenerator * other);
396  void scaleBackStatistics(int factor);
398 
399 private:
402 
403  OsiCuts savedCuts_;
406  double timeInCutGenerator_;
408  CbcModel *model_;
409 
410  // The CglCutGenerator object
411  CglCutGenerator * generator_;
412 
414  char * generatorName_;
415 
419  int whenCutGenerator_;
423  int whenCutGeneratorInSub_;
426  int switchOffIfLessThan_;
427 
431  int depthCutGenerator_;
432 
437  int depthCutGeneratorInSub_;
438 
440  int inaccuracy_;
442  int numberTimes_;
444  int numberCuts_;
446  int numberElements_;
448  int numberColumnCuts_;
450  int numberCutsActive_;
452  int numberCutsAtRoot_;
454  int numberActiveCutsAtRoot_;
456  int numberShortCutsAtRoot_;
458  int switches_;
460  int maximumTries_;
461 };
462 
463 // How often to do if mostly switched off (A)
464 # define SCANCUTS 1000
465 // How often to do if mostly switched off (probing B)
466 # define SCANCUTS_PROBING 1000
467 
468 #endif
469 
void setNumberColumnCuts(int value)
int switchOffIfLessThan() const
void setWhatDepth(int value)
Set the cut generation depth.
int numberCutsAtRoot() const
Number of cuts generated at root.
bool switchedOff() const
Whether generator switched off for moment.
void setNormal(bool value)
Set whether the cut generator should be called in the normal place.
void setWhetherToUse(bool yesNo)
Set whether to use if any cuts generated.
void setIneffectualCuts(bool yesNo)
Set whether last round of cuts did little.
void setNumberCutsInTotal(int value)
bool globalCutsAtRoot() const
Whether global cuts at root.
int maximumTries() const
Get maximum number of times to enter.
const char * cutGeneratorName() const
return name of generator
void incrementNumberCutsInTotal(int value=1)
bool whetherCallAtEnd() const
Whether to call at end.
int switches() const
Get switches (for debug)
void setWhenInfeasible(bool value)
Set whether the cut generator should be called when the subproblem is found to be infeasible...
int whatDepth() const
Get the cut generation depth criterion.
CbcCutGenerator & operator=(const CbcCutGenerator &rhs)
Assignment operator.
bool atSolution() const
Get whether the cut generator should be called when a solution is found.
int numberElementsInTotal() const
Total number of elements added.
void setGlobalCuts(bool yesNo)
Set whether global cuts.
void setNumberCutsAtRoot(int value)
bool generateCuts(OsiCuts &cs, int fullScan, OsiSolverInterface *solver, CbcNode *node)
Generate cuts for the client model.
int numberActiveCutsAtRoot() const
Number of cuts active at root.
void setTiming(bool value)
Set whether the cut generator is being timed.
int numberCutsActive() const
Total number of cuts active after (at end of n cut passes at each node)
void setNeedsOptimalBasis(bool yesNo)
Set if optimal basis needed.
bool globalCuts() const
Whether global cuts.
bool whenInfeasible() const
Get whether the cut generator should be called when the subproblem is found to be infeasible...
void setWhetherInMustCallAgainMode(bool yesNo)
Set whether in must call again mode (or after others)
void setNumberShortCutsAtRoot(int value)
void setAtSolution(bool value)
Set whether the cut generator should be called when a solution is found.
double timeInCutGenerator() const
Return time taken in cut generator.
void setSwitchedOff(bool yesNo)
Set whether generator switched off for moment.
void incrementNumberColumnCuts(int value=1)
void refreshModel(CbcModel *model)
Set the client model.
bool whetherInMustCallAgainMode() const
Whether in must call again mode (or after others)
void setNumberTimesEntered(int value)
int numberTimesEntered() const
Number times cut generator entered.
int inaccuracy() const
Get level of cut inaccuracy (0 means exact e.g. cliques)
Information required while the node is live.
Definition: CbcNode.hpp:49
void setNumberCutsActive(int value)
int numberColumnCuts() const
Total number of column cuts.
int numberCutsInTotal() const
Total number of cuts added.
void setWhetherCallAtEnd(bool yesNo)
Set whether to call at end.
~CbcCutGenerator()
Destructor.
bool timing() const
Get whether the cut generator is being timed.
bool ineffectualCuts() const
Whether last round of cuts did little.
int whatDepthInSub() const
Get the cut generation depth criterion.in sub tree.
void generateTuning(FILE *fp)
Create C++ lines to show how to tune.
void scaleBackStatistics(int factor)
Scale back statistics by factor.
void setMaximumTries(int value)
Set maximum number of times to enter.
void setModel(CbcModel *model)
Set model.
void setGlobalCutsAtRoot(bool yesNo)
Set whether global cuts at root.
void incrementNumberCutsActive(int value=1)
void setInaccuracy(int level)
Set level of cut inaccuracy (0 means exact e.g. cliques)
CglCutGenerator * generator() const
Get the CglCutGenerator corresponding to this CbcCutGenerator.
void setNumberElementsInTotal(int value)
bool whetherToUse() const
Whether to use if any cuts generated.
bool normal() const
Get whether the cut generator should be called in the normal place.
void setWhatDepthInSub(int value)
Set the cut generation depth in sub tree.
CbcCutGenerator()
Default constructor.
void setNumberActiveCutsAtRoot(int value)
bool mustCallAgain() const
Whether generator MUST be called again if any cuts (i.e. ignore break from loop)
int numberShortCutsAtRoot() const
Number of short cuts at root.
void setMustCallAgain(bool yesNo)
Set whether generator MUST be called again if any cuts (i.e. ignore break from loop) ...
bool needsOptimalBasis() const
Say if optimal basis needed.
int howOftenInSub() const
Get the cut generation interval.in sub tree.
Interface between Cbc and Cut Generation Library.
void addStatistics(const CbcCutGenerator *other)
Add in statistics from other.
void setSwitchOffIfLessThan(int value)
Simple Branch and bound class.
Definition: CbcModel.hpp:100
void setHowOften(int value)
Set the cut generation interval.
int howOften() const
Get the cut generation interval.
void incrementTimeInCutGenerator(double value)
void incrementNumberElementsInTotal(int value=1)
void incrementNumberTimesEntered(int value=1)