casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/coin/ClpSolve.hpp

@@ -0,0 +1,505 @@
+/* $Id$ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+/*
+   Authors
+
+   John Forrest
+
+ */
+#ifndef ClpSolve_H
+#define ClpSolve_H
+
+/**
+    This is a very simple class to guide algorithms.  It is used to tidy up
+    passing parameters to initialSolve and maybe for output from that
+
+*/
+
+class ClpSolve {
+
+public:
+  /** enums for solve function */
+  enum SolveType {
+    useDual = 0,
+    usePrimal,
+    usePrimalorSprint,
+    useBarrier,
+    useBarrierNoCross,
+    automatic,
+    tryDantzigWolfe,
+    tryBenders,
+    notImplemented
+  };
+  enum PresolveType {
+    presolveOn = 0,
+    presolveOff,
+    presolveNumber,
+    presolveNumberCost
+  };
+
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  ClpSolve();
+  /// Constructor when you really know what you are doing
+  ClpSolve(SolveType method, PresolveType presolveType,
+    int numberPasses, int options[6],
+    int extraInfo[6], int independentOptions[3]);
+  /// Generates code for above constructor
+  void generateCpp(FILE *fp);
+  /// Copy constructor.
+  ClpSolve(const ClpSolve &);
+  /// Assignment operator. This copies the data
+  ClpSolve &operator=(const ClpSolve &rhs);
+  /// Destructor
+  ~ClpSolve();
+  //@}
+
+  /**@name Functions most useful to user */
+  //@{
+  /** Special options - bits
+     0      4 - use crash (default allslack in dual, idiot in primal)
+         8 - all slack basis in primal
+     2      16 - switch off interrupt handling
+     3      32 - do not try and make plus minus one matrix
+         64 - do not use sprint even if problem looks good
+      */
+  /** which translation is:
+         which:
+         0 - startup in Dual  (nothing if basis exists).:
+                      0 - no basis
+       	   1 - crash
+       	   2 - use initiative about idiot! but no crash
+         1 - startup in Primal (nothing if basis exists):
+                      0 - use initiative
+       	   1 - use crash
+       	   2 - use idiot and look at further info
+       	   3 - use sprint and look at further info
+       	   4 - use all slack
+       	   5 - use initiative but no idiot
+       	   6 - use initiative but no sprint
+       	   7 - use initiative but no crash
+                      8 - do allslack or idiot
+                      9 - do allslack or sprint
+       	   10 - slp before
+       	   11 - no nothing and primal(0)
+         2 - interrupt handling - 0 yes, 1 no (for threadsafe)
+         3 - whether to make +- 1matrix - 0 yes, 1 no
+         4 - for barrier
+                      0 - dense cholesky
+       	   1 - Wssmp allowing some long columns
+       	   2 - Wssmp not allowing long columns
+       	   3 - Wssmp using KKT
+                      4 - Using Florida ordering
+       	   8 - bit set to do scaling
+       	   16 - set to be aggressive with gamma/delta?
+                      32 - Use KKT
+         5 - for presolve
+                      1 - switch off dual stuff
+         6 - extra switches
+                      
+     */
+  void setSpecialOption(int which, int value, int extraInfo = -1);
+  int getSpecialOption(int which) const;
+
+  /// Solve types
+  void setSolveType(SolveType method, int extraInfo = -1);
+  SolveType getSolveType();
+
+  // Presolve types
+  void setPresolveType(PresolveType amount, int extraInfo = -1);
+  PresolveType getPresolveType();
+  int getPresolvePasses() const;
+  /// Extra info for idiot (or sprint)
+  int getExtraInfo(int which) const;
+  /** Say to return at once if infeasible,
+         default is to solve */
+  void setInfeasibleReturn(bool trueFalse);
+  inline bool infeasibleReturn() const
+  {
+    return independentOptions_[0] != 0;
+  }
+  /// Whether we want to do dual part of presolve
+  inline bool doDual() const
+  {
+    return (independentOptions_[1] & 1) == 0;
+  }
+  inline void setDoDual(bool doDual_)
+  {
+    if (doDual_)
+      independentOptions_[1] &= ~1;
+    else
+      independentOptions_[1] |= 1;
+  }
+  /// Whether we want to do singleton part of presolve
+  inline bool doSingleton() const
+  {
+    return (independentOptions_[1] & 2) == 0;
+  }
+  inline void setDoSingleton(bool doSingleton_)
+  {
+    if (doSingleton_)
+      independentOptions_[1] &= ~2;
+    else
+      independentOptions_[1] |= 2;
+  }
+  /// Whether we want to do doubleton part of presolve
+  inline bool doDoubleton() const
+  {
+    return (independentOptions_[1] & 4) == 0;
+  }
+  inline void setDoDoubleton(bool doDoubleton_)
+  {
+    if (doDoubleton_)
+      independentOptions_[1] &= ~4;
+    else
+      independentOptions_[1] |= 4;
+  }
+  /// Whether we want to do tripleton part of presolve
+  inline bool doTripleton() const
+  {
+    return (independentOptions_[1] & 8) == 0;
+  }
+  inline void setDoTripleton(bool doTripleton_)
+  {
+    if (doTripleton_)
+      independentOptions_[1] &= ~8;
+    else
+      independentOptions_[1] |= 8;
+  }
+  /// Whether we want to do tighten part of presolve
+  inline bool doTighten() const
+  {
+    return (independentOptions_[1] & 16) == 0;
+  }
+  inline void setDoTighten(bool doTighten_)
+  {
+    if (doTighten_)
+      independentOptions_[1] &= ~16;
+    else
+      independentOptions_[1] |= 16;
+  }
+  /// Whether we want to do forcing part of presolve
+  inline bool doForcing() const
+  {
+    return (independentOptions_[1] & 32) == 0;
+  }
+  inline void setDoForcing(bool doForcing_)
+  {
+    if (doForcing_)
+      independentOptions_[1] &= ~32;
+    else
+      independentOptions_[1] |= 32;
+  }
+  /// Whether we want to do impliedfree part of presolve
+  inline bool doImpliedFree() const
+  {
+    return (independentOptions_[1] & 64) == 0;
+  }
+  inline void setDoImpliedFree(bool doImpliedfree)
+  {
+    if (doImpliedfree)
+      independentOptions_[1] &= ~64;
+    else
+      independentOptions_[1] |= 64;
+  }
+  /// Whether we want to do dupcol part of presolve
+  inline bool doDupcol() const
+  {
+    return (independentOptions_[1] & 128) == 0;
+  }
+  inline void setDoDupcol(bool doDupcol_)
+  {
+    if (doDupcol_)
+      independentOptions_[1] &= ~128;
+    else
+      independentOptions_[1] |= 128;
+  }
+  /// Whether we want to do duprow part of presolve
+  inline bool doDuprow() const
+  {
+    return (independentOptions_[1] & 256) == 0;
+  }
+  inline void setDoDuprow(bool doDuprow_)
+  {
+    if (doDuprow_)
+      independentOptions_[1] &= ~256;
+    else
+      independentOptions_[1] |= 256;
+  }
+  /// Whether we want to do singleton column part of presolve
+  inline bool doSingletonColumn() const
+  {
+    return (independentOptions_[1] & 512) == 0;
+  }
+  inline void setDoSingletonColumn(bool doSingleton_)
+  {
+    if (doSingleton_)
+      independentOptions_[1] &= ~512;
+    else
+      independentOptions_[1] |= 512;
+  }
+  /// Whether we want to kill small substitutions
+  inline bool doKillSmall() const
+  {
+    return (independentOptions_[1] & 8192) == 0;
+  }
+  inline void setDoKillSmall(bool doKill)
+  {
+    if (doKill)
+      independentOptions_[1] &= ~8192;
+    else
+      independentOptions_[1] |= 8192;
+  }
+  /// Set whole group
+  inline int presolveActions() const
+  {
+    return independentOptions_[1] & 0xffffff;
+  }
+  inline void setPresolveActions(int action)
+  {
+    independentOptions_[1] = (independentOptions_[1] & 0xff000000) | (action & 0xffffff);
+  }
+  /// Largest column for substitution (normally 3)
+  inline int substitution() const
+  {
+    return independentOptions_[2];
+  }
+  inline void setSubstitution(int value)
+  {
+    independentOptions_[2] = value;
+  }
+  inline void setIndependentOption(int type, int value)
+  {
+    independentOptions_[type] = value;
+  }
+  inline int independentOption(int type) const
+  {
+    return independentOptions_[type];
+  }
+  //@}
+
+  ////////////////// data //////////////////
+private:
+  /**@name data.
+     */
+  //@{
+  /// Solve type
+  SolveType method_;
+  /// Presolve type
+  PresolveType presolveType_;
+  /// Amount of presolve
+  int numberPasses_;
+  /// Options - last is switch for OsiClp
+  int options_[7];
+  /// Extra information
+  int extraInfo_[7];
+  /** Extra algorithm dependent options
+         0 - if set return from clpsolve if infeasible
+         1 - To be copied over to presolve options
+         2 - max substitution level
+	 If Dantzig Wolfe/benders 0 is number blocks, 2 is #passes (notional)
+     */
+  int independentOptions_[3];
+  //@}
+};
+
+/// For saving extra information to see if looping.
+class ClpSimplexProgress {
+
+public:
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  ClpSimplexProgress();
+
+  /// Constructor from model
+  ClpSimplexProgress(ClpSimplex *model);
+
+  /// Copy constructor.
+  ClpSimplexProgress(const ClpSimplexProgress &);
+
+  /// Assignment operator. This copies the data
+  ClpSimplexProgress &operator=(const ClpSimplexProgress &rhs);
+  /// Destructor
+  ~ClpSimplexProgress();
+  /// Resets as much as possible
+  void reset();
+  /// Fill from model
+  void fillFromModel(ClpSimplex *model);
+
+  //@}
+
+  /**@name Check progress */
+  //@{
+  /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
+         >=0 if give up and use as problem status
+     */
+  int looping();
+  /// Start check at beginning of whileIterating
+  void startCheck();
+  /// Returns cycle length in whileIterating
+  int cycle(int in, int out, int wayIn, int wayOut);
+
+  /// Returns previous objective (if -1) - current if (0)
+  double lastObjective(int back = 1) const;
+  /// Set real primal infeasibility and move back
+  void setInfeasibility(double value);
+  /// Returns real primal infeasibility (if -1) - current if (0)
+  double lastInfeasibility(int back = 1) const;
+  /// Returns number of primal infeasibilities (if -1) - current if (0)
+  int numberInfeasibilities(int back = 1) const;
+  /// Modify objective e.g. if dual infeasible in dual
+  void modifyObjective(double value);
+  /// Returns previous iteration number (if -1) - current if (0)
+  int lastIterationNumber(int back = 1) const;
+  /// clears all iteration numbers (to switch off panic)
+  void clearIterationNumbers();
+  /// Odd state
+  inline void newOddState()
+  {
+    oddState_ = -oddState_ - 1;
+  }
+  inline void endOddState()
+  {
+    oddState_ = abs(oddState_);
+  }
+  inline void clearOddState()
+  {
+    oddState_ = 0;
+  }
+  inline int oddState() const
+  {
+    return oddState_;
+  }
+  /// number of bad times
+  inline int badTimes() const
+  {
+    return numberBadTimes_;
+  }
+  inline void clearBadTimes()
+  {
+    numberBadTimes_ = 0;
+  }
+  /// number of really bad times
+  inline int reallyBadTimes() const
+  {
+    return numberReallyBadTimes_;
+  }
+  inline void incrementReallyBadTimes()
+  {
+    numberReallyBadTimes_++;
+  }
+  /// number of times flagged
+  inline int timesFlagged() const
+  {
+    return numberTimesFlagged_;
+  }
+  inline void clearTimesFlagged()
+  {
+    numberTimesFlagged_ = 0;
+  }
+  inline void incrementTimesFlagged()
+  {
+    numberTimesFlagged_++;
+  }
+
+  //@}
+  /**@name Data  */
+#define CLP_PROGRESS 5
+  //#define CLP_PROGRESS_WEIGHT 10
+  //@{
+  /// Objective values
+  double objective_[CLP_PROGRESS];
+  /// Sum of infeasibilities for algorithm
+  double infeasibility_[CLP_PROGRESS];
+  /// Sum of real primal infeasibilities for primal
+  double realInfeasibility_[CLP_PROGRESS];
+#ifdef CLP_PROGRESS_WEIGHT
+  /// Objective values for weights
+  double objectiveWeight_[CLP_PROGRESS_WEIGHT];
+  /// Sum of infeasibilities for algorithm for weights
+  double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
+  /// Sum of real primal infeasibilities for primal for weights
+  double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
+  /// Drop  for weights
+  double drop_;
+  /// Best? for weights
+  double best_;
+#endif
+  /// Initial weight for weights
+  double initialWeight_;
+#define CLP_CYCLE 12
+  /// For cycle checking
+  //double obj_[CLP_CYCLE];
+  int in_[CLP_CYCLE];
+  int out_[CLP_CYCLE];
+  char way_[CLP_CYCLE];
+  /// Pointer back to model so we can get information
+  ClpSimplex *model_;
+  /// Number of infeasibilities
+  int numberInfeasibilities_[CLP_PROGRESS];
+  /// Iteration number at which occurred
+  int iterationNumber_[CLP_PROGRESS];
+#ifdef CLP_PROGRESS_WEIGHT
+  /// Number of infeasibilities for weights
+  int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
+  /// Iteration number at which occurred for weights
+  int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
+#endif
+  /// Number of times checked (so won't stop too early)
+  int numberTimes_;
+  /// Number of times it looked like loop
+  int numberBadTimes_;
+  /// Number really bad times
+  int numberReallyBadTimes_;
+  /// Number of times no iterations as flagged
+  int numberTimesFlagged_;
+  /// If things are in an odd state
+  int oddState_;
+  //@}
+};
+
+#include "ClpConfig.h"
+#if CLP_HAS_ABC
+#include "AbcCommon.hpp"
+/// For saving extra information to see if looping.
+class AbcSimplexProgress : public ClpSimplexProgress {
+
+public:
+  /**@name Constructors and destructor and copy */
+  //@{
+  /// Default constructor
+  AbcSimplexProgress();
+
+  /// Constructor from model
+  AbcSimplexProgress(ClpSimplex *model);
+
+  /// Copy constructor.
+  AbcSimplexProgress(const AbcSimplexProgress &);
+
+  /// Assignment operator. This copies the data
+  AbcSimplexProgress &operator=(const AbcSimplexProgress &rhs);
+  /// Destructor
+  ~AbcSimplexProgress();
+
+  //@}
+
+  /**@name Check progress */
+  //@{
+  /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
+         >=0 if give up and use as problem status
+     */
+  int looping();
+
+  //@}
+  /**@name Data  */
+  //@}
+};
+#endif
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/