diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CbcCutGenerator.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/CbcCutGenerator.hpp | 482 |
1 files changed, 482 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcCutGenerator.hpp b/thirdparty/linux/include/coin/CbcCutGenerator.hpp new file mode 100644 index 0000000..f07142e --- /dev/null +++ b/thirdparty/linux/include/coin/CbcCutGenerator.hpp @@ -0,0 +1,482 @@ +/* $Id: CbcCutGenerator.hpp 2081 2014-09-25 11:31:17Z forrest $ */ +// 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; + +//############################################################################# + +/** Interface between Cbc and Cut Generation Library. + + \c CbcCutGenerator is intended to provide an intelligent interface between + Cbc and the cutting plane algorithms in the CGL. A \c CbcCutGenerator is + bound to a \c CglCutGenerator and to an \c CbcModel. It contains parameters + which control when and how the \c generateCuts method of the + \c CglCutGenerator will be called. + + The builtin decision criteria available to use when deciding whether to + generate cuts are limited: every <i>X</i> nodes, when a solution is found, + and when a subproblem is found to be infeasible. The idea is that the class + will grow more intelligent with time. + + \todo Add a pointer to function member which will allow a client to install + their own decision algorithm to decide whether or not to call the CGL + \p generateCuts method. Create a default decision method that looks + at the builtin criteria. + + \todo It strikes me as not good that generateCuts contains code specific to + individual CGL algorithms. Another set of pointer to function members, + so that the client can specify the cut generation method as well as + pre- and post-generation methods? Taken a bit further, should this + class contain a bunch of pointer to function members, one for each + of the places where the cut generator might be referenced? + Initialization, root node, search tree node, discovery of solution, + and termination all come to mind. Initialization and termination would + also be useful for instrumenting cbc. +*/ + +class CbcCutGenerator { + +public: + + /** \name Generate Cuts */ + //@{ + /** Generate cuts for the client model. + + Evaluate the state of the client model and decide whether to generate cuts. + The generated cuts are inserted into and returned in the collection of cuts + \p cs. + + If \p fullScan is !=0, the generator is obliged to call the CGL + \c generateCuts routine. Otherwise, it is free to make a local decision. + Negative fullScan says things like at integer solution + The current implementation uses \c whenCutGenerator_ to decide. + + The routine returns true if reoptimisation is needed (because the state of + the solver interface has been modified). + + If node then can find out depth + */ + bool generateCuts( OsiCuts &cs, int fullScan, OsiSolverInterface * solver, + CbcNode * node); + //@} + + + /**@name Constructors and destructors */ + //@{ + /// Default constructor + CbcCutGenerator (); + + /// Normal constructor + 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); + + /// Copy constructor + CbcCutGenerator (const CbcCutGenerator &); + + /// Assignment operator + CbcCutGenerator & operator=(const CbcCutGenerator& rhs); + + /// Destructor + ~CbcCutGenerator (); + //@} + + /**@name Gets and sets */ + //@{ + /** Set the client model. + + In addition to setting the client model, refreshModel also calls + the \c refreshSolver method of the CglCutGenerator object. + */ + void refreshModel(CbcModel * model); + + /// return name of generator + inline const char * cutGeneratorName() const { + return generatorName_; + } + + /// Create C++ lines to show how to tune + void generateTuning( FILE * fp); + /** Set the cut generation interval + + Set the number of nodes evaluated between calls to the Cgl object's + \p generateCuts routine. + + If \p value is positive, cuts will always be generated at the specified + interval. + If \p value is negative, cuts will initially be generated at the specified + interval, but Cbc may adjust the value depending on the success of cuts + produced by this generator. + + A value of -100 disables the generator, while a value of -99 means + just at root. + */ + void setHowOften(int value) ; + + /// Get the cut generation interval. + inline int howOften() const { + return whenCutGenerator_; + } + /// Get the cut generation interval.in sub tree + inline int howOftenInSub() const { + return whenCutGeneratorInSub_; + } + /// Get level of cut inaccuracy (0 means exact e.g. cliques) + inline int inaccuracy() const { + return inaccuracy_; + } + /// Set level of cut inaccuracy (0 means exact e.g. cliques) + inline void setInaccuracy(int level) { + inaccuracy_ = level; + } + + /** Set the cut generation depth + + Set the depth criterion for calls to the Cgl object's + \p generateCuts routine. Only active if > 0. + + If whenCutGenerator is positive and this is positive then this overrides. + If whenCutGenerator is -1 then this is used as criterion if any cuts + were generated at root node. + If whenCutGenerator is anything else this is ignored. + */ + void setWhatDepth(int value) ; + /// Set the cut generation depth in sub tree + void setWhatDepthInSub(int value) ; + /// Get the cut generation depth criterion. + inline int whatDepth() const { + return depthCutGenerator_; + } + /// Get the cut generation depth criterion.in sub tree + inline int whatDepthInSub() const { + return depthCutGeneratorInSub_; + } + /// Set maximum number of times to enter + inline void setMaximumTries(int value) + { maximumTries_ = value;} + /// Get maximum number of times to enter + inline int maximumTries() const + { return maximumTries_;} + + /// Get switches + inline int switches() const { + return switches_; + } + /// Set switches (for copying from virgin state) + inline void setSwitches(int value) { + switches_ = value; + } + /// Get whether the cut generator should be called in the normal place + inline bool normal() const { + return (switches_&1) != 0; + } + /// Set whether the cut generator should be called in the normal place + inline void setNormal(bool value) { + switches_ &= ~1; + switches_ |= value ? 1 : 0; + } + /// Get whether the cut generator should be called when a solution is found + inline bool atSolution() const { + return (switches_&2) != 0; + } + /// Set whether the cut generator should be called when a solution is found + inline void setAtSolution(bool value) { + switches_ &= ~2; + switches_ |= value ? 2 : 0; + } + /** Get whether the cut generator should be called when the subproblem is + found to be infeasible. + */ + inline bool whenInfeasible() const { + return (switches_&4) != 0; + } + /** Set whether the cut generator should be called when the subproblem is + found to be infeasible. + */ + inline void setWhenInfeasible(bool value) { + switches_ &= ~4; + switches_ |= value ? 4 : 0; + } + /// Get whether the cut generator is being timed + inline bool timing() const { + return (switches_&64) != 0; + } + /// Set whether the cut generator is being timed + inline void setTiming(bool value) { + switches_ &= ~64; + switches_ |= value ? 64 : 0; + timeInCutGenerator_ = 0.0; + } + /// Return time taken in cut generator + inline double timeInCutGenerator() const { + return timeInCutGenerator_; + } + inline void incrementTimeInCutGenerator(double value) { + timeInCutGenerator_ += value; + } + /// Get the \c CglCutGenerator corresponding to this \c CbcCutGenerator. + inline CglCutGenerator * generator() const { + return generator_; + } + /// Number times cut generator entered + inline int numberTimesEntered() const { + return numberTimes_; + } + inline void setNumberTimesEntered(int value) { + numberTimes_ = value; + } + inline void incrementNumberTimesEntered(int value = 1) { + numberTimes_ += value; + } + /// Total number of cuts added + inline int numberCutsInTotal() const { + return numberCuts_; + } + inline void setNumberCutsInTotal(int value) { + numberCuts_ = value; + } + inline void incrementNumberCutsInTotal(int value = 1) { + numberCuts_ += value; + } + /// Total number of elements added + inline int numberElementsInTotal() const { + return numberElements_; + } + inline void setNumberElementsInTotal(int value) { + numberElements_ = value; + } + inline void incrementNumberElementsInTotal(int value = 1) { + numberElements_ += value; + } + /// Total number of column cuts + inline int numberColumnCuts() const { + return numberColumnCuts_; + } + inline void setNumberColumnCuts(int value) { + numberColumnCuts_ = value; + } + inline void incrementNumberColumnCuts(int value = 1) { + numberColumnCuts_ += value; + } + /// Total number of cuts active after (at end of n cut passes at each node) + 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_; + } + /// Say if optimal basis needed + inline bool needsOptimalBasis() const { + return (switches_&128) != 0; + } + /// Set if optimal basis needed + inline void setNeedsOptimalBasis(bool yesNo) { + switches_ &= ~128; + switches_ |= yesNo ? 128 : 0; + } + /// Whether generator MUST be called again if any cuts (i.e. ignore break from loop) + inline bool mustCallAgain() const { + return (switches_&8) != 0; + } + /// Set whether generator MUST be called again if any cuts (i.e. ignore break from loop) + inline void setMustCallAgain(bool yesNo) { + switches_ &= ~8; + switches_ |= yesNo ? 8 : 0; + } + /// Whether generator switched off for moment + inline bool switchedOff() const { + return (switches_&16) != 0; + } + /// Set whether generator switched off for moment + inline void setSwitchedOff(bool yesNo) { + switches_ &= ~16; + switches_ |= yesNo ? 16 : 0; + } + /// Whether last round of cuts did little + inline bool ineffectualCuts() const { + return (switches_&512) != 0; + } + /// Set whether last round of cuts did little + inline void setIneffectualCuts(bool yesNo) { + switches_ &= ~512; + switches_ |= yesNo ? 512 : 0; + } + /// Whether to use if any cuts generated + inline bool whetherToUse() const { + return (switches_&1024) != 0; + } + /// Set whether to use if any cuts generated + inline void setWhetherToUse(bool yesNo) { + switches_ &= ~1024; + switches_ |= yesNo ? 1024 : 0; + } + /// Whether in must call again mode (or after others) + inline bool whetherInMustCallAgainMode() const { + return (switches_&2048) != 0; + } + /// Set whether in must call again mode (or after others) + inline void setWhetherInMustCallAgainMode(bool yesNo) { + switches_ &= ~2048; + switches_ |= yesNo ? 2048 : 0; + } + /// Whether to call at end + inline bool whetherCallAtEnd() const { + return (switches_&4096) != 0; + } + /// Set whether to call at end + inline void setWhetherCallAtEnd(bool yesNo) { + switches_ &= ~4096; + switches_ |= yesNo ? 4096 : 0; + } + /// Whether needs refresh on copy + inline bool needsRefresh() const { + return (switches_&8192) != 0; + } + /// Set whether needs refresh on copy + inline void setNeedsRefresh(bool yesNo) { + switches_ &= ~8192; + switches_ |= yesNo ? 8192 : 0; + } + /// Number of cuts generated at root + inline int numberCutsAtRoot() const { + return numberCutsAtRoot_; + } + inline void setNumberCutsAtRoot(int value) { + numberCutsAtRoot_ = value; + } + /// Number of cuts active at root + inline int numberActiveCutsAtRoot() const { + return numberActiveCutsAtRoot_; + } + inline void setNumberActiveCutsAtRoot(int value) { + numberActiveCutsAtRoot_ = value; + } + /// Number of short cuts at root + inline int numberShortCutsAtRoot() const { + return numberShortCutsAtRoot_; + } + inline void setNumberShortCutsAtRoot(int value) { + numberShortCutsAtRoot_ = value; + } + /// Set model + inline void setModel(CbcModel * model) { + model_ = model; + } + /// Whether global cuts at root + inline bool globalCutsAtRoot() const { + return (switches_&32) != 0; + } + /// Set whether global cuts at root + inline void setGlobalCutsAtRoot(bool yesNo) { + switches_ &= ~32; + switches_ |= yesNo ? 32 : 0; + } + /// Whether global cuts + inline bool globalCuts() const { + return (switches_&256) != 0; + } + /// Set whether global cuts + inline void setGlobalCuts(bool yesNo) { + switches_ &= ~256; + switches_ |= yesNo ? 256 : 0; + } + /// Add in statistics from other + void addStatistics(const CbcCutGenerator * other); + /// Scale back statistics by factor + void scaleBackStatistics(int factor); + //@} + +private: + /**@name Private gets and sets */ + //@{ + //@} + /// Saved cuts + OsiCuts savedCuts_; + /// Time in cut generator + double timeInCutGenerator_; + /// The client model + CbcModel *model_; + + // The CglCutGenerator object + CglCutGenerator * generator_; + + /// Name of generator + char * generatorName_; + + /** Number of nodes between calls to the CglCutGenerator::generateCuts + routine. + */ + int whenCutGenerator_; + /** Number of nodes between calls to the CglCutGenerator::generateCuts + routine in sub tree. + */ + int whenCutGeneratorInSub_; + /** If first pass at root produces fewer than this cuts then switch off + */ + int switchOffIfLessThan_; + + /** Depth at which to call the CglCutGenerator::generateCuts + routine (If >0 then overrides when and is called if depth%depthCutGenerator==0). + */ + int depthCutGenerator_; + + /** Depth at which to call the CglCutGenerator::generateCuts + routine (If >0 then overrides when and is called if depth%depthCutGenerator==0). + In sub tree. + */ + int depthCutGeneratorInSub_; + + /// Level of cut inaccuracy (0 means exact e.g. cliques) + int inaccuracy_; + /// Number times cut generator entered + int numberTimes_; + /// Total number of cuts added + int numberCuts_; + /// Total number of elements added + int numberElements_; + /// Total number of column cuts added + int numberColumnCuts_; + /// Total number of cuts active after (at end of n cut passes at each node) + int numberCutsActive_; + /// Number of cuts generated at root + int numberCutsAtRoot_; + /// Number of cuts active at root + int numberActiveCutsAtRoot_; + /// Number of short cuts at root + int numberShortCutsAtRoot_; + /// Switches - see gets and sets + int switches_; + /// Maximum number of times to enter + 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 + |