casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpPEDualRowSteepest.hpp

@@ -0,0 +1,100 @@
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+/*
+   Authors
+
+   Jeremy Omer
+
+   Last update: april 10, 2015
+
+ */
+
+#ifndef ClpPEDualRowSteepest_H
+#define ClpPEDualRowSteepest_H
+
+#include "ClpDualRowSteepest.hpp"
+#include "ClpPESimplex.hpp"
+class CoinIndexedVector;
+
+//#############################################################################
+
+/** Dual Row Pivot Steepest Edge Algorithm Class
+
+See Forrest-Goldfarb paper for algorithm
+
+*/
+
+class ClpPEDualRowSteepest : public ClpDualRowSteepest {
+
+public:
+  /** Default Constructor
+         mode: 0 is uninitialized, 1 full, 2 is partial uninitialized,
+         3 starts as 2 but may switch to 1.
+         By partial is meant that the weights are updated as normal
+         but only part of the infeasible basic variables are scanned.
+         This can be faster on very easy problems.
+     */
+  ClpPEDualRowSteepest(double psi = 0.5, int mode = 3);
+
+  /// Copy constructor
+  ClpPEDualRowSteepest(const ClpPEDualRowSteepest &);
+
+  /// Assignment operator
+  ClpPEDualRowSteepest &operator=(const ClpPEDualRowSteepest &rhs);
+
+  /// Destructor
+  virtual ~ClpPEDualRowSteepest();
+
+  /// Clone
+  virtual ClpDualRowPivot *clone(bool copyData = true) const;
+
+public:
+  ///@name Algorithmic methods
+  //@{
+
+  /// Returns pivot row, -1 if none
+  virtual int pivotRow();
+
+  /** Save weights - this may initialize weights as well
+	 This is as parent but may initialize ClpPESimplex
+     */
+  virtual void saveWeights(ClpSimplex *model, int mode);
+  /** Updates primal solution (and maybe list of candidates)
+         Uses input vector which it deletes
+         Computes change in objective function
+	 As ordinary steepest but checks for zero moves
+     */
+  virtual void updatePrimalSolution(CoinIndexedVector *input,
+    double theta,
+    double &changeInObjective);
+  //@}
+
+  // Psi
+  inline double psi() const
+  {
+    return psi_;
+  }
+
+  //---------------------------------------------------------------------------
+
+private:
+  /* this PESimplex object is used to identify the compatible variables */
+  ClpPESimplex *modelPE_;
+
+  /* psi is the factor used in the bi-dimensional pricing, it is < 1 and
+       1/psi grows with the priority given to compatible variables */
+  double psi_;
+
+  /* useful counters for the update of the set of compatible variables */
+  int iCurrent_;
+  int iInterval_;
+
+  /* record if previous iterations concluded that compatibles should not be checked */
+  bool updateCompatibles_;
+  int coDegenCompatibles_, coConsecutiveCompatibles_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpPEPrimalColumnDantzig.hpp

@@ -0,0 +1,71 @@
+/*
+   Authors
+
+   Jeremy Omer, Mehdi Towhidi
+
+   Last update: april 10, 2015
+
+ */
+
+#ifndef ClpPEPrimalColumnDantzig_H
+#define ClpPEPrimalColumnDantzig_H
+
+#include "ClpPrimalColumnDantzig.hpp"
+#include "ClpPrimalColumnPivot.hpp"
+#include "ClpSimplex.hpp"
+#include "CoinIndexedVector.hpp"
+#include "ClpFactorization.hpp"
+#include "ClpNonLinearCost.hpp"
+#include "ClpSimplexPrimal.hpp"
+#include "ClpPackedMatrix.hpp"
+#include "ClpPESimplex.hpp"
+
+class ClpPEPrimalColumnDantzig : public ClpPrimalColumnDantzig {
+
+public:
+  /** constructors */
+  ClpPEPrimalColumnDantzig(double psi = 0.5);
+  ClpPEPrimalColumnDantzig(const ClpPEPrimalColumnDantzig &); //copy constructor
+
+  /** destructor */
+  ~ClpPEPrimalColumnDantzig();
+
+  /** assignment operator */
+  ClpPEPrimalColumnDantzig &operator=(const ClpPEPrimalColumnDantzig &rhs);
+
+  /** clone */
+  ClpPrimalColumnPivot *clone(bool copyData = true) const;
+
+  virtual int pivotColumn(CoinIndexedVector *updates,
+    CoinIndexedVector *spareRow1,
+    CoinIndexedVector *spareRow2,
+    CoinIndexedVector *spareColumn1,
+    CoinIndexedVector *spareColumn2);
+
+  //@}
+  /** Save weights - this may initialize weights as well
+	 This is as parent but may initialize ClpPESimplex
+     */
+  virtual void saveWeights(ClpSimplex *model, int mode);
+  //---------------------------------------------------------------------------
+private:
+  /* this PESimplex object is used to identify the compatible variables */
+  ClpPESimplex *modelPE_;
+
+  /* psi is the factor used in the bi-dimensional pricing, it is < 1 and
+       1/psi grows with the priority given to compatible variables */
+  double psi_;
+
+  /* useful counters for the update of the set of compatible variables */
+  int iCurrent_;
+  int iInterval_;
+
+  /* record if previous iterations concluded that compatibles should not be checked */
+  int coDegenCompatibles_;
+  int coConsecutiveCompatibles_;
+  bool updateCompatibles_;
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpPEPrimalColumnSteepest.hpp

@@ -0,0 +1,107 @@
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+/*
+   Authors
+
+   Jeremy Omer, Mehdi Towhidi
+
+   Last update: april 10, 2015
+
+ */
+
+#ifndef ClpPEPrimalColumnSteepest_H
+#define ClpPEPrimalColumnSteepest_H
+
+#include "ClpPrimalColumnSteepest.hpp"
+#include "ClpFactorization.hpp"
+#include "ClpPESimplex.hpp"
+#include <bitset>
+
+//#############################################################################
+class CoinIndexedVector;
+
+/** Primal Column Pivot Steepest Edge Algorithm Class
+
+See Forrest-Goldfarb paper for algorithm
+
+*/
+
+class ClpPEPrimalColumnSteepest : public ClpPrimalColumnSteepest {
+public:
+  ///@name Constructors and destructors
+  //@{
+  /** Default Constructor
+         0 is exact devex, 1 full steepest, 2 is partial exact devex
+         3 switches between 0 and 2 depending on factorization
+         4 starts as partial dantzig/devex but then may switch between 0 and 2.
+         By partial exact devex is meant that the weights are updated as normal
+         but only part of the nonbasic variables are scanned.
+         This can be faster on very easy problems.
+     */
+  ClpPEPrimalColumnSteepest(double psi = 0.5, int mode = 3);
+
+  /// Copy constructor
+  ClpPEPrimalColumnSteepest(const ClpPEPrimalColumnSteepest &rhs);
+
+  /// Assignment operator
+  ClpPEPrimalColumnSteepest &operator=(const ClpPEPrimalColumnSteepest &rhs);
+
+  /// Destructor
+  virtual ~ClpPEPrimalColumnSteepest();
+
+  /// Clone
+  virtual ClpPrimalColumnPivot *clone(bool copyData = true) const;
+
+public:
+  ///@name Algorithmic methods
+  //@{
+
+  /** Returns pivot column, -1 if none.
+         The Packed CoinIndexedVector updates has cost updates - for normal LP
+         that is just +-weight where a feasibility changed.  It also has
+         reduced cost from last iteration in pivot row
+         Parts of operation split out into separate functions for
+         profiling and speed
+     */
+  virtual int pivotColumn(CoinIndexedVector *updates,
+    CoinIndexedVector *spareRow1,
+    CoinIndexedVector *spareRow2,
+    CoinIndexedVector *spareColumn1,
+    CoinIndexedVector *spareColumn2);
+
+  //@}
+  /** Save weights - this may initialize weights as well
+	 This is as parent but may initialize ClpPESimplex
+     */
+  virtual void saveWeights(ClpSimplex *model, int mode);
+  /// Updates weights - as ordinary but checks for zero moves
+  virtual void updateWeights(CoinIndexedVector *input);
+  //---------------------------------------------------------------------------
+  // Psi
+  inline double psi() const
+  {
+    return psi_;
+  }
+
+private:
+  /* this PESimplex object is used to identify the compatible variables */
+  ClpPESimplex *modelPE_;
+
+  /* psi is the factor used in the bi-dimensional pricing, it is < 1 and
+       1/psi grows with the priority given to compatible variables */
+  double psi_;
+
+  /* useful counters for the update of the set of compatible variables */
+  int iCurrent_;
+  int iInterval_;
+
+  /* record if previous iterations concluded that compatibles should not be checked */
+  int coDegenCompatibles_;
+  int coConsecutiveCompatibles_;
+  bool updateCompatibles_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpPESimplex.hpp

@@ -0,0 +1,231 @@
+// Copyright (C) 2002, International Business Machines
+// Corporation and others.  All Rights Reserved.
+/*
+   Authors
+
+   Jeremy Omer
+
+   Last update: june 10, 2014
+
+ */
+
+#ifndef ClpPESimplex_H
+#define ClpPESimplex_H
+
+#include "ClpSimplex.hpp"
+#include "CoinIndexedVector.hpp"
+#include "ClpPackedMatrix.hpp"
+#include "CoinTime.hpp"
+
+#include <iostream>
+#include <fstream>
+
+// #define PE_DEBUG 0
+
+/** SHARED METHODS FOR USEFUL ALGEBRAIC OPERATIONS */
+
+/** inner product between a coin vector and a pointer */
+double PEdot(CoinIndexedVector &v1, const double *v2);
+
+/** inner product between two coin vectors
+    call the function with the sparser vector first for efficiency */
+double PEdot(CoinIndexedVector &v1, CoinIndexedVector &v2);
+
+/** compute the product x^T*[A I] for the indices "which" of [A I] */
+void PEtransposeTimesSubsetAll(ClpSimplex *model, int number, const int *which,
+  const double *COIN_RESTRICT x, double *COIN_RESTRICT y,
+  const double *COIN_RESTRICT rowScale,
+  const double *COIN_RESTRICT columnScale);
+
+/** BASE CLASS FOR THE IMPROVED SIMPLEX
+*/
+class ClpPESimplex {
+
+public:
+  /** Constructor */
+  ClpPESimplex(ClpSimplex *model);
+
+  /** Destructor */
+  ~ClpPESimplex();
+
+  /** BASIC GET METHODS */
+public:
+  inline int coPrimalDegenerates() { return coPrimalDegenerates_; }
+  inline int coDualDegenerates() { return coDualDegenerates_; }
+  inline int coCompatibleCols() { return coCompatibleCols_; }
+  inline int coCompatibleRows() { return coCompatibleRows_; }
+
+  inline bool isCompatibleCol(int sequence) { return isCompatibleCol_[sequence]; }
+  inline bool isCompatibleRow(int row)
+  {
+    assert(row >= 0 && row < numberRows_);
+    return isCompatibleRow_[row];
+  }
+
+  inline ClpSimplex *clpModel() { return model_; }
+  // check seems to be same model - returns false if size changed
+  bool checkSize();
+  /** PUBLIC METHODS RELATED TO COMPATIBILITY */
+public:
+  /** Updates the set of variables that are not at their bounds */
+  void updatePrimalDegenerates();
+
+  /** Updates the set of dual degenerate variables */
+  void updateDualDegenerates();
+
+  /** Identify the primal compatible columns
+        The input argument is a temporary array that is needed for the Clp's BTRAN */
+  void identifyCompatibleCols(int number, const int *which,
+    CoinIndexedVector *spareRow2,
+    CoinIndexedVector *wPrimal);
+
+  /** Identify the dual compatible rows */
+  void identifyCompatibleRows(CoinIndexedVector *spare,
+    CoinIndexedVector *wDual);
+
+  /** Update the dual compatible rows */
+  void updateCompatibleRows(int sequence);
+
+  /** DEBUG AND DISPLAY METHODS */
+public:
+#if PE_DEBUG >= 1
+  /** Print the set of variables within their bounds */
+  void printPrimalDegenerates();
+
+  /** Print the set of primal compatible variables */
+  void printCompatibleCols();
+
+  /** Check that a nonbasic variable is indeed compatible */
+  bool checkCompatibilityCol(int sequence, CoinIndexedVector *spareRow2);
+#endif
+
+  /** Check that a basic row is indeed compatible */
+  bool checkCompatibilityRow(int pivotRow);
+
+  /** Tracking the degenerate iterations after compatible pivots */
+  inline double lastObjectiveValue() { return lastObjectiveValue_; }
+  inline void updateLastObjectiveValue() { lastObjectiveValue_ = model_->objectiveValue(); }
+  inline bool isDegeneratePivot() { return fabs(model_->objectiveValue() - lastObjectiveValue_) < model_->dualTolerance(); }
+  inline bool isLastPivotCompatible() { return isLastPivotCompatible_; }
+  inline void isLastPivotCompatible(bool yesOrNo) { isLastPivotCompatible_ = yesOrNo; }
+
+  /** Start and stop the timer, and print the total recorded time */
+  inline void startTimer() { timeTmp_ = CoinCpuTime(); }
+  inline void stopTimer() { timeCompatibility_ += CoinCpuTime() - timeTmp_; }
+  void printTimer(std::ostream &out);
+  inline double timeMultRandom() { return timeMultRandom_; }
+  inline double timeLinearSystem() { return timeLinearSystem_; }
+  inline double timeCompatibility() { return timeCompatibility_; }
+
+  /** Update and return the number of degenerate pivots and variables */
+  inline void addDegeneratePivot() { coDegeneratePivots_++; }
+  inline int coDegeneratePivots() { return coDegeneratePivots_; }
+  inline void addDegeneratePivotConsecutive() { coDegeneratePivotsConsecutive_++; }
+  inline void resetDegeneratePivotsConsecutive() { coDegeneratePivotsConsecutive_ = 0; }
+  inline int coDegeneratePivotsConsecutive() { return coDegeneratePivotsConsecutive_; }
+  void updateDualDegeneratesAvg(int coPivots);
+  inline double coDualDegeneratesAvg() { return coDualDegeneratesAvg_; }
+  void updatePrimalDegeneratesAvg(int coPivots);
+  inline double coPrimalDegeneratesAvg() { return coPrimalDegeneratesAvg_; }
+  inline double coCompatibleRowsAvg() { return coCompatibleRowsAvg_; }
+  void updateCompatibleRowsAvg(int coPivots);
+  inline double coCompatibleColsAvg() { return coCompatibleColsAvg_; }
+  void updateCompatibleColsAvg(int coPivots);
+  inline int coCompatiblePivots() { return coCompatiblePivots_; }
+  inline void addCompatiblePivot() { coCompatiblePivots_++; }
+  inline int coDegenerateCompatiblePivots() { return coDegenerateCompatiblePivots_; }
+  inline void addDegenerateCompatiblePivot() { coDegenerateCompatiblePivots_++; }
+
+  /* Get and update the number of compatible pivots that were done because of the priority factor */
+  inline void addPriorityPivot() { coPriorityPivots_++; }
+  inline int coPriorityPivots() { return coPriorityPivots_; }
+  inline int doStatistics() const
+  {
+    return doStatistics_;
+  }
+  inline void setDoStatistics(int value)
+  {
+    doStatistics_ = value;
+  }
+
+protected:
+  /** Indices of the variables that were not at one of their bounds 
+        during the last update (non primal degenerate variables) */
+  int coPrimalDegenerates_;
+  int *primalDegenerates_;
+  bool *isPrimalDegenerate_;
+
+  /** Indices of the non basic variables with a zero reduced cost
+        during the last update (ndual-degenerate variables) */
+  int coDualDegenerates_;
+  int *dualDegenerates_;
+  bool *isDualDegenerate_;
+
+  /** Table of booleans indicating whether each variable is primal
+        compatible (true) or not (false) */
+  int coCompatibleCols_;
+  double *compatibilityCol_;
+  bool *isCompatibleCol_;
+
+  /** Table of booleans indicating whether each constraint is dual
+        compatible (true) or not (false) */
+  int coCompatibleRows_;
+  double *compatibilityRow_;
+  bool *isCompatibleRow_;
+
+private:
+  /** pointer to the original model that shall be solved */
+  ClpSimplex *model_;
+
+  /** tolerance used for the tests of degeneracy and compatibility (resp.) */
+  double epsDegeneracy_;
+  double epsCompatibility_;
+
+  /** size of the original model */
+  int numberRows_;
+  int numberColumns_;
+
+  /** w vectors that are used to identify the compatible columns and
+    rows. The name w, refers to the notations of the articles on 
+    positive edge */
+  // now passed in CoinIndexedVector *wPrimal_;
+  // now passed in CoinIndexedVector *wDual_;
+
+  /** temporary vectors that are used to store colulns of the constraint
+        matrix or random numbers */
+  // not usedCoinIndexedVector *tempColumn_;
+  double *tempRandom_;
+
+  /** number of degenerate pivots and variables */
+  int coPrimalDegeneratesAvg_;
+  int coDualDegeneratesAvg_;
+  int coCompatibleColsAvg_;
+  int coCompatibleRowsAvg_;
+  int coUpdateDegenerates_;
+  //int coIdentifyCompatibles_;
+  int coDegeneratePivots_;
+  int coCompatiblePivots_;
+  int coDegenerateCompatiblePivots_;
+  int coDegeneratePivotsConsecutive_;
+
+  /** number of compatible pivots that were done because of the priority factor */
+  int coPriorityPivots_;
+  /// Do statistics
+  int doStatistics_;
+
+  /** tracking the degenerate iterations after compatible pivots */
+  double lastObjectiveValue_;
+  bool isLastPivotCompatible_;
+
+  /** Timer attribute recording the additional time spent in 
+        identifying compatible variables */
+  double timeCompatibility_;
+  double timeMultRandom_;
+  double timeLinearSystem_;
+  double timeTmp_;
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/