casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/OsiPresolve.hpp

@@ -0,0 +1,272 @@
+// 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 OsiPresolve_H
+#define OsiPresolve_H
+#include "OsiSolverInterface.hpp"
+
+class CoinPresolveAction;
+#include "CoinPresolveMatrix.hpp"
+
+/*! \class OsiPresolve
+    \brief OSI interface to COIN problem simplification capabilities
+
+  COIN provides a number of classes which implement problem simplification
+  algorithms (CoinPresolveAction, CoinPrePostsolveMatrix, and derived
+  classes). The model of operation is as follows:
+  <ul>
+    <li>
+      Create a copy of the original problem.
+    </li>
+    <li>
+      Subject the copy to a series of transformations (the <i>presolve</i>
+      methods) to produce a presolved model. Each transformation is also
+      expected to provide a method to reverse the transformation (the
+      <i>postsolve</i> method). The postsolve methods are collected in a
+      linked list; the postsolve method for the final presolve transformation
+      is at the head of the list.
+    </li>
+    <li>
+      Hand the presolved problem to the solver for optimization.
+    </li>
+    <li>
+      Apply the collected postsolve methods to the presolved problem
+      and solution, restating the solution in terms of the original problem.
+    </li>
+  </ul>
+
+  The COIN presolve algorithms are unaware of OSI. The OsiPresolve class takes
+  care of the interface. Given an OsiSolverInterface \c origModel, it will take
+  care of creating a clone properly loaded with the presolved problem and ready
+  for optimization. After optimization, it will apply postsolve
+  transformations and load the result back into \c origModel.
+  
+  Assuming a problem has been loaded into an
+  \c OsiSolverInterface \c origModel, a bare-bones application looks like this:
+  \code
+  OsiPresolve pinfo ;
+  OsiSolverInterface *presolvedModel ;
+  // Return an OsiSolverInterface loaded with the presolved problem.
+  presolvedModel = pinfo.presolvedModel(*origModel,1.0e-8,false,numberPasses) ;
+  presolvedModel->initialSolve() ;
+  // Restate the solution and load it back into origModel.
+  pinfo.postsolve(true) ;
+  delete presolvedModel ;
+  \endcode
+*/
+
+class OsiPresolve {
+public:
+  /// Default constructor (empty object)
+  OsiPresolve();
+
+  /// Virtual destructor
+  virtual ~OsiPresolve();
+
+  /*! \brief Create a new OsiSolverInterface loaded with the presolved problem.
+
+    This method implements the first two steps described in the class
+    documentation.  It clones \c origModel and applies presolve
+    transformations, storing the resulting list of postsolve
+    transformations.  It returns a pointer to a new OsiSolverInterface loaded
+    with the presolved problem, or NULL if the problem is infeasible or
+    unbounded.  If \c keepIntegers is true then bounds may be tightened in
+    the original. Bounds will be moved by up to \c feasibilityTolerance to
+    try and stay feasible. When \c doStatus is true, the current solution will
+    be transformed to match the presolved model.
+
+    This should be paired with postsolve(). It is up to the client to
+    destroy the returned OsiSolverInterface, <i>after</i> calling postsolve().
+    
+    This method is virtual. Override this method if you need to customize
+    the steps of creating a model to apply presolve transformations.
+
+    In some sense, a wrapper for presolve(CoinPresolveMatrix*).
+  */
+  virtual OsiSolverInterface *presolvedModel(OsiSolverInterface &origModel,
+    double feasibilityTolerance = 0.0,
+    bool keepIntegers = true,
+    int numberPasses = 5,
+    const char *prohibited = NULL,
+    bool doStatus = true,
+    const char *rowProhibited = NULL);
+
+  /*! \brief Restate the solution to the presolved problem in terms of the
+	     original problem and load it into the original model.
+  
+    postsolve() restates the solution in terms of the original problem and
+    updates the original OsiSolverInterface supplied to presolvedModel().  If
+    the problem has not been solved to optimality, there are no guarantees.
+    If you are using an algorithm like simplex that has a concept of a basic
+    solution, then set updateStatus
+
+    The advantage of going back to the original problem is that it
+    will be exactly as it was, <i>i.e.</i>, 0.0 will not become 1.0e-19.
+
+    Note that if you modified the original problem after presolving, then you
+    must ``undo'' these modifications before calling postsolve().
+
+    In some sense, a wrapper for postsolve(CoinPostsolveMatrix&).
+  */
+  virtual void postsolve(bool updateStatus = true);
+
+  /*! \brief Return a pointer to the presolved model. */
+  OsiSolverInterface *model() const;
+
+  /// Return a pointer to the original model
+  OsiSolverInterface *originalModel() const;
+
+  /// Set the pointer to the original model
+  void setOriginalModel(OsiSolverInterface *model);
+
+  /// Return a pointer to the original columns
+  const int *originalColumns() const;
+
+  /// Return a pointer to the original rows
+  const int *originalRows() const;
+
+  /// Return number of rows in original model
+  inline int getNumRows() const
+  {
+    return nrows_;
+  }
+
+  /// Return number of columns in original model
+  inline int getNumCols() const
+  {
+    return ncols_;
+  }
+
+  /** "Magic" number. If this is non-zero then any elements with this value
+      may change and so presolve is very limited in what can be done
+      to the row and column.  This is for non-linear problems.
+  */
+  inline void setNonLinearValue(double value)
+  {
+    nonLinearValue_ = value;
+  }
+  inline double nonLinearValue() const
+  {
+    return nonLinearValue_;
+  }
+  /*! \brief Fine control over presolve actions
+  
+    Set/clear the following bits to allow or suppress actions:
+      - 0x01 allow duplicate column processing on integer columns
+	     and dual stuff on integers
+      - 0x02 switch off actions which can change +1 to something else
+      	     (doubleton, tripleton, implied free)
+      - 0x04 allow transfer of costs from singletons and between integer
+      	     variables (when advantageous)
+      - 0x08 do not allow x+y+z=1 transform
+      - 0x10 allow actions that don't easily unroll
+      - 0x20 allow dubious gub element reduction
+
+    GUB element reduction is only partially implemented in CoinPresolve (see
+    gubrow_action) and willl cause an abort at postsolve. It's not clear
+    what's meant by `dual stuff on integers'.
+    -- lh, 110605 --
+  */
+  inline void setPresolveActions(int action)
+  {
+    presolveActions_ = (presolveActions_ & 0xffff0000) | (action & 0xffff);
+  }
+  /// Get presolved model
+  inline OsiSolverInterface *presolvedModel() const
+  {
+    return presolvedModel_;
+  }
+  /// Set presolved model
+  inline void setPresolvedModel(OsiSolverInterface *presolvedModel)
+  {
+    presolvedModel_ = presolvedModel;
+  }
+
+private:
+  /*! Original model (solver interface loaded with the original problem).
+
+      Must not be destroyed until after postsolve().
+  */
+  OsiSolverInterface *originalModel_;
+
+  /*! Presolved  model (solver interface loaded with the presolved problem)
+  
+    Must be destroyed by the client (using delete) after postsolve().
+  */
+  OsiSolverInterface *presolvedModel_;
+
+  /*! "Magic" number. If this is non-zero then any elements with this value
+      may change and so presolve is very limited in what can be done
+      to the row and column.  This is for non-linear problems.
+      One could also allow for cases where sign of coefficient is known.
+  */
+  double nonLinearValue_;
+
+  /// Original column numbers
+  int *originalColumn_;
+
+  /// Original row numbers
+  int *originalRow_;
+
+  /// The list of transformations applied.
+  const CoinPresolveAction *paction_;
+
+  /*! \brief Number of columns in original model.
+
+    The problem will expand back to its former size as postsolve
+    transformations are applied. It is efficient to allocate data structures
+    for the final size of the problem rather than expand them as needed.
+  */
+  int ncols_;
+
+  /*! \brief Number of rows in original model. */
+  int nrows_;
+
+  /*! \brief Number of nonzero matrix coefficients in the original model. */
+  CoinBigIndex nelems_;
+
+  /** Whether we want to skip dual part of presolve etc.
+      1 bit allows duplicate column processing on integer columns
+      and dual stuff on integers
+      4 transfers costs to integer variables
+  */
+  int presolveActions_;
+  /// Number of major passes
+  int numberPasses_;
+
+protected:
+  /*! \brief Apply presolve transformations to the problem.
+  
+    Handles the core activity of applying presolve transformations.
+    
+    If you want to apply the individual presolve routines differently, or
+    perhaps add your own to the mix, define a derived class and override
+    this method
+  */
+  virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob);
+
+  /*! \brief Reverse presolve transformations to recover the solution
+	     to the original problem.
+
+    Handles the core activity of applying postsolve transformations.
+
+    Postsolving is pretty generic; just apply the transformations in reverse
+    order. You will probably only be interested in overriding this method if
+    you want to add code to test for consistency while debugging new presolve
+    techniques.
+  */
+  virtual void postsolve(CoinPostsolveMatrix &prob);
+
+  /*! \brief Destroys queued postsolve actions.
+  
+    <i>E.g.</i>, when presolve() determines the problem is infeasible, so that
+    it will not be necessary to actually solve the presolved problem and
+    convert the result back to the original problem.
+  */
+  void gutsOfDestroy();
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/OsiRowCut.hpp

