casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpDualRowPivot.hpp

@@ -0,0 +1,136 @@
+/* $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).
+
+#ifndef ClpDualRowPivot_H
+#define ClpDualRowPivot_H
+
+class ClpSimplex;
+class CoinIndexedVector;
+
+//#############################################################################
+
+/** Dual Row Pivot Abstract Base Class
+
+Abstract Base Class for describing an interface to an algorithm
+to choose row pivot in dual simplex algorithm.  For some algorithms
+e.g. Dantzig choice then some functions may be null.
+
+*/
+
+class ClpDualRowPivot {
+
+public:
+  ///@name Algorithmic methods
+  //@{
+
+  /// Returns pivot row, -1 if none
+  virtual int pivotRow() = 0;
+
+  /** Updates weights and returns pivot alpha.
+         Also does FT update */
+  virtual double updateWeights(CoinIndexedVector *input,
+    CoinIndexedVector *spare,
+    CoinIndexedVector *spare2,
+    CoinIndexedVector *updatedColumn)
+    = 0;
+
+  /** Updates primal solution (and maybe list of candidates)
+         Uses input vector which it deletes
+         Computes change in objective function
+         Would be faster if we kept basic regions, but on other hand it
+         means everything is always in sync
+     */
+  /* FIXME: this was pure virtul (=0). Why? */
+  virtual void updatePrimalSolution(CoinIndexedVector *input,
+    double theta,
+    double &changeInObjective)
+    = 0;
+  /** Saves any weights round factorization as pivot rows may change
+         Will be empty unless steepest edge (will save model)
+         May also recompute infeasibility stuff
+         1) before factorization
+         2) after good factorization (if weights empty may initialize)
+         3) after something happened but no factorization
+            (e.g. check for infeasible)
+         4) as 2 but restore weights from previous snapshot
+         5) for strong branching - initialize to 1 , infeasibilities
+	 6) scale back
+         7) for strong branching - initialize full weights , infeasibilities
+     */
+  virtual void saveWeights(ClpSimplex *model, int mode);
+  /// checks accuracy and may re-initialize (may be empty)
+  virtual void checkAccuracy();
+  /// Gets rid of last update (may be empty)
+  virtual void unrollWeights();
+  /// Gets rid of all arrays (may be empty)
+  virtual void clearArrays();
+  /// Returns true if would not find any row
+  virtual bool looksOptimal() const
+  {
+    return false;
+  }
+  /// Called when maximum pivots changes
+  virtual void maximumPivotsChanged() {}
+  //@}
+
+  ///@name Constructors and destructors
+  //@{
+  /// Default Constructor
+  ClpDualRowPivot();
+
+  /// Copy constructor
+  ClpDualRowPivot(const ClpDualRowPivot &);
+
+  /// Assignment operator
+  ClpDualRowPivot &operator=(const ClpDualRowPivot &rhs);
+
+  /// Destructor
+  virtual ~ClpDualRowPivot();
+
+  /// Clone
+  virtual ClpDualRowPivot *clone(bool copyData = true) const = 0;
+
+  //@}
+
+  ///@name Other
+  //@{
+  /// Returns model
+  inline ClpSimplex *model()
+  {
+    return model_;
+  }
+
+  /// Sets model (normally to NULL)
+  inline void setModel(ClpSimplex *newmodel)
+  {
+    model_ = newmodel;
+  }
+
+  /// Returns type (above 63 is extra information)
+  inline int type()
+  {
+    return type_;
+  }
+
+  //@}
+
+  //---------------------------------------------------------------------------
+
+protected:
+  ///@name Protected member data
+  //@{
+  /// Pointer to model
+  ClpSimplex *model_;
+  /// Type of row pivot algorithm
+  int type_;
+  //@}
+};
+#ifndef CLP_DUAL_COLUMN_MULTIPLIER
+//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
+#endif
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpDualRowSteepest.hpp

