diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CglTreeInfo.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/CglTreeInfo.hpp | 180 |
1 files changed, 180 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CglTreeInfo.hpp b/thirdparty/linux/include/coin/CglTreeInfo.hpp new file mode 100644 index 0000000..4f85aca --- /dev/null +++ b/thirdparty/linux/include/coin/CglTreeInfo.hpp @@ -0,0 +1,180 @@ +// $Id: CglTreeInfo.hpp 1201 2014-03-07 17:24:04Z forrest $ +// Copyright (C) 2000, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CglTreeInfo_H +#define CglTreeInfo_H + +#include "OsiCuts.hpp" +#include "OsiSolverInterface.hpp" +#include "CoinHelperFunctions.hpp" +class CglStored; +/** Information about where the cut generator is invoked from. */ + +class CglTreeInfo { +public: + /// The level of the search tree node + int level; + /** How many times the cut generator was already invoked in this search tree + node */ + int pass; + /** The number of rows in the original formulation. Some generators may not + want to consider already generated rows when generating new ones. */ + int formulation_rows; + /** Options + 1 - treat costed integers as important + 2 - switch off some stuff as variables semi-integer + 4 - set global cut flag if at root node + 8 - set global cut flag if at root node and first pass + 16 - set global cut flag and make cuts globally valid + 32 - last round of cuts did nothing - maybe be more aggressive + 64 - in preprocessing stage + 128 - looks like solution + 256 - want alternate cuts + 512 - in sub tree (i.e. parent model) + 1024 - in must call again mode or after everything mode + */ + int options; + /// Set true if in tree (to avoid ambiguity at first branch) + bool inTree; + /** Replacement array. Before Branch and Cut it may be beneficial to strengthen rows + rather than adding cuts. If this array is not NULL then the cut generator can + place a pointer to the stronger cut in this array which is number of rows in size. + + A null (i.e. zero elements and free rhs) cut indicates that the row is useless + and can be removed. + + The calling function can then replace those rows. + */ + OsiRowCut ** strengthenRow; + /// Optional pointer to thread specific random number generator + CoinThreadRandom * randomNumberGenerator; + /// Default constructor + CglTreeInfo (); + + /// Copy constructor + CglTreeInfo ( + const CglTreeInfo &); + /// Clone + virtual CglTreeInfo * clone() const; + + /// Assignment operator + CglTreeInfo & + operator=( + const CglTreeInfo& rhs); + + /// Destructor + virtual + ~CglTreeInfo (); + /// Take action if cut generator can fix a variable (toValue -1 for down, +1 for up) + virtual bool fixes(int , int , int ,bool) {return false;} + /** Initalizes fixing arrays etc - returns >0 if we want to save info + 0 if we don't and -1 if is to be used */ + virtual int initializeFixing(const OsiSolverInterface * ) {return 0;} + +}; + +/** Derived class to pick up probing info. */ +typedef struct { + //unsigned int oneFixed:1; // nonzero if variable to 1 fixes all + //unsigned int sequence:31; // variable (in matrix) (but also see cliqueRow_) + unsigned int fixes; +} CliqueEntry; + +class CglTreeProbingInfo : public CglTreeInfo { +public: + /// Default constructor + CglTreeProbingInfo (); + /// Constructor from model + CglTreeProbingInfo (const OsiSolverInterface * model); + + /// Copy constructor + CglTreeProbingInfo ( + const CglTreeProbingInfo &); + /// Clone + virtual CglTreeInfo * clone() const; + + /// Assignment operator + CglTreeProbingInfo & + operator=( + const CglTreeProbingInfo& rhs); + + /// Destructor + virtual + ~CglTreeProbingInfo (); + OsiSolverInterface * analyze(const OsiSolverInterface & si, int createSolver=0, + int numberExtraCliques=0,const int * starts=NULL, + const CliqueEntry * entries=NULL,const char * type=NULL); + /** Take action if cut generator can fix a variable + (toValue -1 for down, +1 for up) + Returns true if still room, false if not */ + virtual bool fixes(int variable, int toValue, int fixedVariable,bool fixedToLower); + /** Initalizes fixing arrays etc - returns >0 if we want to save info + 0 if we don't and -1 if is to be used */ + virtual int initializeFixing(const OsiSolverInterface * model) ; + /// Fix entries in a solver using implications + int fixColumns(OsiSolverInterface & si) const; + /// Fix entries in a solver using implications for one variable + int fixColumns(int iColumn, int value, OsiSolverInterface & si) const; + /// Packs down entries + int packDown(); + /// Generate cuts from implications + void generateCuts(const OsiSolverInterface & si, OsiCuts & cs, + const CglTreeInfo info) const; + /// Entries for fixing variables + inline CliqueEntry * fixEntries() + { convert(); return fixEntry_;} + /// Starts of integer variable going to zero + inline int * toZero() + { convert(); return toZero_;} + /// Starts of integer variable going to one + inline int * toOne() + { convert(); return toOne_;} + /// List of 0-1 integer variables + inline int * integerVariable() const + { return integerVariable_;} + /// Backward look up + inline int * backward() const + { return backward_;} + /// Number of variables + inline int numberVariables() const + { return numberVariables_;} + /// Number of 0-1 variables + inline int numberIntegers() const + { return numberIntegers_;} +private: + /// Converts to ordered + void convert(); +protected: + /// Entries for fixing variables + CliqueEntry * fixEntry_; + /// Starts of integer variable going to zero + int * toZero_; + /// Starts of integer variable going to one + int * toOne_; + /// List of 0-1 integer variables + int * integerVariable_; + /// Backward look up + int * backward_; + /// Entries for fixing variable when collecting + int * fixingEntry_; + /// Number of variables + int numberVariables_; + /// Number of 0-1 variables + int numberIntegers_; + /// Maximum number in fixEntry_ + int maximumEntries_; + /// Number entries in fixingEntry_ (and fixEntry_) or -2 if correct style + int numberEntries_; +}; +inline int sequenceInCliqueEntry(const CliqueEntry & cEntry) +{ return cEntry.fixes&0x7fffffff;} +inline void setSequenceInCliqueEntry(CliqueEntry & cEntry,int sequence) +{ cEntry.fixes = sequence|(cEntry.fixes&0x80000000);} +inline bool oneFixesInCliqueEntry(const CliqueEntry & cEntry) +{ return (cEntry.fixes&0x80000000)!=0;} +inline void setOneFixesInCliqueEntry(CliqueEntry & cEntry,bool oneFixes) +{ cEntry.fixes = (oneFixes ? 0x80000000 : 0)|(cEntry.fixes&0x7fffffff);} + +#endif |