@@ -0,0 +1,345 @@
+// Copyright (C) 2000, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef OsiRowCut_H
+#define OsiRowCut_H
+
+#include "CoinPackedVector.hpp"
+
+#include "OsiCollections.hpp"
+#include "OsiCut.hpp"
+
+//#define OSI_INLINE_ROWCUT_METHODS
+#ifdef OSI_INLINE_ROWCUT_METHODS
+#define OsiRowCut_inline inline
+#else
+#define OsiRowCut_inline
+#endif
+
+/** Row Cut Class
+
+A row cut has:
+  <ul>
+  <li>a lower bound<br>
+  <li>an upper bound<br>
+  <li>a vector of row elements
+  </ul>
+*/
+class OsiRowCut : public OsiCut {
+  friend void OsiRowCutUnitTest(const OsiSolverInterface *baseSiP,
+    const std::string &mpsDir);
+
+public:
+  /**@name Row bounds */
+  //@{
+  /// Get lower bound
+  OsiRowCut_inline double lb() const;
+  /// Set lower bound
+  OsiRowCut_inline void setLb(double lb);
+  /// Get upper bound
+  OsiRowCut_inline double ub() const;
+  /// Set upper bound
+  OsiRowCut_inline void setUb(double ub);
+  //@}
+
+  /**@name Row rhs, sense, range */
+  //@{
+  /// Get sense ('E', 'G', 'L', 'N', 'R')
+  char sense() const;
+  /// Get right-hand side
+  double rhs() const;
+  /// Get range (ub - lb for 'R' rows, 0 otherwise)
+  double range() const;
+  //@}
+
+  //-------------------------------------------------------------------
+  /**@name Row elements  */
+  //@{
+  /// Set row elements
+  OsiRowCut_inline void setRow(
+    int size,
+    const int *colIndices,
+    const double *elements,
+    bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE);
+  /// Set row elements from a packed vector
+  OsiRowCut_inline void setRow(const CoinPackedVector &v);
+  /// Get row elements
+  OsiRowCut_inline const CoinPackedVector &row() const;
+  /// Get row elements for changing
+  OsiRowCut_inline CoinPackedVector &mutableRow();
+  //@}
+
+  /**@name Comparison operators  */
+  //@{
+#if __GNUC__ != 2
+  using OsiCut::operator==;
+#endif
+  /** equal - true if lower bound, upper bound, row elements,
+        and OsiCut are equal.
+    */
+  OsiRowCut_inline bool operator==(const OsiRowCut &rhs) const;
+
+#if __GNUC__ != 2
+  using OsiCut::operator!=;
+#endif
+  /// not equal
+  OsiRowCut_inline bool operator!=(const OsiRowCut &rhs) const;
+  //@}
+
+  //----------------------------------------------------------------
+  /**@name Sanity checks on cut */
+  //@{
+  /** Returns true if the cut is consistent.
+        This checks to ensure that:
+        <ul>
+        <li>The row element vector does not have duplicate indices
+        <li>The row element vector indices are >= 0
+        </ul>
+    */
+  OsiRowCut_inline bool consistent() const;
+
+  /** Returns true if cut is consistent with respect to the solver
+        interface's model.
+        This checks to ensure that
+        <ul>
+        <li>The row element vector indices are < the number of columns
+            in the model
+        </ul>
+    */
+  OsiRowCut_inline bool consistent(const OsiSolverInterface &im) const;
+
+  /** Returns true if the row cut itself is infeasible and cannot be satisfied.       
+        This checks whether
+        <ul>
+        <li>the lower bound is strictly greater than the
+            upper bound.
+        </ul>
+    */
+  OsiRowCut_inline bool infeasible(const OsiSolverInterface &im) const;
+  /** Returns infeasibility of the cut with respect to solution 
+	passed in i.e. is positive if cuts off that solution.  
+	solution is getNumCols() long..
+    */
+  virtual double violated(const double *solution) const;
+  //@}
+
+  /**@name Arithmetic operators. Apply CoinPackedVector methods to the vector */
+  //@{
+  /// add <code>value</code> to every vector entry
+  void operator+=(double value)
+  {
+    row_ += value;
+  }
+
+  /// subtract <code>value</code> from every vector entry
+  void operator-=(double value)
+  {
+    row_ -= value;
+  }
+
+  /// multiply every vector entry by <code>value</code>
+  void operator*=(double value)
+  {
+    row_ *= value;
+  }
+
+  /// divide every vector entry by <code>value</code>
+  void operator/=(double value)
+  {
+    row_ /= value;
+  }
+  //@}
+
+  /// Allow access row sorting function
+  void sortIncrIndex()
+  {
+    row_.sortIncrIndex();
+  }
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Assignment operator
+  OsiRowCut &operator=(const OsiRowCut &rhs);
+
+  /// Copy constructor
+  OsiRowCut(const OsiRowCut &);
+
+  /// Clone
+  virtual OsiRowCut *clone() const;
+
+  /// Default Constructor
+  OsiRowCut();
+
+  /** \brief Ownership Constructor
+
+      This constructor assumes ownership of the vectors passed as parameters
+      for indices and elements. \p colIndices and \p elements will be NULL
+      on return.
+    */
+  OsiRowCut(double cutlb, double cutub,
+    int capacity, int size,
+    int *&colIndices, double *&elements);
+
+  /// Destructor
+  virtual ~OsiRowCut();
+  //@}
+
+  /**@name Debug stuff */
+  //@{
+  /// Print cuts in collection
+  virtual void print() const;
+  //@}
+
+private:
+  /**@name Private member data */
+  //@{
+  /// Row elements
+  CoinPackedVector row_;
+  /// Row lower bound
+  double lb_;
+  /// Row upper bound
+  double ub_;
+  //@}
+};
+
+#ifdef OSI_INLINE_ROWCUT_METHODS
+
+//-------------------------------------------------------------------
+// Set/Get lower & upper bounds
+//-------------------------------------------------------------------
+double OsiRowCut::lb() const { return lb_; }
+void OsiRowCut::setLb(double lb) { lb_ = lb; }
+double OsiRowCut::ub() const { return ub_; }
+void OsiRowCut::setUb(double ub) { ub_ = ub; }
+
+//-------------------------------------------------------------------
+// Set row elements
+//-------------------------------------------------------------------
+void OsiRowCut::setRow(int size,
+  const int *colIndices, const double *elements)
+{
+  row_.setVector(size, colIndices, elements);
+}
+void OsiRowCut::setRow(const CoinPackedVector &v)
+{
+  row_ = v;
+}
+
+//-------------------------------------------------------------------
+// Get the row
+//-------------------------------------------------------------------
+const CoinPackedVector &OsiRowCut::row() const
+{
+  return row_;
+}
+
+//-------------------------------------------------------------------
+// Get the row so we can change
+//-------------------------------------------------------------------
+CoinPackedVector &OsiRowCut::mutableRow()
+{
+  return row_;
+}
+
+//----------------------------------------------------------------
+// == operator
+//-------------------------------------------------------------------
+bool OsiRowCut::operator==(const OsiRowCut &rhs) const
+{
+  if (this->OsiCut::operator!=(rhs))
+    return false;
+  if (row() != rhs.row())
+    return false;
+  if (lb() != rhs.lb())
+    return false;
+  if (ub() != rhs.ub())
+    return false;
+  return true;
+}
+bool OsiRowCut::operator!=(const OsiRowCut &rhs) const
+{
+  return !((*this) == rhs);
+}
+
+//----------------------------------------------------------------
+// consistent & infeasible
+//-------------------------------------------------------------------
+bool OsiRowCut::consistent() const
+{
+  const CoinPackedVector &r = row();
+  r.duplicateIndex("consistent", "OsiRowCut");
+  if (r.getMinIndex() < 0)
+    return false;
+  return true;
+}
+bool OsiRowCut::consistent(const OsiSolverInterface &im) const
+{
+  const CoinPackedVector &r = row();
+  if (r.getMaxIndex() >= im.getNumCols())
+    return false;
+
+  return true;
+}
+bool OsiRowCut::infeasible(const OsiSolverInterface &im) const
+{
+  if (lb() > ub())
+    return true;
+
+  return false;
+}
+
+#endif
+
+/** Row Cut Class which refers back to row which created it.
+    It may be useful to strengthen a row rather than add a cut.  To do this
+    we need to know which row is strengthened.  This trivial extension
+    to OsiRowCut does that.
+
+*/
+class OsiRowCut2 : public OsiRowCut {
+
+public:
+  /**@name Which row */
+  //@{
+  /// Get row
+  inline int whichRow() const
+  {
+    return whichRow_;
+  }
+  /// Set row
+  inline void setWhichRow(int row)
+  {
+    whichRow_ = row;
+  }
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Assignment operator
+  OsiRowCut2 &operator=(const OsiRowCut2 &rhs);
+
+  /// Copy constructor
+  OsiRowCut2(const OsiRowCut2 &);
+
+  /// Clone
+  virtual OsiRowCut *clone() const;
+
+  /// Default Constructor
+  OsiRowCut2(int row = -1);
+
+  /// Destructor
+  virtual ~OsiRowCut2();
+  //@}
+
+private:
+  /**@name Private member data */
+  //@{
+  /// Which row
+  int whichRow_;
+  //@}
+};
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/