@@ -0,0 +1,160 @@
+/* $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).
+
+#ifndef ClpDualRowSteepest_H
+#define ClpDualRowSteepest_H
+
+#include "ClpDualRowPivot.hpp"
+class CoinIndexedVector;
+
+//#############################################################################
+
+/** Dual Row Pivot Steepest Edge Algorithm Class
+
+See Forrest-Goldfarb paper for algorithm
+
+*/
+
+class ClpDualRowSteepest : public ClpDualRowPivot {
+
+public:
+  ///@name Algorithmic methods
+  //@{
+
+  /// Returns pivot row, -1 if none
+  virtual int pivotRow();
+
+  /** Updates weights and returns pivot alpha.
+         Also does FT update */
+  virtual double updateWeights(CoinIndexedVector *input,
+    CoinIndexedVector *spare,
+    CoinIndexedVector *spare2,
+    CoinIndexedVector *updatedColumn);
+
+  /** Updates primal solution (and maybe list of candidates)
+         Uses input vector which it deletes
+         Computes change in objective function
+     */
+  virtual void updatePrimalSolution(CoinIndexedVector *input,
+    double theta,
+    double &changeInObjective);
+
+  /** Saves any weights round factorization as pivot rows may change
+         Save model
+         May also recompute infeasibility stuff
+         1) before factorization
+         2) after good factorization (if weights empty may initialize)
+         3) after something happened but no factorization
+            (e.g. check for infeasible)
+         4) as 2 but restore weights from previous snapshot
+         5) for strong branching - initialize (uninitialized) , infeasibilities
+     */
+  virtual void saveWeights(ClpSimplex *model, int mode);
+  /// Pass in saved weights
+  void passInSavedWeights(const CoinIndexedVector *saved);
+  /// Get saved weights
+  inline CoinIndexedVector *savedWeights()
+  {
+    return savedWeights_;
+  }
+  /// Gets rid of last update
+  virtual void unrollWeights();
+  /// Gets rid of all arrays
+  virtual void clearArrays();
+  /// Returns true if would not find any row
+  virtual bool looksOptimal() const;
+  /// Called when maximum pivots changes
+  virtual void maximumPivotsChanged();
+  //@}
+
+  /** enums for persistence
+     */
+  enum Persistence {
+    normal = 0x00, // create (if necessary) and destroy
+    keep = 0x01 // create (if necessary) and leave
+  };
+
+  ///@name Constructors and destructors
+  //@{
+  /** Default Constructor
+         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.
+     */
+  ClpDualRowSteepest(int mode = 3);
+
+  /// Copy constructor
+  ClpDualRowSteepest(const ClpDualRowSteepest &);
+
+  /// Assignment operator
+  ClpDualRowSteepest &operator=(const ClpDualRowSteepest &rhs);
+
+  /// Fill most values
+  void fill(const ClpDualRowSteepest &rhs);
+
+  /// Destructor
+  virtual ~ClpDualRowSteepest();
+
+  /// Clone
+  virtual ClpDualRowPivot *clone(bool copyData = true) const;
+
+  //@}
+  /**@name gets and sets */
+  //@{
+  /// Mode
+  inline int mode() const
+  {
+    return mode_;
+  }
+  /// Set mode
+  inline void setMode(int mode)
+  {
+    mode_ = mode;
+  }
+  /// Set/ get persistence
+  inline void setPersistence(Persistence life)
+  {
+    persistence_ = life;
+  }
+  inline Persistence persistence() const
+  {
+    return persistence_;
+  }
+  //@}
+
+  //---------------------------------------------------------------------------
+
+protected:
+  ///@name Protected member data
+  /** Status
+         0) Normal
+         -1) Needs initialization
+         1) Weights are stored by sequence number
+     */
+  int state_;
+  /** If 0 then we are using uninitialized weights, 1 then full,
+         if 2 then uninitialized partial, 3 switchable */
+  int mode_;
+  /// Life of weights
+  Persistence persistence_;
+  /// weight array
+  double *weights_;
+  /// square of infeasibility array (just for infeasible rows)
+  CoinIndexedVector *infeasible_;
+  /// alternate weight array (so we can unroll)
+  CoinIndexedVector *alternateWeights_;
+  /// save weight array (so we can use checkpoint)
+  CoinIndexedVector *savedWeights_;
+  /// Dubious weights
+  int *dubiousWeights_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpDummyMatrix.hpp

@@ -0,0 +1,186 @@
+/* $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).
+
+#ifndef ClpDummyMatrix_H
+#define ClpDummyMatrix_H
+
+#include "CoinPragma.hpp"
+
+#include "ClpMatrixBase.hpp"
+
+/** This implements a dummy matrix as derived from ClpMatrixBase.
+    This is so you can do ClpPdco but may come in useful elsewhere.
+    It just has dimensions but no data
+*/
+
+class ClpDummyMatrix : public ClpMatrixBase {
+
+public:
+  /**@name Useful methods */
+  //@{
+  /// Return a complete CoinPackedMatrix
+  virtual CoinPackedMatrix *getPackedMatrix() const;
+  /** Whether the packed matrix is column major ordered or not. */
+  virtual bool isColOrdered() const
+  {
+    return true;
+  }
+  /** Number of entries in the packed matrix. */
+  virtual CoinBigIndex getNumElements() const
+  {
+    return numberElements_;
+  }
+  /** Number of columns. */
+  virtual int getNumCols() const
+  {
+    return numberColumns_;
+  }
+  /** Number of rows. */
+  virtual int getNumRows() const
+  {
+    return numberRows_;
+  }
+
+  /** A vector containing the elements in the packed matrix. Note that there
+      might be gaps in this list, entries that do not belong to any
+      major-dimension vector. To get the actual elements one should look at
+      this vector together with vectorStarts and vectorLengths. */
+  virtual const double *getElements() const;
+  /** A vector containing the minor indices of the elements in the packed
+          matrix. Note that there might be gaps in this list, entries that do not
+          belong to any major-dimension vector. To get the actual elements one
+          should look at this vector together with vectorStarts and
+          vectorLengths. */
+  virtual const int *getIndices() const;
+
+  virtual const CoinBigIndex *getVectorStarts() const;
+  /** The lengths of the major-dimension vectors. */
+  virtual const int *getVectorLengths() const;
+
+  /** Delete the columns whose indices are listed in <code>indDel</code>. */
+  virtual void deleteCols(const int numDel, const int *indDel);
+  /** Delete the rows whose indices are listed in <code>indDel</code>. */
+  virtual void deleteRows(const int numDel, const int *indDel);
+  /** Returns a new matrix in reverse order without gaps */
+  virtual ClpMatrixBase *reverseOrderedCopy() const;
+  /// Returns number of elements in column part of basis
+  virtual int countBasis(const int *whichColumn,
+    int &numberColumnBasic);
+  /// Fills in column part of basis
+  virtual void fillBasis(ClpSimplex *model,
+    const int *whichColumn,
+    int &numberColumnBasic,
+    int *row, int *start,
+    int *rowCount, int *columnCount,
+    CoinFactorizationDouble *element);
+  /** Unpacks a column into an CoinIndexedvector
+      */
+  virtual void unpack(const ClpSimplex *model, CoinIndexedVector *rowArray,
+    int column) const;
+  /** Unpacks a column into an CoinIndexedvector
+      ** in packed foramt
+         Note that model is NOT const.  Bounds and objective could
+         be modified if doing column generation (just for this variable) */
+  virtual void unpackPacked(ClpSimplex *model,
+    CoinIndexedVector *rowArray,
+    int column) const;
+  /** Adds multiple of a column into an CoinIndexedvector
+         You can use quickAdd to add to vector */
+  virtual void add(const ClpSimplex *model, CoinIndexedVector *rowArray,
+    int column, double multiplier) const;
+  /** Adds multiple of a column into an array */
+  virtual void add(const ClpSimplex *model, double *array,
+    int column, double multiplier) const;
+  /// Allow any parts of a created CoinMatrix to be deleted
+  /// Allow any parts of a created CoinPackedMatrix to be deleted
+  virtual void releasePackedMatrix() const {}
+  //@}
+
+  /**@name Matrix times vector methods */
+  //@{
+  /** Return <code>y + A * scalar *x</code> in <code>y</code>.
+         @pre <code>x</code> must be of size <code>numColumns()</code>
+         @pre <code>y</code> must be of size <code>numRows()</code> */
+  virtual void times(double scalar,
+    const double *x, double *y) const;
+  /// And for scaling
+  virtual void times(double scalar,
+    const double *x, double *y,
+    const double *rowScale,
+    const double *columnScale) const;
+  /** Return <code>y + x * scalar * A</code> in <code>y</code>.
+         @pre <code>x</code> must be of size <code>numRows()</code>
+         @pre <code>y</code> must be of size <code>numColumns()</code> */
+  virtual void transposeTimes(double scalar,
+    const double *x, double *y) const;
+  /// And for scaling
+  virtual void transposeTimes(double scalar,
+    const double *x, double *y,
+    const double *rowScale,
+    const double *columnScale) const;
+
+  using ClpMatrixBase::transposeTimes;
+  /** Return <code>x * scalar * A + y</code> in <code>z</code>.
+     Can use y as temporary array (will be empty at end)
+     Note - If x packed mode - then z packed mode */
+  virtual void transposeTimes(const ClpSimplex *model, double scalar,
+    const CoinIndexedVector *x,
+    CoinIndexedVector *y,
+    CoinIndexedVector *z) const;
+  /** Return <code>x *A</code> in <code>z</code> but
+     just for indices in y.
+     Note - If x packed mode - then z packed mode
+     Squashes small elements and knows about ClpSimplex */
+  virtual void subsetTransposeTimes(const ClpSimplex *model,
+    const CoinIndexedVector *x,
+    const CoinIndexedVector *y,
+    CoinIndexedVector *z) const;
+  //@}
+
+  /**@name Other */
+  //@{
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Default constructor. */
+  ClpDummyMatrix();
+  /// Constructor with data
+  ClpDummyMatrix(int numberColumns, int numberRows,
+    int numberElements);
+  /** Destructor */
+  virtual ~ClpDummyMatrix();
+  //@}
+
+  /**@name Copy method */
+  //@{
+  /** The copy constructor. */
+  ClpDummyMatrix(const ClpDummyMatrix &);
+  /** The copy constructor from an CoinDummyMatrix. */
+  ClpDummyMatrix(const CoinPackedMatrix &);
+
+  ClpDummyMatrix &operator=(const ClpDummyMatrix &);
+  /// Clone
+  virtual ClpMatrixBase *clone() const;
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// Number of rows
+  int numberRows_;
+  /// Number of columns
+  int numberColumns_;
+  /// Number of elements
+  int numberElements_;
+
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpDynamicExampleMatrix.hpp

@@ -0,0 +1,199 @@
+/* $Id$ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDynamicExampleMatrix_H
+#define ClpDynamicExampleMatrix_H
+
+#include "CoinPragma.hpp"
+
+#include "ClpDynamicMatrix.hpp"
+class ClpSimplex;
+/** This implements a dynamic matrix when we have a limit on the number of
+    "interesting rows". This version inherits from ClpDynamicMatrix and knows that
+    the real matrix is gub.  This acts just like ClpDynamicMatrix but generates columns.
+    This "generates" columns by choosing from stored set.  It is maent as a starting point
+    as to how you could use shortest path to generate columns.
+
+    So it has its own copy of all data needed.  It populates ClpDynamicWatrix with enough
+    to allow for gub keys and active variables.  In turn ClpDynamicMatrix populates
+    a CoinPackedMatrix with active columns and rows.
+
+    As there is one copy here and one in ClpDynamicmatrix these names end in Gen_
+
+    It is obviously more efficient to just use ClpDynamicMatrix but the ideas is to
+    show how much code a user would have to write.
+
+    This does not work very well with bounds
+
+*/
+
+class ClpDynamicExampleMatrix : public ClpDynamicMatrix {
+
+public:
+  /**@name Main functions provided */
+  //@{
+  /// Partial pricing
+  virtual void partialPricing(ClpSimplex *model, double start, double end,
+    int &bestSequence, int &numberWanted);
+
+  /** Creates a variable.  This is called after partial pricing and will modify matrix.
+         Will update bestSequence.
+     */
+  virtual void createVariable(ClpSimplex *model, int &bestSequence);
+  /** If addColumn forces compression then this allows descendant to know what to do.
+         If >= then entry stayed in, if -1 then entry went out to lower bound.of zero.
+         Entries at upper bound (really nonzero) never go out (at present).
+     */
+  virtual void packDown(const int *in, int numberToPack);
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Default constructor. */
+  ClpDynamicExampleMatrix();
+  /** This is the real constructor.
+         It assumes factorization frequency will not be changed.
+         This resizes model !!!!
+         The contents of original matrix in model will be taken over and original matrix
+         will be sanitized so can be deleted (to avoid a very small memory leak)
+      */
+  ClpDynamicExampleMatrix(ClpSimplex *model, int numberSets,
+    int numberColumns, const CoinBigIndex *starts,
+    const double *lower, const double *upper,
+    const CoinBigIndex *startColumn, const int *row,
+    const double *element, const double *cost,
+    const double *columnLower = NULL, const double *columnUpper = NULL,
+    const unsigned char *status = NULL,
+    const unsigned char *dynamicStatus = NULL,
+    int numberIds = 0, const int *ids = NULL);
+#if 0
+     /// This constructor just takes over ownership (except for lower, upper)
+     ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
+                             int numberColumns, int * starts,
+                             const double * lower, const double * upper,
+                             int * startColumn, int * row,
+                             double * element, double * cost,
+                             double * columnLower = NULL, double * columnUpper = NULL,
+                             const unsigned char * status = NULL,
+                             const unsigned char * dynamicStatus = NULL,
+                             int numberIds = 0, const int *ids = NULL);
+#endif
+  /** Destructor */
+  virtual ~ClpDynamicExampleMatrix();
+  //@}
+
+  /**@name Copy method */
+  //@{
+  /** The copy constructor. */
+  ClpDynamicExampleMatrix(const ClpDynamicExampleMatrix &);
+  ClpDynamicExampleMatrix &operator=(const ClpDynamicExampleMatrix &);
+  /// Clone
+  virtual ClpMatrixBase *clone() const;
+  //@}
+  /**@name gets and sets */
+  //@{
+  /// Starts of each column
+  inline CoinBigIndex *startColumnGen() const
+  {
+    return startColumnGen_;
+  }
+  /// rows
+  inline int *rowGen() const
+  {
+    return rowGen_;
+  }
+  /// elements
+  inline double *elementGen() const
+  {
+    return elementGen_;
+  }
+  /// costs
+  inline double *costGen() const
+  {
+    return costGen_;
+  }
+  /// full starts
+  inline CoinBigIndex *fullStartGen() const
+  {
+    return fullStartGen_;
+  }
+  /// ids in next level matrix
+  inline int *idGen() const
+  {
+    return idGen_;
+  }
+  /// Optional lower bounds on columns
+  inline double *columnLowerGen() const
+  {
+    return columnLowerGen_;
+  }
+  /// Optional upper bounds on columns
+  inline double *columnUpperGen() const
+  {
+    return columnUpperGen_;
+  }
+  /// size
+  inline int numberColumns() const
+  {
+    return numberColumns_;
+  }
+  inline void setDynamicStatusGen(int sequence, DynamicStatus status)
+  {
+    unsigned char &st_byte = dynamicStatusGen_[sequence];
+    st_byte = static_cast< unsigned char >(st_byte & ~7);
+    st_byte = static_cast< unsigned char >(st_byte | status);
+  }
+  inline DynamicStatus getDynamicStatusGen(int sequence) const
+  {
+    return static_cast< DynamicStatus >(dynamicStatusGen_[sequence] & 7);
+  }
+  /// Whether flagged
+  inline bool flaggedGen(int i) const
+  {
+    return (dynamicStatusGen_[i] & 8) != 0;
+  }
+  inline void setFlaggedGen(int i)
+  {
+    dynamicStatusGen_[i] = static_cast< unsigned char >(dynamicStatusGen_[i] | 8);
+  }
+  inline void unsetFlagged(int i)
+  {
+    dynamicStatusGen_[i] = static_cast< unsigned char >(dynamicStatusGen_[i] & ~8);
+  }
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// size
+  int numberColumns_;
+  /// Starts of each column
+  CoinBigIndex *startColumnGen_;
+  /// rows
+  int *rowGen_;
+  /// elements
+  double *elementGen_;
+  /// costs
+  double *costGen_;
+  /// start of each set
+  CoinBigIndex *fullStartGen_;
+  /// for status and which bound
+  unsigned char *dynamicStatusGen_;
+  /** identifier for each variable up one level (startColumn_, etc).  This is
+         of length maximumGubColumns_.  For this version it is just sequence number
+         at this level */
+  int *idGen_;
+  /// Optional lower bounds on columns
+  double *columnLowerGen_;
+  /// Optional upper bounds on columns
+  double *columnUpperGen_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/