summaryrefslogtreecommitdiff
path: root/thirdparty/windows/include/coin/Idiot.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/windows/include/coin/Idiot.hpp')
-rw-r--r--thirdparty/windows/include/coin/Idiot.hpp298
1 files changed, 298 insertions, 0 deletions
diff --git a/thirdparty/windows/include/coin/Idiot.hpp b/thirdparty/windows/include/coin/Idiot.hpp
new file mode 100644
index 0000000..b675c4f
--- /dev/null
+++ b/thirdparty/windows/include/coin/Idiot.hpp
@@ -0,0 +1,298 @@
+/* $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