casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/ClpGubDynamicMatrix.hpp

@@ -0,0 +1,270 @@
+/* $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 ClpGubDynamicMatrix_H
+#define ClpGubDynamicMatrix_H
+
+#include "CoinPragma.hpp"
+
+#include "ClpGubMatrix.hpp"
+/** This implements Gub rows plus a ClpPackedMatrix.
+    This a dynamic version which stores the gub part and dynamically creates matrix.
+    All bounds are assumed to be zero and infinity
+
+    This is just a simple example for real column generation
+*/
+
+class ClpGubDynamicMatrix : public ClpGubMatrix {
+
+public:
+  /**@name Main functions provided */
+  //@{
+  /// Partial pricing
+  virtual void partialPricing(ClpSimplex *model, double start, double end,
+    int &bestSequence, int &numberWanted);
+  /** This is local to Gub to allow synchronization:
+         mode=0 when status of basis is good
+         mode=1 when variable is flagged
+         mode=2 when all variables unflagged (returns number flagged)
+         mode=3 just reset costs (primal)
+         mode=4 correct number of dual infeasibilities
+         mode=5 return 4 if time to re-factorize
+         mode=8  - make sure set is clean
+         mode=9  - adjust lower, upper on set by incoming
+     */
+  virtual int synchronize(ClpSimplex *model, int mode);
+  /// Sets up an effective RHS and does gub crash if needed
+  virtual void useEffectiveRhs(ClpSimplex *model, bool cheapest = true);
+  /**
+        update information for a pivot (and effective rhs)
+     */
+  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
+  /// Add a new variable to a set
+  void insertNonBasic(int sequence, int iSet);
+  /** Returns effective RHS offset if it is being used.  This is used for long problems
+         or big gub or anywhere where going through full columns is
+         expensive.  This may re-compute */
+  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
+    bool check = false);
+
+  using ClpPackedMatrix::times;
+  /** 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;
+  /** Just for debug
+         Returns sum and number of primal infeasibilities. Recomputes keys
+     */
+  virtual int checkFeasible(ClpSimplex *model, double &sum) const;
+  /// Cleans data after setWarmStart
+  void cleanData(ClpSimplex *model);
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Default constructor. */
+  ClpGubDynamicMatrix();
+  /** Destructor */
+  virtual ~ClpGubDynamicMatrix();
+  //@}
+
+  /**@name Copy method */
+  //@{
+  /** The copy constructor. */
+  ClpGubDynamicMatrix(const ClpGubDynamicMatrix &);
+  /** This is the real constructor.
+         It assumes factorization frequency will not be changed.
+         This resizes model !!!!
+      */
+  ClpGubDynamicMatrix(ClpSimplex *model, int numberSets,
+    int numberColumns, const int *starts,
+    const double *lower, const double *upper,
+    const CoinBigIndex *startColumn, const int *row,
+    const double *element, const double *cost,
+    const double *lowerColumn = NULL, const double *upperColumn = NULL,
+    const unsigned char *status = NULL);
+
+  ClpGubDynamicMatrix &operator=(const ClpGubDynamicMatrix &);
+  /// Clone
+  virtual ClpMatrixBase *clone() const;
+  //@}
+  /**@name gets and sets */
+  //@{
+  /// enums for status of various sorts
+  enum DynamicStatus {
+    inSmall = 0x01,
+    atUpperBound = 0x02,
+    atLowerBound = 0x03
+  };
+  /// Whether flagged
+  inline bool flagged(int i) const
+  {
+    return (dynamicStatus_[i] & 8) != 0;
+  }
+  inline void setFlagged(int i)
+  {
+    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] | 8);
+  }
+  inline void unsetFlagged(int i)
+  {
+    dynamicStatus_[i] = static_cast< unsigned char >(dynamicStatus_[i] & ~8);
+  }
+  inline void setDynamicStatus(int sequence, DynamicStatus status)
+  {
+    unsigned char &st_byte = dynamicStatus_[sequence];
+    st_byte = static_cast< unsigned char >(st_byte & ~7);
+    st_byte = static_cast< unsigned char >(st_byte | status);
+  }
+  inline DynamicStatus getDynamicStatus(int sequence) const
+  {
+    return static_cast< DynamicStatus >(dynamicStatus_[sequence] & 7);
+  }
+  /// Saved value of objective offset
+  inline double objectiveOffset() const
+  {
+    return objectiveOffset_;
+  }
+  /// Starts of each column
+  inline CoinBigIndex *startColumn() const
+  {
+    return startColumn_;
+  }
+  /// rows
+  inline int *row() const
+  {
+    return row_;
+  }
+  /// elements
+  inline double *element() const
+  {
+    return element_;
+  }
+  /// costs
+  inline double *cost() const
+  {
+    return cost_;
+  }
+  /// full starts
+  inline int *fullStart() const
+  {
+    return fullStart_;
+  }
+  /// ids of active columns (just index here)
+  inline int *id() const
+  {
+    return id_;
+  }
+  /// Optional lower bounds on columns
+  inline double *lowerColumn() const
+  {
+    return lowerColumn_;
+  }
+  /// Optional upper bounds on columns
+  inline double *upperColumn() const
+  {
+    return upperColumn_;
+  }
+  /// Optional true lower bounds on sets
+  inline double *lowerSet() const
+  {
+    return lowerSet_;
+  }
+  /// Optional true upper bounds on sets
+  inline double *upperSet() const
+  {
+    return upperSet_;
+  }
+  /// size
+  inline int numberGubColumns() const
+  {
+    return numberGubColumns_;
+  }
+  /// first free
+  inline int firstAvailable() const
+  {
+    return firstAvailable_;
+  }
+  /// set first free
+  inline void setFirstAvailable(int value)
+  {
+    firstAvailable_ = value;
+  }
+  /// first dynamic
+  inline int firstDynamic() const
+  {
+    return firstDynamic_;
+  }
+  /// number of columns in dynamic model
+  inline int lastDynamic() const
+  {
+    return lastDynamic_;
+  }
+  /// size of working matrix (max)
+  inline CoinBigIndex numberElements() const
+  {
+    return numberElements_;
+  }
+  /// Status region for gub slacks
+  inline unsigned char *gubRowStatus() const
+  {
+    return status_;
+  }
+  /// Status region for gub variables
+  inline unsigned char *dynamicStatus() const
+  {
+    return dynamicStatus_;
+  }
+  /// Returns which set a variable is in
+  int whichSet(int sequence) const;
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// Saved value of objective offset
+  double objectiveOffset_;
+  /// Starts of each column
+  CoinBigIndex *startColumn_;
+  /// rows
+  int *row_;
+  /// elements
+  double *element_;
+  /// costs
+  double *cost_;
+  /// full starts
+  int *fullStart_;
+  /// ids of active columns (just index here)
+  int *id_;
+  /// for status and which bound
+  unsigned char *dynamicStatus_;
+  /// Optional lower bounds on columns
+  double *lowerColumn_;
+  /// Optional upper bounds on columns
+  double *upperColumn_;
+  /// Optional true lower bounds on sets
+  double *lowerSet_;
+  /// Optional true upper bounds on sets
+  double *upperSet_;
+  /// size
+  int numberGubColumns_;
+  /// first free
+  int firstAvailable_;
+  /// saved first free
+  int savedFirstAvailable_;
+  /// first dynamic
+  int firstDynamic_;
+  /// number of columns in dynamic model
+  int lastDynamic_;
+  /// size of working matrix (max)
+  CoinBigIndex numberElements_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/ClpGubMatrix.hpp

