diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/Idiot.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/Idiot.hpp | 298 |
1 files changed, 0 insertions, 298 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/Idiot.hpp b/newstructure/thirdparty/linux/include/coin/Idiot.hpp deleted file mode 100644 index b675c4f..0000000 --- a/newstructure/thirdparty/linux/include/coin/Idiot.hpp +++ /dev/null @@ -1,298 +0,0 @@ -/* $Id: Idiot.hpp 2143 2015-05-20 15:49:17Z forrest $ */ -// Copyright (C) 2002, International Business Machines -// Corporation and others. All Rights Reserved. -// This code is licensed under the terms of the Eclipse Public License (EPL). - -// "Idiot" as the name of this algorithm is copylefted. If you want to change -// the name then it should be something equally stupid (but not "Stupid") or -// even better something witty. - -#ifndef Idiot_H -#define Idiot_H -#ifndef OSI_IDIOT -#include "ClpSimplex.hpp" -#define OsiSolverInterface ClpSimplex -#else -#include "OsiSolverInterface.hpp" -typedef int CoinBigIndex; -#endif -class CoinMessageHandler; -class CoinMessages; -/// for use internally -typedef struct { - double infeas; - double objval; - double dropThis; - double weighted; - double sumSquared; - double djAtBeginning; - double djAtEnd; - int iteration; -} IdiotResult; -/** This class implements a very silly algorithm. It has no merit - apart from the fact that it gets an approximate solution to - some classes of problems. Better if vaguely homogeneous. - It works on problems where volume algorithm works and often - gets a better primal solution but it has no dual solution. - - It can also be used as a "crash" to get a problem started. This - is probably its most useful function. - - It is based on the idea that algorithms with terrible convergence - properties may be okay at first. Throw in some random dubious tricks - and the resulting code may be worth keeping as long as you don't - look at it. - -*/ - -class Idiot { - -public: - - /**@name Constructors and destructor - Just a pointer to model is kept - */ - //@{ - /// Default constructor - Idiot ( ); - /// Constructor with model - Idiot ( OsiSolverInterface & model ); - - /// Copy constructor. - Idiot(const Idiot &); - /// Assignment operator. This copies the data - Idiot & operator=(const Idiot & rhs); - /// Destructor - ~Idiot ( ); - //@} - - - /**@name Algorithmic calls - */ - //@{ - /// Get an approximate solution with the idiot code - void solve(); - /// Lightweight "crash" - void crash(int numberPass, CoinMessageHandler * handler, - const CoinMessages * messages, bool doCrossover = true); - /** Use simplex to get an optimal solution - mode is how many steps the simplex crossover should take to - arrive to an extreme point: - 0 - chosen,all ever used, all - 1 - chosen, all - 2 - all - 3 - do not do anything - maybe basis - + 16 do presolves - */ - void crossOver(int mode); - //@} - - - /**@name Gets and sets of most useful data - */ - //@{ - /** Starting weight - small emphasizes feasibility, - default 1.0e-4 */ - inline double getStartingWeight() const { - return mu_; - } - inline void setStartingWeight(double value) { - mu_ = value; - } - /** Weight factor - weight multiplied by this when changes, - default 0.333 */ - inline double getWeightFactor() const { - return muFactor_; - } - inline void setWeightFactor(double value) { - muFactor_ = value; - } - /** Feasibility tolerance - problem essentially feasible if - individual infeasibilities less than this. - default 0.1 */ - inline double getFeasibilityTolerance() const { - return smallInfeas_; - } - inline void setFeasibilityTolerance(double value) { - smallInfeas_ = value; - } - /** Reasonably feasible. Dubious method concentrates more on - objective when sum of infeasibilities less than this. - Very dubious default value of (Number of rows)/20 */ - inline double getReasonablyFeasible() const { - return reasonableInfeas_; - } - inline void setReasonablyFeasible(double value) { - reasonableInfeas_ = value; - } - /** Exit infeasibility - exit if sum of infeasibilities less than this. - Default -1.0 (i.e. switched off) */ - inline double getExitInfeasibility() const { - return exitFeasibility_; - } - inline void setExitInfeasibility(double value) { - exitFeasibility_ = value; - } - /** Major iterations. stop after this number. - Default 30. Use 2-5 for "crash" 50-100 for serious crunching */ - inline int getMajorIterations() const { - return majorIterations_; - } - inline void setMajorIterations(int value) { - majorIterations_ = value; - } - /** Minor iterations. Do this number of tiny steps before - deciding whether to change weights etc. - Default - dubious sqrt(Number of Rows). - Good numbers 105 to 405 say (5 is dubious method of making sure - idiot is not trying to be clever which it may do every 10 minor - iterations) */ - inline int getMinorIterations() const { - return maxIts2_; - } - inline void setMinorIterations(int value) { - maxIts2_ = value; - } - // minor iterations for first time - inline int getMinorIterations0() const { - return maxIts_; - } - inline void setMinorIterations0(int value) { - maxIts_ = value; - } - /** Reduce weight after this many major iterations. It may - get reduced before this but this is a maximum. - Default 3. 3-10 plausible. */ - inline int getReduceIterations() const { - return maxBigIts_; - } - inline void setReduceIterations(int value) { - maxBigIts_ = value; - } - /// Amount of information - default of 1 should be okay - inline int getLogLevel() const { - return logLevel_; - } - inline void setLogLevel(int value) { - logLevel_ = value; - } - /// How lightweight - 0 not, 1 yes, 2 very lightweight - inline int getLightweight() const { - return lightWeight_; - } - inline void setLightweight(int value) { - lightWeight_ = value; - } - /// strategy - inline int getStrategy() const { - return strategy_; - } - inline void setStrategy(int value) { - strategy_ = value; - } - /// Fine tuning - okay if feasibility drop this factor - inline double getDropEnoughFeasibility() const { - return dropEnoughFeasibility_; - } - inline void setDropEnoughFeasibility(double value) { - dropEnoughFeasibility_ = value; - } - /// Fine tuning - okay if weighted obj drop this factor - inline double getDropEnoughWeighted() const { - return dropEnoughWeighted_; - } - inline void setDropEnoughWeighted(double value) { - dropEnoughWeighted_ = value; - } - /// Set model - inline void setModel(OsiSolverInterface * model) { - model_ = model; - }; - //@} - - -/// Stuff for internal use -private: - - /// Does actual work - // allow public! -public: - void solve2(CoinMessageHandler * handler, const CoinMessages *messages); -private: - IdiotResult IdiSolve( - int nrows, int ncols, double * rowsol , double * colsol, - double * pi, double * djs, const double * origcost , - double * rowlower, - double * rowupper, const double * lower, - const double * upper, const double * element, - const int * row, const CoinBigIndex * colcc, - const int * length, double * lambda, - int maxIts, double mu, double drop, - double maxmin, double offset, - int strategy, double djTol, double djExit, double djFlag, - CoinThreadRandom * randomNumberGenerator); - int dropping(IdiotResult result, - double tolerance, - double small, - int *nbad); - IdiotResult objval(int nrows, int ncols, double * rowsol , double * colsol, - double * pi, double * djs, const double * cost , - const double * rowlower, - const double * rowupper, const double * lower, - const double * upper, const double * elemnt, - const int * row, const CoinBigIndex * columnStart, - const int * length, int extraBlock, int * rowExtra, - double * solExtra, double * elemExtra, double * upperExtra, - double * costExtra, double weight); - // Deals with whenUsed and slacks - int cleanIteration(int iteration, int ordinaryStart, int ordinaryEnd, - double * colsol, const double * lower, const double * upper, - const double * rowLower, const double * rowUpper, - const double * cost, const double * element, double fixTolerance, double & objChange, - double & infChange, double & maxInfeasibility); -private: - /// Underlying model - OsiSolverInterface * model_; - - double djTolerance_; - double mu_; /* starting mu */ - double drop_; /* exit if drop over 5 checks less than this */ - double muFactor_; /* reduce mu by this */ - double stopMu_; /* exit if mu gets smaller than this */ - double smallInfeas_; /* feasibility tolerance */ - double reasonableInfeas_; /* use lambdas if feasibility less than this */ - double exitDrop_; /* candidate for stopping after a major iteration */ - double muAtExit_; /* mu on exit */ - double exitFeasibility_; /* exit if infeasibility less than this */ - double dropEnoughFeasibility_; /* okay if feasibility drop this factor */ - double dropEnoughWeighted_; /* okay if weighted obj drop this factor */ - int * whenUsed_; /* array to say what was used */ - int maxBigIts_; /* always reduce mu after this */ - int maxIts_; /* do this many iterations on first go */ - int majorIterations_; - int logLevel_; - int logFreq_; - int checkFrequency_; /* can exit after 5 * this iterations (on drop) */ - int lambdaIterations_; /* do at least this many lambda iterations */ - int maxIts2_; /* do this many iterations on subsequent goes */ - int strategy_; /* 0 - default strategy - 1 - do accelerator step but be cautious - 2 - do not do accelerator step - 4 - drop, exitDrop and djTolerance all relative - 8 - keep accelerator step to theta=10.0 - - 32 - Scale - 512 - crossover - 2048 - keep lambda across mu change - 4096 - return best solution (not last found) - 8192 - always do a presolve in crossover - 16384 - costed slacks found - so whenUsed_ longer - 32768 - experimental 1 - 65536 - experimental 2 - 131072 - experimental 3 - 262144 - just values pass etc - 524288 - don't treat structural slacks as slacks */ - - int lightWeight_; // 0 - normal, 1 lightweight -}; -#endif |