diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/CbcHeuristicFPump.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/CbcHeuristicFPump.hpp | 340 |
1 files changed, 340 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/CbcHeuristicFPump.hpp b/newstructure/thirdparty/linux/include/coin/CbcHeuristicFPump.hpp new file mode 100644 index 0000000..1c1af86 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/CbcHeuristicFPump.hpp @@ -0,0 +1,340 @@ +/* $Id: CbcHeuristicFPump.hpp 1573 2011-01-05 01:12:36Z lou $ */ +// Copyright (C) 2004, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CbcHeuristicFeasibilityPump_H +#define CbcHeuristicFeasibilityPump_H + +#include "CbcHeuristic.hpp" +#include "OsiClpSolverInterface.hpp" + +/** Feasibility Pump class + */ + +class CbcHeuristicFPump : public CbcHeuristic { +public: + + // Default Constructor + CbcHeuristicFPump (); + + // Constructor with model - assumed before cuts + CbcHeuristicFPump (CbcModel & model, + double downValue = 0.5, bool roundExpensive = false); + + // Copy constructor + CbcHeuristicFPump ( const CbcHeuristicFPump &); + + // Destructor + ~CbcHeuristicFPump (); + + /// Assignment operator + CbcHeuristicFPump & operator=(const CbcHeuristicFPump& rhs); + /// Clone + virtual CbcHeuristic * clone() const; + /// 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 + with better objective value than one passed in + Sets solution values if good, sets objective value (only if good) + This is called after cuts have been added - so can not add cuts. + + It may make sense for user to call this outside Branch and Cut to + get solution. Or normally is just at root node. + + * new meanings for when_ - on first try then set back to 1 + 11 - at end fix all integers at same bound throughout + 12 - also fix all integers staying at same internal integral value throughout + 13 - also fix all continuous variables staying at same bound throughout + 14 - also fix all continuous variables staying at same internal value throughout + 15 - as 13 but no internal integers + And beyond that, it's apparently possible for the range to be between 21 + and 25, in which case it's reduced on entry to solution() to be between + 11 and 15 and allSlack is set to true. Then, if we're not processing + general integers, we'll use an all-slack basis to solve ... what? Don't + see that yet. + */ + virtual int solution(double & objectiveValue, + double * newSolution); + + /// Set maximum Time (default off) - also sets starttime to current + void setMaximumTime(double value); + /// Get maximum Time (default 0.0 == time limit off) + inline double maximumTime() const { + return maximumTime_; + } + /// Set fake cutoff (default COIN_DBL_MAX == off) + inline void setFakeCutoff(double value) { + fakeCutoff_ = value; + } + /// Get fake cutoff (default 0.0 == off) + inline double fakeCutoff() const { + return fakeCutoff_; + } + /// Set absolute increment (default 0.0 == off) + inline void setAbsoluteIncrement(double value) { + absoluteIncrement_ = value; + } + /// Get absolute increment (default 0.0 == off) + inline double absoluteIncrement() const { + return absoluteIncrement_; + } + /// Set relative increment (default 0.0 == off) + inline void setRelativeIncrement(double value) { + relativeIncrement_ = value; + } + /// Get relative increment (default 0.0 == off) + inline double relativeIncrement() const { + return relativeIncrement_; + } + /// Set default rounding (default 0.5) + inline void setDefaultRounding(double value) { + defaultRounding_ = value; + } + /// Get default rounding (default 0.5) + inline double defaultRounding() const { + return defaultRounding_; + } + /// Set initial weight (default 0.0 == off) + inline void setInitialWeight(double value) { + initialWeight_ = value; + } + /// Get initial weight (default 0.0 == off) + inline double initialWeight() const { + return initialWeight_; + } + /// Set weight factor (default 0.1) + inline void setWeightFactor(double value) { + weightFactor_ = value; + } + /// Get weight factor (default 0.1) + inline double weightFactor() const { + return weightFactor_; + } + /// Set threshold cost for using original cost - even on continuous (default infinity) + inline void setArtificialCost(double value) { + artificialCost_ = value; + } + /// Get threshold cost for using original cost - even on continuous (default infinity) + inline double artificialCost() const { + return artificialCost_; + } + /// Get iteration to size ratio + inline double iterationRatio() const { + return iterationRatio_; + } + /// Set iteration to size ratio + inline void setIterationRatio(double value) { + iterationRatio_ = value; + } + /// Set maximum passes (default 100) + inline void setMaximumPasses(int value) { + maximumPasses_ = value; + } + /// Get maximum passes (default 100) + inline int maximumPasses() const { + return maximumPasses_; + } + /// Set maximum retries (default 1) + inline void setMaximumRetries(int value) { + maximumRetries_ = value; + } + /// Get maximum retries (default 1) + inline int maximumRetries() const { + return maximumRetries_; + } + /** Set use of multiple solutions and solves + 0 - do not reuse solves, do not accumulate integer solutions for local search + 1 - do not reuse solves, accumulate integer solutions for local search + 2 - reuse solves, do not accumulate integer solutions for local search + 3 - reuse solves, accumulate integer solutions for local search + If we add 4 then use second form of problem (with extra rows and variables for general integers) + At some point (date?), I added + + And then there are a few bit fields: + 4 - something about general integers + So my (lh) guess for 4 was at least in the ballpark, but I'll have to + rethink 8 entirely (and it may well not mean the same thing as it did + when I added that comment. + 8 - determines whether we process general integers + + And on 090831, John added + + If we add 4 then use second form of problem (with extra rows and + variables for general integers) + If we add 8 then can run after initial cuts (if no solution) + */ + inline void setAccumulate(int value) { + accumulate_ = value; + } + /// Get accumulation option + inline int accumulate() const { + return accumulate_; + } + /** Set whether to fix variables on known solution + 0 - do not fix + 1 - fix integers on reduced costs + 2 - fix integers on reduced costs but only on entry + */ + inline void setFixOnReducedCosts(int value) { + fixOnReducedCosts_ = value; + } + /// Get reduced cost option + inline int fixOnReducedCosts() const { + return fixOnReducedCosts_; + } + /** Set reduced cost multiplier + 1.0 as normal + <1.0 (x) - pretend gap is x* actual gap - just for fixing + */ + inline void setReducedCostMultiplier(double value) { + reducedCostMultiplier_ = value; + } + /// Get reduced cost multiplier + inline double reducedCostMultiplier() const { + return reducedCostMultiplier_; + } + +protected: + // Data + /// Start time + double startTime_; + /// Maximum Cpu seconds + double maximumTime_; + /** Fake cutoff value. + If set then better of real cutoff and this used to add a constraint + */ + double fakeCutoff_; + /// If positive carry on after solution expecting gain of at least this + double absoluteIncrement_; + /// If positive carry on after solution expecting gain of at least this times objective + double relativeIncrement_; + /// Default is round up if > this + double defaultRounding_; + /// Initial weight for true objective + double initialWeight_; + /// Factor for decreasing weight + double weightFactor_; + /// Threshold cost for using original cost - even on continuous + double artificialCost_; + /** If iterationRatio >0 use instead of maximumPasses_ + test is iterations > ratio*(2*nrow+ncol) */ + double iterationRatio_; + /** Reduced cost multiplier + 1.0 as normal + <1.0 (x) - pretend gap is x* actual gap - just for fixing + */ + double reducedCostMultiplier_; + /// Maximum number of passes + int maximumPasses_; + /** Maximum number of retries if we find a solution. + If negative we clean out used array + */ + int maximumRetries_; + /** Set use of multiple solutions and solves + 0 - do not reuse solves, do not accumulate integer solutions for local search + 1 - do not reuse solves, accumulate integer solutions for local search + 2 - reuse solves, do not accumulate integer solutions for local search + 3 - reuse solves, accumulate integer solutions for local search + If we add 4 then use second form of problem (with extra rows and variables for general integers) + If we do not accumulate solutions then no mini branch and bounds will be done + reuse - refers to initial solve after adding in new "cut" + If we add 8 then can run after initial cuts (if no solution) + */ + int accumulate_; + /** Set whether to fix variables on known solution + 0 - do not fix + 1 - fix integers on reduced costs + 2 - fix integers on reduced costs but only on entry + */ + int fixOnReducedCosts_; + /// If true round to expensive + bool roundExpensive_; + +private: + /** Rounds solution - down if < downValue + If roundExpensive then always to more expnsive. + returns 0 if current is solution + */ + int rounds(OsiSolverInterface * solver, double * solution, + /*const double * objective, */ + int numberIntegers, const int * integerVariable, + /*char * pumpPrint,*/int passNumber, + /*bool roundExpensive=false,*/ + double downValue = 0.5, int *flip = 0); + /* note for eagle eyed readers. + when_ can now be exotic - + <=10 normal + */ +}; + +# ifdef COIN_HAS_CLP + +class CbcDisasterHandler : public OsiClpDisasterHandler { +public: + /**@name Virtual methods that the derived classe should provide. + */ + //@{ +#ifdef JJF_ZERO + /// Into simplex + virtual void intoSimplex(); + /// Checks if disaster + virtual bool check() const ; + /// saves information for next attempt + virtual void saveInfo(); +#endif + /// Type of disaster 0 can fix, 1 abort + virtual int typeOfDisaster(); + //@} + + + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + CbcDisasterHandler(CbcModel * model = NULL); + /** Destructor */ + virtual ~CbcDisasterHandler(); + // Copy + CbcDisasterHandler(const CbcDisasterHandler&); + // Assignment + CbcDisasterHandler& operator=(const CbcDisasterHandler&); + /// Clone + virtual ClpDisasterHandler * clone() const; + + //@} + + /**@name Sets/gets */ + + //@{ + /** set model. */ + void setCbcModel(CbcModel * model); + /// Get model + inline CbcModel * cbcModel() const { + return cbcModel_; + } + + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Pointer to model + CbcModel * cbcModel_; + + //@} +}; +#endif + +#endif + |