casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/coin/OsiColCut.hpp

@@ -0,0 +1,322 @@
+// 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 OsiColCut_H
+#define OsiColCut_H
+
+#include <string>
+
+#include "CoinPackedVector.hpp"
+
+#include "OsiCollections.hpp"
+#include "OsiCut.hpp"
+
+/** Column Cut Class
+
+Column Cut Class has:
+  <ul>
+  <li>a sparse vector of column lower bounds
+  <li>a sparse vector of column upper bounds
+  </ul>
+*/
+class OsiColCut : public OsiCut {
+  friend void OsiColCutUnitTest(const OsiSolverInterface *baseSiP,
+    const std::string &mpsDir);
+
+public:
+  //----------------------------------------------------------------
+
+  /**@name Setting column bounds */
+  //@{
+  /// Set column lower bounds
+  inline void setLbs(
+    int nElements,
+    const int *colIndices,
+    const double *lbElements);
+
+  /// Set column lower bounds from a packed vector
+  inline void setLbs(const CoinPackedVector &lbs);
+
+  /// Set column upper bounds
+  inline void setUbs(
+    int nElements,
+    const int *colIndices,
+    const double *ubElements);
+
+  /// Set column upper bounds from a packed vector
+  inline void setUbs(const CoinPackedVector &ubs);
+  //@}
+
+  //----------------------------------------------------------------
+
+  /**@name Getting column bounds */
+  //@{
+  /// Get column lower bounds
+  inline const CoinPackedVector &lbs() const;
+  /// Get column upper bounds
+  inline const CoinPackedVector &ubs() const;
+  //@}
+
+  /**@name Comparison operators  */
+  //@{
+#if __GNUC__ != 2
+  using OsiCut::operator==;
+#endif
+  /** equal - true if lower bounds, upper bounds, 
+  and OsiCut are equal.
+  */
+  inline virtual bool operator==(const OsiColCut &rhs) const;
+
+#if __GNUC__ != 2
+  using OsiCut::operator!=;
+#endif
+  /// not equal
+  inline virtual bool operator!=(const OsiColCut &rhs) const;
+  //@}
+
+  //----------------------------------------------------------------
+
+  /**@name Sanity checks on cut */
+  //@{
+  /** Returns true if the cut is consistent with respect to itself.
+  This checks to ensure that:
+  <ul>
+  <li>The bound vectors do not have duplicate indices,
+  <li>The bound vectors indices are >=0
+  </ul>
+  */
+  inline virtual bool consistent() const;
+
+  /** Returns true if cut is consistent with respect to the solver  
+  interface's model. This checks to ensure that
+  the lower & upperbound packed vectors:
+  <ul>
+  <li>do not have an index >= the number of column is the model.
+  </ul>
+  */
+  inline virtual bool consistent(const OsiSolverInterface &im) const;
+
+  /** Returns true if the cut is infeasible with respect to its bounds and the 
+  column bounds in the solver interface's models.
+  This checks whether:
+  <ul>
+  <li>the maximum of the new and existing lower bounds is strictly 
+  greater than the minimum of the new and existing upper bounds.
+</ul>
+  */
+  inline virtual 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 Constructors and destructors */
+  //@{
+  /// Assignment operator
+  OsiColCut &operator=(const OsiColCut &rhs);
+
+  /// Copy constructor
+  OsiColCut(const OsiColCut &);
+
+  /// Default Constructor
+  OsiColCut();
+
+  /// Clone
+  virtual OsiColCut *clone() const;
+
+  /// Destructor
+  virtual ~OsiColCut();
+  //@}
+
+  /**@name Debug stuff */
+  //@{
+  /// Print cuts in collection
+  virtual void print() const;
+  //@}
+
+private:
+  /**@name Private member data */
+  //@{
+  /// Lower bounds
+  CoinPackedVector lbs_;
+  /// Upper bounds
+  CoinPackedVector ubs_;
+  //@}
+};
+
+//-------------------------------------------------------------------
+// Set lower & upper bound vectors
+//-------------------------------------------------------------------
+void OsiColCut::setLbs(
+  int size,
+  const int *colIndices,
+  const double *lbElements)
+{
+  lbs_.setVector(size, colIndices, lbElements);
+}
+//
+void OsiColCut::setUbs(
+  int size,
+  const int *colIndices,
+  const double *ubElements)
+{
+  ubs_.setVector(size, colIndices, ubElements);
+}
+//
+void OsiColCut::setLbs(const CoinPackedVector &lbs)
+{
+  lbs_ = lbs;
+}
+//
+void OsiColCut::setUbs(const CoinPackedVector &ubs)
+{
+  ubs_ = ubs;
+}
+
+//-------------------------------------------------------------------
+// Get Column Lower Bounds and Column Upper Bounds
+//-------------------------------------------------------------------
+const CoinPackedVector &OsiColCut::lbs() const
+{
+  return lbs_;
+}
+//
+const CoinPackedVector &OsiColCut::ubs() const
+{
+  return ubs_;
+}
+
+//----------------------------------------------------------------
+// == operator
+//-------------------------------------------------------------------
+bool OsiColCut::operator==(
+  const OsiColCut &rhs) const
+{
+  if (this->OsiCut::operator!=(rhs))
+    return false;
+  if (lbs() != rhs.lbs())
+    return false;
+  if (ubs() != rhs.ubs())
+    return false;
+  return true;
+}
+//
+bool OsiColCut::operator!=(
+  const OsiColCut &rhs) const
+{
+  return !((*this) == rhs);
+}
+
+//----------------------------------------------------------------
+// consistent & infeasible
+//-------------------------------------------------------------------
+bool OsiColCut::consistent() const
+{
+  const CoinPackedVector &lb = lbs();
+  const CoinPackedVector &ub = ubs();
+  // Test for consistent cut.
+  // Are packed vectors consistent?
+  lb.duplicateIndex("consistent", "OsiColCut");
+  ub.duplicateIndex("consistent", "OsiColCut");
+  if (lb.getMinIndex() < 0)
+    return false;
+  if (ub.getMinIndex() < 0)
+    return false;
+  return true;
+}
+//
+bool OsiColCut::consistent(const OsiSolverInterface &im) const
+{
+  const CoinPackedVector &lb = lbs();
+  const CoinPackedVector &ub = ubs();
+
+  // Test for consistent cut.
+  if (lb.getMaxIndex() >= im.getNumCols())
+    return false;
+  if (ub.getMaxIndex() >= im.getNumCols())
+    return false;
+
+  return true;
+}
+
+#if 0
+bool OsiColCut::feasible(const OsiSolverInterface &im) const
+{
+  const double * oldColLb = im.getColLower();
+  const double * oldColUb = im.getColUpper();
+  const CoinPackedVector & cutLbs = lbs();
+  const CoinPackedVector & cutUbs = ubs();
+  int i;
+  
+  for ( i=0; i<cutLbs.size(); i++ ) {
+    int colIndx = cutLbs.indices()[i];
+    double newLb;
+    if ( cutLbs.elements()[i] > oldColLb[colIndx] )
+      newLb = cutLbs.elements()[i];
+    else
+      newLb = oldColLb[colIndx];
+
+    double newUb = oldColUb[colIndx];
+    if ( cutUbs.indexExists(colIndx) )
+      if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx];
+      if ( newLb > newUb ) 
+        return false;
+  }
+  
+  for ( i=0; i<cutUbs.size(); i++ ) {
+    int colIndx = cutUbs.indices()[i];
+    double newUb = cutUbs.elements()[i] < oldColUb[colIndx] ? cutUbs.elements()[i] : oldColUb[colIndx];
+    double newLb = oldColLb[colIndx];
+    if ( cutLbs.indexExists(colIndx) )
+      if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx];
+      if ( newUb < newLb ) 
+        return false;
+  }
+  
+  return true;
+}
+#endif
+
+bool OsiColCut::infeasible(const OsiSolverInterface &im) const
+{
+  const double *oldColLb = im.getColLower();
+  const double *oldColUb = im.getColUpper();
+  const CoinPackedVector &cutLbs = lbs();
+  const CoinPackedVector &cutUbs = ubs();
+  int i;
+
+  for (i = 0; i < cutLbs.getNumElements(); i++) {
+    int colIndx = cutLbs.getIndices()[i];
+    double newLb = cutLbs.getElements()[i] > oldColLb[colIndx] ? cutLbs.getElements()[i] : oldColLb[colIndx];
+
+    double newUb = oldColUb[colIndx];
+    if (cutUbs.isExistingIndex(colIndx))
+      if (cutUbs[colIndx] < newUb)
+        newUb = cutUbs[colIndx];
+    if (newLb > newUb)
+      return true;
+  }
+
+  for (i = 0; i < cutUbs.getNumElements(); i++) {
+    int colIndx = cutUbs.getIndices()[i];
+    double newUb = cutUbs.getElements()[i] < oldColUb[colIndx] ? cutUbs.getElements()[i] : oldColUb[colIndx];
+    double newLb = oldColLb[colIndx];
+    if (cutLbs.isExistingIndex(colIndx))
+      if (cutLbs[colIndx] > newLb)
+        newLb = cutLbs[colIndx];
+    if (newUb < newLb)
+      return true;
+  }
+
+  return false;
+}
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/OsiCollections.hpp

