diff options
Diffstat (limited to 'thirdparty/linux/include/coin/CbcHeuristicDW.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/CbcHeuristicDW.hpp | 309 |
1 files changed, 309 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcHeuristicDW.hpp b/thirdparty/linux/include/coin/CbcHeuristicDW.hpp new file mode 100644 index 0000000..337bd0f --- /dev/null +++ b/thirdparty/linux/include/coin/CbcHeuristicDW.hpp @@ -0,0 +1,309 @@ +// $Id: CbcHeuristicDW.hpp 1899 2013-04-09 18:12:08Z stefan $ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + + +#ifndef CbcHeuristicDW_H +#define CbcHeuristicDW_H + +#include "CbcHeuristic.hpp" + +/** + This is unlike the other heuristics in that it is very very compute intensive. + It tries to find a DW structure and use that + */ + +class CbcHeuristicDW : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicDW (); + + /* Constructor with model - assumed before cuts + */ + CbcHeuristicDW (CbcModel & model, int keepContinuous=0); + + /* Constructor with model - assumed before cuts + */ + CbcHeuristicDW (CbcModel & model, + int callBack(CbcHeuristicDW * currentHeuristic, + CbcModel * thisModel, + int whereFrom), + int keepContinuous=0); + + // Copy constructor + CbcHeuristicDW ( const CbcHeuristicDW &); + + // Destructor + ~CbcHeuristicDW (); + + /// Clone + virtual CbcHeuristic * clone() const; + + + /// Assignment operator + CbcHeuristicDW & operator=(const CbcHeuristicDW& rhs); + + /// Create C++ lines to get to current state + virtual void generateCpp( FILE * fp) ; + + /// Resets stuff if model changes + virtual void resetModel(CbcModel * model); + + /// update model (This is needed if cliques update matrix etc) + virtual void setModel(CbcModel * model); + using CbcHeuristic::solution ; + /** returns 0 if no solution, 1 if valid solution. + Sets solution values if good, sets objective value (only if good) + This does Relaxation Induced Neighborhood Search + */ + virtual int solution(double & objectiveValue, + double * newSolution); + /** Return number of blocks + <=0 - no usable structure */ + inline int numberBlocks() const + { return numberBlocks_;} + /// Pass in a solution + void passInSolution(const double * solution); + /// Pass in continuous solution + void passInContinuousSolution(const double * solution); + /** DW Proposal actions + fullDWEverySoOften - + 0 - off + k - every k times solution gets better + */ + void setProposalActions(int fullDWEverySoOften); + /// Objective value when whichDw created + double objectiveValueWhen(int whichDW) const; + /// Number of columns in DW + int numberColumnsDW(int whichDW) const; + /// Solver + inline OsiSolverInterface * solver() const + { return solver_;} + /// DW model (user must delete) + OsiSolverInterface * DWModel(int whichDW) const; + /// Best objective value + inline double bestObjective() const + { return bestObjective_;} + /// Best solution found so far + inline const double * bestSolution() const + { return bestSolution_;} + /// Continuous solution + inline const double * continuousSolution() const + { return continuousSolution_;} + /// Reduced costs of fixed solution + inline const double * fixedDj() const + { return fixedDj_;} + /// Objective at which DW updated + inline const double * objectiveDW() const + { return objectiveDW_;} + /// Number of times we have added to DW model + inline int numberDWTimes() const + { return numberDWTimes_;} + /// Number of columns in DW + inline const int * numberColumnsDW() const + { return numberColumnsDW_;} + /// Set number of passes + inline void setNumberPasses(int value) + { numberPasses_ = value;} + /// Set number of passes without better solution + inline void setNumberBadPasses(int value) + { numberBadPasses_ = value;} + /// Set number free integers needed (Base value) + inline void setNumberNeeded(int value) + { nNeededBase_ = value;} + /// Get number free integers needed (Base value) + inline int getNumberNeeded() const + {return nNeededBase_;} + /// Set number free integers needed (Current value) + inline void setCurrentNumberNeeded(int value) + { nNeeded_ = value;} + /// Get number free integers needed (Current value) + inline int getCurrentNumberNeeded() const + {return nNeeded_;} + /// Set number nodes (could be done in callback) (Base value) + inline void setNumberNodes(int value) + { nNodesBase_ = value;} + /// Get number nodes (could be done in callback) (Base value) + inline int getNumberNodes() const + {return nNodesBase_;} + /// Set number nodes (could be done in callback) (Current value) + inline void setCurrentNumberNodes(int value) + { nNodes_ = value;} + /// Get number nodes (could be done in callback) (Current value) + inline int getCurrentNumberNodes() const + {return nNodes_;} + /// Set target objective + inline void setTargetObjective(double value) + { targetObjective_ = value;} + /// Sets how often to do it + inline void setHowOften(int value) { + howOften_ = value; + } + /// Block for every row + inline const int * whichRowBlock() const + { return whichRowBlock_;} + /// Block for every column + inline const int * whichColumnBlock() const + { return whichColumnBlock_;} + /// Initial Lower bounds + inline double * initialLower() const + { return saveLower_;} + /// Initial Upper bounds + inline double * initialUpper() const + { return saveUpper_;} + /// Local integer arrays (each numberBlocks_ long) + inline int * intArrays() const + { return intArray_;} + /// Local double arrays (each numberBlocks_ long) + inline double * doubleArrays() const + { return doubleArray_;} + /// Phase of solution + inline int phase() const + { return phase_;} + /// Pass number + inline int pass() const + { return pass_;} + /// Which columns are in block + inline const int * columnsInBlock() const + { return columnsInBlock_;} + /// Starts for columnsInBlock + inline const int * startColumnBlock() const + { return startColumnBlock_;} + /// Number of integer variables in each block + inline const int * intsInBlock() const + { return intsInBlock_;} + /// Objective value (could also check validity) + double objectiveValue(const double * solution); +private: + /// Guts of copy + void gutsOfCopy(const CbcHeuristicDW & rhs); + /// Guts of delete + void gutsOfDelete(); + /// Set default values + void setDefaults(); + /// Find structure + void findStructure(); + /// Set up DW structure + void setupDWStructures(); + /// Add DW proposals + int addDW(const double * solution,int numberBlocksUsed, + const int * whichBlocks); +protected: + typedef int (*heuristicCallBack) (CbcHeuristicDW * ,CbcModel *, int) ; + // Data + /// Target objective + double targetObjective_; + /// Best objective value + double bestObjective_; + /// Objective value last time + double lastObjective_; + /** Call back + whereFrom - + 0 - after blocks found but before data setup + 1 - after blocks sorted but before used + 2 - just before normal branch and bound + 3 - after DW has been updated + 4 - if better solution found + 5 - every time a block might be used + next few for adjustment of nNeeded etc + 6 - complete search done - no solution + 7 - stopped on nodes - no improvement + 8 - improving (same as 4 but after nNeeded changed + Pointers to local data given by following pointers + */ + heuristicCallBack functionPointer_; + /// Local integer arrays (each numberBlocks_ long) + int * intArray_; + /// Local double arrays (each numberBlocks_ long) + double * doubleArray_; + /// Base solver + OsiSolverInterface * solver_; + /// DW solver + OsiSolverInterface * dwSolver_; + /// Best solution found so far + double * bestSolution_; + /// Continuous solution + double * continuousSolution_; + /// Reduced costs of fixed solution + double * fixedDj_; + /// Original lower bounds + double * saveLower_; + /// Original Upper bounds + double * saveUpper_; + /// random numbers for master rows + double * random_; + /// Weights for each proposal + double * weights_; + /// Objective at which DW updated + double * objectiveDW_; + /// Number of columns in each DW + int * numberColumnsDW_; + /// Block for every row + int * whichRowBlock_; + /// Block for every column + int * whichColumnBlock_; + /// Block number for each proposal + int * dwBlock_; + /// Points back to master rows + int * backwardRow_; + /// Which rows are in blocke + int * rowsInBlock_; + /// Which columns are in block + int * columnsInBlock_; + /// Starts for rowsInBlock + int * startRowBlock_; + /// Starts for columnsInBlock + int * startColumnBlock_; + /// Number of integer variables in each block + int * intsInBlock_; + /// Bits set for 1 integers in each block + unsigned int * fingerPrint_; + /// Affinity each block has for other (will be triangular?) + unsigned short * affinity_; + /** DW Proposal actions + fullDWEverySoOften - + 0 - off + k - every k times solution gets better + */ + int fullDWEverySoOften_; + /// Number of passes + int numberPasses_; + /// How often to do (code can change) + int howOften_; + /// Current maximum number of DW proposals + int maximumDW_; + /// Number of DW proposals + int numberDW_; + /// Number of times we have added to DW model + int numberDWTimes_; + /// Number of unsigned ints needed for each block of fingerPrint + int sizeFingerPrint_; + /// Number of columns in master + int numberMasterColumns_; + /// Number of rows in master + int numberMasterRows_; + /// Number of blocks + int numberBlocks_; + /// Action on decomposition - 1 keep continuous, 0 don't + int keepContinuous_; + /// Phase of solution + int phase_; + /// Pass number + int pass_; + /// Base number of integers needed + int nNeededBase_; + /// Base number of nodes needed + int nNodesBase_; + /// Base number of integers needed + int nNeeded_; + /// Base number of nodes needed + int nNodes_; + /// Number of passes without better solution + int numberBadPasses_; + // 0 - fine, 1 can't be better, 2 max node + int solveState_; +}; + +#endif |