@@ -0,0 +1,373 @@
+/* $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 ClpGubMatrix_H
+#define ClpGubMatrix_H
+
+#include "CoinPragma.hpp"
+
+#include "ClpPackedMatrix.hpp"
+class ClpSimplex;
+/** This implements Gub rows plus a ClpPackedMatrix.
+
+    There will be a version using ClpPlusMinusOne matrix but
+    there is no point doing one with ClpNetworkMatrix (although
+    an embedded network is attractive).
+
+*/
+
+class ClpGubMatrix : public ClpPackedMatrix {
+
+public:
+  /**@name Main functions provided */
+  //@{
+  /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */
+  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;
+  /// Partial pricing
+  virtual void partialPricing(ClpSimplex *model, double start, double end,
+    int &bestSequence, int &numberWanted);
+  /// Returns number of hidden rows e.g. gub
+  virtual int hiddenRows() const;
+  //@}
+
+  /**@name Matrix times vector methods */
+  //@{
+
+  using ClpPackedMatrix::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
+     Squashes small elements and knows about ClpSimplex */
+  virtual void transposeTimes(const ClpSimplex *model, double scalar,
+    const CoinIndexedVector *x,
+    CoinIndexedVector *y,
+    CoinIndexedVector *z) const;
+  /** 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
+     Squashes small elements and knows about ClpSimplex.
+     This version uses row copy*/
+  virtual void transposeTimesByRow(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 - z always packed mode */
+  virtual void subsetTransposeTimes(const ClpSimplex *model,
+    const CoinIndexedVector *x,
+    const CoinIndexedVector *y,
+    CoinIndexedVector *z) const;
+  /** expands an updated column to allow for extra rows which the main
+         solver does not know about and returns number added if mode 0.
+         If mode 1 deletes extra entries
+
+         This active in Gub
+     */
+  virtual int extendUpdated(ClpSimplex *model, CoinIndexedVector *update, int mode);
+  /**
+        mode=0  - Set up before "update" and "times" for primal solution using extended rows
+        mode=1  - Cleanup primal solution after "times" using extended rows.
+        mode=2  - Check (or report on) primal infeasibilities
+     */
+  virtual void primalExpanded(ClpSimplex *model, int mode);
+  /**
+         mode=0  - Set up before "updateTranspose" and "transposeTimes" for duals using extended
+                   updates array (and may use other if dual values pass)
+         mode=1  - Update dual solution after "transposeTimes" using extended rows.
+         mode=2  - Compute all djs and compute key dual infeasibilities
+         mode=3  - Report on key dual infeasibilities
+         mode=4  - Modify before updateTranspose in partial pricing
+     */
+  virtual void dualExpanded(ClpSimplex *model, CoinIndexedVector *array,
+    double *other, int mode);
+  /**
+         mode=0  - Create list of non-key basics in pivotVariable_ using
+                   number as numberBasic in and out
+         mode=1  - Set all key variables as basic
+         mode=2  - return number extra rows needed, number gives maximum number basic
+         mode=3  - before replaceColumn
+         mode=4  - return 1 if can do primal, 2 if dual, 3 if both
+         mode=5  - save any status stuff (when in good state)
+         mode=6  - restore status stuff
+         mode=7  - flag given variable (normally sequenceIn)
+         mode=8  - unflag all variables
+         mode=9  - synchronize costs
+         mode=10  - return 1 if there may be changing bounds on variable (column generation)
+         mode=11  - make sure set is clean (used when a variable rejected - but not flagged)
+         mode=12  - after factorize but before permute stuff
+         mode=13  - at end of simplex to delete stuff
+     */
+  virtual int generalExpanded(ClpSimplex *model, int mode, int &number);
+  /**
+        update information for a pivot (and effective rhs)
+     */
+  virtual int updatePivot(ClpSimplex *model, double oldInValue, double oldOutValue);
+  /// Sets up an effective RHS and does gub crash if needed
+  virtual void useEffectiveRhs(ClpSimplex *model, bool cheapest = true);
+  /** Returns effective RHS offset if it is being used.  This is used for long problems
+         or big gub or anywhere where going through full columns is
+         expensive.  This may re-compute */
+  virtual double *rhsOffset(ClpSimplex *model, bool forceRefresh = false,
+    bool check = false);
+  /** This is local to Gub to allow synchronization:
+         mode=0 when status of basis is good
+         mode=1 when variable is flagged
+         mode=2 when all variables unflagged (returns number flagged)
+         mode=3 just reset costs (primal)
+         mode=4 correct number of dual infeasibilities
+         mode=5 return 4 if time to re-factorize
+         mode=6  - return 1 if there may be changing bounds on variable (column generation)
+         mode=7  - do extra restores for column generation
+         mode=8  - make sure set is clean
+         mode=9  - adjust lower, upper on set by incoming
+     */
+  virtual int synchronize(ClpSimplex *model, int mode);
+  /// Correct sequence in and out to give true value
+  virtual void correctSequence(const ClpSimplex *model, int &sequenceIn, int &sequenceOut);
+  //@}
+
+  /**@name Constructors, destructor */
+  //@{
+  /** Default constructor. */
+  ClpGubMatrix();
+  /** Destructor */
+  virtual ~ClpGubMatrix();
+  //@}
+
+  /**@name Copy method */
+  //@{
+  /** The copy constructor. */
+  ClpGubMatrix(const ClpGubMatrix &);
+  /** The copy constructor from an CoinPackedMatrix. */
+  ClpGubMatrix(const CoinPackedMatrix &);
+  /** Subset constructor (without gaps).  Duplicates are allowed
+         and order is as given */
+  ClpGubMatrix(const ClpGubMatrix &wholeModel,
+    int numberRows, const int *whichRows,
+    int numberColumns, const int *whichColumns);
+  ClpGubMatrix(const CoinPackedMatrix &wholeModel,
+    int numberRows, const int *whichRows,
+    int numberColumns, const int *whichColumns);
+
+  /** This takes over ownership (for space reasons) */
+  ClpGubMatrix(CoinPackedMatrix *matrix);
+
+  /** This takes over ownership (for space reasons) and is the
+         real constructor*/
+  ClpGubMatrix(ClpPackedMatrix *matrix, int numberSets,
+    const int *start, const int *end,
+    const double *lower, const double *upper,
+    const unsigned char *status = NULL);
+
+  ClpGubMatrix &operator=(const ClpGubMatrix &);
+  /// Clone
+  virtual ClpMatrixBase *clone() const;
+  /** Subset clone (without gaps).  Duplicates are allowed
+         and order is as given */
+  virtual ClpMatrixBase *subsetClone(
+    int numberRows, const int *whichRows,
+    int numberColumns, const int *whichColumns) const;
+  /** redoes next_ for a set.  */
+  void redoSet(ClpSimplex *model, int newKey, int oldKey, int iSet);
+  //@}
+  /**@name gets and sets */
+  //@{
+  /// Status
+  inline ClpSimplex::Status getStatus(int sequence) const
+  {
+    return static_cast< ClpSimplex::Status >(status_[sequence] & 7);
+  }
+  inline void setStatus(int sequence, ClpSimplex::Status status)
+  {
+    unsigned char &st_byte = status_[sequence];
+    st_byte = static_cast< unsigned char >(st_byte & ~7);
+    st_byte = static_cast< unsigned char >(st_byte | status);
+  }
+  /// To flag a variable
+  inline void setFlagged(int sequence)
+  {
+    status_[sequence] = static_cast< unsigned char >(status_[sequence] | 64);
+  }
+  inline void clearFlagged(int sequence)
+  {
+    status_[sequence] = static_cast< unsigned char >(status_[sequence] & ~64);
+  }
+  inline bool flagged(int sequence) const
+  {
+    return ((status_[sequence] & 64) != 0);
+  }
+  /// To say key is above ub
+  inline void setAbove(int sequence)
+  {
+    unsigned char iStat = status_[sequence];
+    iStat = static_cast< unsigned char >(iStat & ~24);
+    status_[sequence] = static_cast< unsigned char >(iStat | 16);
+  }
+  /// To say key is feasible
+  inline void setFeasible(int sequence)
+  {
+    unsigned char iStat = status_[sequence];
+    iStat = static_cast< unsigned char >(iStat & ~24);
+    status_[sequence] = static_cast< unsigned char >(iStat | 8);
+  }
+  /// To say key is below lb
+  inline void setBelow(int sequence)
+  {
+    unsigned char iStat = status_[sequence];
+    iStat = static_cast< unsigned char >(iStat & ~24);
+    status_[sequence] = iStat;
+  }
+  inline double weight(int sequence) const
+  {
+    int iStat = status_[sequence] & 31;
+    iStat = iStat >> 3;
+    return static_cast< double >(iStat - 1);
+  }
+  /// Starts
+  inline int *start() const
+  {
+    return start_;
+  }
+  /// End
+  inline int *end() const
+  {
+    return end_;
+  }
+  /// Lower bounds on sets
+  inline double *lower() const
+  {
+    return lower_;
+  }
+  /// Upper bounds on sets
+  inline double *upper() const
+  {
+    return upper_;
+  }
+  /// Key variable of set
+  inline int *keyVariable() const
+  {
+    return keyVariable_;
+  }
+  /// Backward pointer to set number
+  inline int *backward() const
+  {
+    return backward_;
+  }
+  /// Number of sets (gub rows)
+  inline int numberSets() const
+  {
+    return numberSets_;
+  }
+  /// Switches off dj checking each factorization (for BIG models)
+  void switchOffCheck();
+  //@}
+
+protected:
+  /**@name Data members
+        The data members are protected to allow access for derived classes. */
+  //@{
+  /// Sum of dual infeasibilities
+  double sumDualInfeasibilities_;
+  /// Sum of primal infeasibilities
+  double sumPrimalInfeasibilities_;
+  /// Sum of Dual infeasibilities using tolerance based on error in duals
+  double sumOfRelaxedDualInfeasibilities_;
+  /// Sum of Primal infeasibilities using tolerance based on error in primals
+  double sumOfRelaxedPrimalInfeasibilities_;
+  /// Infeasibility weight when last full pass done
+  double infeasibilityWeight_;
+  /// Starts
+  int *start_;
+  /// End
+  int *end_;
+  /// Lower bounds on sets
+  double *lower_;
+  /// Upper bounds on sets
+  double *upper_;
+  /// Status of slacks
+  mutable unsigned char *status_;
+  /// Saved status of slacks
+  unsigned char *saveStatus_;
+  /// Saved key variables
+  int *savedKeyVariable_;
+  /// Backward pointer to set number
+  int *backward_;
+  /// Backward pointer to pivot row !!!
+  int *backToPivotRow_;
+  /// Change in costs for keys
+  double *changeCost_;
+  /// Key variable of set
+  mutable int *keyVariable_;
+  /** Next basic variable in set - starts at key and end with -(set+1).
+         Now changes to -(nonbasic+1).
+         next_ has extra space for 2* longest set */
+  mutable int *next_;
+  /// Backward pointer to index in CoinIndexedVector
+  int *toIndex_;
+  // Reverse pointer from index to set
+  int *fromIndex_;
+  /// Pointer back to model
+  ClpSimplex *model_;
+  /// Number of dual infeasibilities
+  int numberDualInfeasibilities_;
+  /// Number of primal infeasibilities
+  int numberPrimalInfeasibilities_;
+  /** If pricing will declare victory (i.e. no check every factorization).
+         -1 - always check
+         0  - don't check
+         1  - in don't check mode but looks optimal
+     */
+  int noCheck_;
+  /// Number of sets (gub rows)
+  int numberSets_;
+  /// Number in vector without gub extension
+  int saveNumber_;
+  /// Pivot row of possible next key
+  int possiblePivotKey_;
+  /// Gub slack in (set number or -1)
+  int gubSlackIn_;
+  /// First gub variables (same as start_[0] at present)
+  int firstGub_;
+  /// last gub variable (same as end_[numberSets_-1] at present)
+  int lastGub_;
+  /** type of gub - 0 not contiguous, 1 contiguous
+         add 8 bit to say no ubs on individual variables */
+  int gubType_;
+  //@}
+};
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/