@@ -0,0 +1,34 @@
+// 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 OsiCollections_H
+#define OsiCollections_H
+
+#include <vector>
+
+//Forward declarations
+class OsiColCut;
+class OsiRowCut;
+class OsiCut;
+
+/* Collection Classes */
+
+/**@name Typedefs for Standard Template Library collections of Osi Objects. */
+//@{
+/// Vector of int
+typedef std::vector< int > OsiVectorInt;
+/// Vector of double
+typedef std::vector< double > OsiVectorDouble;
+/// Vector of OsiColCut pointers
+typedef std::vector< OsiColCut * > OsiVectorColCutPtr;
+/// Vector of OsiRowCut pointers
+typedef std::vector< OsiRowCut * > OsiVectorRowCutPtr;
+/// Vector of OsiCut pointers
+typedef std::vector< OsiCut * > OsiVectorCutPtr;
+//@}
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/

casadi/include/coin/OsiConfig.h

@@ -0,0 +1,19 @@
+/* src/Osi/config_osi.h.  Generated by configure.  */
+/* src/Osi/config_osi.h.in. */
+
+#ifndef __CONFIG_OSI_H__
+#define __CONFIG_OSI_H__
+
+/* Version number of project */
+#define OSI_VERSION "0.108.9"
+
+/* Major Version number of project */
+#define OSI_VERSION_MAJOR 0
+
+/* Minor Version number of project */
+#define OSI_VERSION_MINOR 108
+
+/* Release Version number of project */
+#define OSI_VERSION_RELEASE 9
+
+#endif

