casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/Idiot.hpp

@@ -0,0 +1,327 @@
+/* $Id$ */
+// 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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/OsiAuxInfo.hpp

@@ -0,0 +1,261 @@
+// 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 OsiAuxInfo_H
+#define OsiAuxInfo_H
+
+class OsiSolverInterface;
+
+//#############################################################################
+/** This class allows for a more structured use of algorithmic tweaking to
+    an OsiSolverInterface.  It is designed to replace the simple use of
+    appData_ pointer.
+
+    This has been done to make it easier to use NonLinear solvers and other
+    exotic beasts in a branch and bound mode.  After this class definition
+    there is one for a derived class for just such a purpose.
+
+*/
+
+class OsiAuxInfo {
+public:
+  // Default Constructor
+  OsiAuxInfo(void *appData = NULL);
+
+  // Copy Constructor
+  OsiAuxInfo(const OsiAuxInfo &rhs);
+  // Destructor
+  virtual ~OsiAuxInfo();
+
+  /// Clone
+  virtual OsiAuxInfo *clone() const;
+  /// Assignment operator
+  OsiAuxInfo &operator=(const OsiAuxInfo &rhs);
+
+  /// Get application data
+  inline void *getApplicationData() const
+  {
+    return appData_;
+  }
+
+protected:
+  /// Pointer to user-defined data structure
+  void *appData_;
+};
+//#############################################################################
+/** This class allows for the use of more exotic solvers e.g. Non-Linear or Volume.
+
+    You can derive from this although at present I can't see the need.
+*/
+
+class OsiBabSolver : public OsiAuxInfo {
+public:
+  // Default Constructor
+  OsiBabSolver(int solverType = 0);
+
+  // Copy Constructor
+  OsiBabSolver(const OsiBabSolver &rhs);
+  // Destructor
+  virtual ~OsiBabSolver();
+
+  /// Clone
+  virtual OsiAuxInfo *clone() const;
+  /// Assignment operator
+  OsiBabSolver &operator=(const OsiBabSolver &rhs);
+
+  /// Update solver
+  inline void setSolver(const OsiSolverInterface *solver)
+  {
+    solver_ = solver;
+  }
+  /// Update solver
+  inline void setSolver(const OsiSolverInterface &solver)
+  {
+    solver_ = &solver;
+  }
+
+  /** returns 0 if no heuristic solution, 1 if valid solution
+      with better objective value than one passed in
+      Sets solution values if good, sets objective value 
+      numberColumns is size of newSolution
+  */
+  int solution(double &objectiveValue,
+    double *newSolution, int numberColumns);
+  /** Set solution and objective value.
+      Number of columns and optimization direction taken from current solver.
+      Size of solution is numberColumns (may be padded or truncated in function) */
+  void setSolution(const double *solution, int numberColumns, double objectiveValue);
+
+  /** returns true if the object stores a solution, false otherwise. If there
+	  is a solution then solutionValue and solution will be filled out as well.
+      In that case the user needs to allocate solution to be a big enough
+	  array.
+  */
+  bool hasSolution(double &solutionValue, double *solution);
+
+  /** Sets solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check solver to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+      4 - normal solver but cuts are needed for integral solution    
+  */
+  inline void setSolverType(int value)
+  {
+    solverType_ = value;
+  }
+  /** gets solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+      4 - normal solver but cuts are needed for integral solution    
+  */
+  inline int solverType() const
+  {
+    return solverType_;
+  }
+  /** Return true if getting solution may add cuts so hot start etc will
+      be obsolete */
+  inline bool solutionAddsCuts() const
+  {
+    return solverType_ == 3;
+  }
+  /// Return true if we should try cuts at root even if looks satisfied
+  inline bool alwaysTryCutsAtRootNode() const
+  {
+    return solverType_ == 4;
+  }
+  /** Returns true if can use solver objective or feasible values,
+      otherwise use mipBound etc */
+  inline bool solverAccurate() const
+  {
+    return solverType_ == 0 || solverType_ == 2 || solverType_ == 4;
+  }
+  /// Returns true if can use reduced costs for fixing
+  inline bool reducedCostsAccurate() const
+  {
+    return solverType_ == 0 || solverType_ == 4;
+  }
+  /// Get objective  (well mip bound)
+  double mipBound() const;
+  /// Returns true if node feasible
+  bool mipFeasible() const;
+  /// Set mip bound (only used for some solvers)
+  inline void setMipBound(double value)
+  {
+    mipBound_ = value;
+  }
+  /// Get objective value of saved solution
+  inline double bestObjectiveValue() const
+  {
+    return bestObjectiveValue_;
+  }
+  /// Says whether we want to try cuts at all
+  inline bool tryCuts() const
+  {
+    return solverType_ != 2;
+  }
+  /// Says whether we have a warm start (so can do strong branching)
+  inline bool warmStart() const
+  {
+    return solverType_ != 2;
+  }
+  /** Get bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  inline int extraCharacteristics() const
+  {
+    return extraCharacteristics_;
+  }
+  /** Set bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  inline void setExtraCharacteristics(int value)
+  {
+    extraCharacteristics_ = value;
+  }
+  /// Pointer to lower bounds before branch (only if extraCharacteristics set)
+  inline const double *beforeLower() const
+  {
+    return beforeLower_;
+  }
+  /// Set pointer to lower bounds before branch (only if extraCharacteristics set)
+  inline void setBeforeLower(const double *array)
+  {
+    beforeLower_ = array;
+  }
+  /// Pointer to upper bounds before branch (only if extraCharacteristics set)
+  inline const double *beforeUpper() const
+  {
+    return beforeUpper_;
+  }
+  /// Set pointer to upper bounds before branch (only if extraCharacteristics set)
+  inline void setBeforeUpper(const double *array)
+  {
+    beforeUpper_ = array;
+  }
+  /// Set pointer to extra stuff
+  inline void setExtraPointer(void *extraInfo)
+  {
+    extraInfo_ = extraInfo;
+  }
+  /// get pointer to extra info
+  inline void *getExtraPointer() const
+  {
+    return extraInfo_;
+  }
+
+protected:
+  /// Objective value of best solution (if there is one) (minimization)
+  double bestObjectiveValue_;
+  /// Current lower bound on solution ( if > 1.0e50 infeasible)
+  double mipBound_;
+  /// Solver to use for getting/setting solutions etc
+  const OsiSolverInterface *solver_;
+  /// Best integer feasible solution
+  double *bestSolution_;
+  /// Pointer to lower bounds before branch (only if extraCharacteristics set)
+  const double *beforeLower_;
+  /// Pointer to upper bounds before branch (only if extraCharacteristics set)
+  const double *beforeUpper_;
+  /// Pointer to extra info
+  void *extraInfo_;
+  /** Solver type
+      0 - normal LP solver
+      1 - DW - may also return heuristic solutions
+      2 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is
+          - may also return heuristic solution
+      3 - NLP solver or similar - can't compute objective value just from solution
+          check this (rather than solver) to see if feasible and what objective value is.
+          Using Outer Approximation so called lp based
+          - may also return heuristic solution
+  */
+  int solverType_;
+  /// Size of solution
+  int sizeSolution_;
+  /** Bit mask for odd actions of solvers
+      1 - solution or bound arrays may move in mysterious ways e.g. cplex
+      2 - solver may want bounds before branch
+  */
+  int extraCharacteristics_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/