casadi/include/coin/OsiCut.hpp

@@ -0,0 +1,251 @@
+// 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 OsiCut_H
+#define OsiCut_H
+
+#include "OsiCollections.hpp"
+#include "OsiSolverInterface.hpp"
+
+/** Base Class for cut.
+
+The Base cut class contains:
+  <ul>
+  <li>a measure of the cut's effectivness
+  </ul>
+*/
+
+/*
+  COIN_NOTEST_DUPLICATE is rooted in CoinUtils. Check there before you
+  meddle here.
+*/
+#ifdef COIN_FAST_CODE
+#ifndef COIN_NOTEST_DUPLICATE
+#define COIN_NOTEST_DUPLICATE
+#endif
+#endif
+
+#ifndef COIN_NOTEST_DUPLICATE
+#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true
+#else
+#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false
+#endif
+
+class OsiCut {
+
+public:
+  //-------------------------------------------------------------------
+  /**@name Effectiveness */
+  //@{
+  /// Set effectiveness
+  inline void setEffectiveness(double e);
+  /// Get effectiveness
+  inline double effectiveness() const;
+  //@}
+
+  /**@name GloballyValid */
+  //@{
+  /// Set globallyValid (nonzero true)
+  inline void setGloballyValid(bool trueFalse)
+  {
+    globallyValid_ = trueFalse ? 1 : 0;
+  }
+  inline void setGloballyValid()
+  {
+    globallyValid_ = 1;
+  }
+  inline void setNotGloballyValid()
+  {
+    globallyValid_ = 0;
+  }
+  /// Get globallyValid
+  inline bool globallyValid() const
+  {
+    return globallyValid_ != 0;
+  }
+  /// Set globallyValid as integer (nonzero true)
+  inline void setGloballyValidAsInteger(int trueFalse)
+  {
+    globallyValid_ = trueFalse;
+  }
+  /// Get globallyValid
+  inline int globallyValidAsInteger() const
+  {
+    return globallyValid_;
+  }
+  //@}
+
+  /**@name Debug stuff */
+  //@{
+  /// Print cuts in collection
+  virtual void print() const {}
+  //@}
+
+#if 0
+  / **@name Times used */
+  / /@{
+  / // Set times used
+  inline void setTimesUsed( int t );
+  / // Increment times used
+  inline void incrementTimesUsed();
+  / // Get times used
+  inline int timesUsed() const;
+  / /@}
+  
+  / **@name Times tested */
+  / /@{
+  / // Set times tested
+  inline void setTimesTested( int t );
+  / // Increment times tested
+  inline void incrementTimesTested();
+  / // Get times tested
+  inline int timesTested() const;
+  / /@}
+#endif
+
+  //----------------------------------------------------------------
+
+  /**@name Comparison operators  */
+  //@{
+  ///equal. 2 cuts are equal if there effectiveness are equal
+  inline virtual bool operator==(const OsiCut &rhs) const;
+  /// not equal
+  inline virtual bool operator!=(const OsiCut &rhs) const;
+  /// less than. True if this.effectiveness < rhs.effectiveness
+  inline virtual bool operator<(const OsiCut &rhs) const;
+  /// less than. True if this.effectiveness > rhs.effectiveness
+  inline virtual bool operator>(const OsiCut &rhs) const;
+  //@}
+
+  //----------------------------------------------------------------
+  // consistent() - returns true if the cut is consistent with repect to itself.
+  //         This might include checks to ensure that a packed vector
+  //         itself does not have a negative index.
+  // consistent(const OsiSolverInterface& si) - returns true if cut is consistent with
+  //         respect to the solver interface's model. This might include a check to
+  //         make sure a column index is not greater than the number
+  //         of columns in the problem.
+  // infeasible(const OsiSolverInterface& si) - returns true if the cut is infeasible
+  //         "with respect to itself". This might include a check to ensure
+  //         the lower bound is greater than the upper bound, or if the
+  //         cut simply replaces bounds that the new bounds are feasible with
+  //         respect to the old bounds.
+  //-----------------------------------------------------------------
+  /**@name Sanity checks on cut */
+  //@{
+  /** Returns true if the cut is consistent with respect to itself,
+      without considering any
+      data in the model. For example, it might check to ensure
+      that a column index is not negative.
+  */
+  inline virtual bool consistent() const = 0;
+
+  /** Returns true if cut is consistent when considering the solver
+      interface's model.  For example, it might check to ensure
+      that a column index is not greater than the number of columns
+      in the model. Assumes consistent() is true.
+  */
+  inline virtual bool consistent(const OsiSolverInterface &si) const = 0;
+
+  /** Returns true if the cut is infeasible "with respect to itself" and
+      cannot be satisfied. This method does NOT check whether adding the
+      cut to the solver interface's model will make the -model- infeasble.
+      A cut which returns !infeasible(si) may very well make the model
+      infeasible. (Of course, adding a cut with returns infeasible(si) 
+      will make the model infeasible.)
+
+      The "with respect to itself" is in quotes becaues 
+      in the case where the cut
+      simply replaces existing bounds, it may make
+      sense to test infeasibility with respect to the current bounds
+      held in the solver interface's model. For example, if the cut 
+      has a single variable in it, it might check that the maximum
+      of new and existing lower bounds is greater than the minium of 
+      the new and existing upper bounds.
+
+      Assumes that consistent(si) is true.<br>
+      Infeasible cuts can be a useful mechanism for a cut generator to
+      inform the solver interface that its detected infeasibility of the
+      problem.
+  */
+  inline virtual bool infeasible(const OsiSolverInterface &si) const = 0;
+
+  /** 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 = 0;
+  //@}
+
+protected:
+  /**@name Constructors and destructors */
+  //@{
+  /// Default Constructor
+  OsiCut();
+
+  /// Copy constructor
+  OsiCut(const OsiCut &);
+
+  /// Assignment operator
+  OsiCut &operator=(const OsiCut &rhs);
+
+  /// Destructor
+  virtual ~OsiCut();
+  //@}
+
+private:
+  /**@name Private member data */
+  //@{
+  /// Effectiveness
+  double effectiveness_;
+  /// If cut has global validity i.e. can be used anywhere in tree
+  int globallyValid_;
+#if 0
+  /// Times used
+  int timesUsed_;
+  /// Times tested
+  int timesTested_;
+#endif
+  //@}
+};
+
+//-------------------------------------------------------------------
+// Set/Get member data
+//-------------------------------------------------------------------
+void OsiCut::setEffectiveness(double e) { effectiveness_ = e; }
+double OsiCut::effectiveness() const { return effectiveness_; }
+
+#if 0
+void OsiCut::setTimesUsed( int t ) { timesUsed_=t; }
+void OsiCut::incrementTimesUsed() { timesUsed_++; }
+int OsiCut::timesUsed() const { return timesUsed_; }
+
+void OsiCut::setTimesTested( int t ) { timesTested_=t; }
+void OsiCut::incrementTimesTested() { timesTested_++; }
+int OsiCut::timesTested() const{ return timesTested_; }
+#endif
+
+//----------------------------------------------------------------
+// == operator
+//-------------------------------------------------------------------
+bool OsiCut::operator==(const OsiCut &rhs) const
+{
+  return effectiveness() == rhs.effectiveness();
+}
+bool OsiCut::operator!=(const OsiCut &rhs) const
+{
+  return !((*this) == rhs);
+}
+bool OsiCut::operator<(const OsiCut &rhs) const
+{
+  return effectiveness() < rhs.effectiveness();
+}
+bool OsiCut::operator>(const OsiCut &rhs) const
+{
+  return effectiveness() > rhs.effectiveness();
+}
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/