casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/coin/OsiCuts.hpp

@@ -0,0 +1,505 @@
+// 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 OsiCuts_H
+#define OsiCuts_H
+
+#include "CoinPragma.hpp"
+
+#include <cmath>
+#include <cfloat>
+#include "OsiCollections.hpp"
+#include "OsiRowCut.hpp"
+#include "OsiColCut.hpp"
+#include "CoinFloatEqual.hpp"
+
+/** Collections of row cuts and column cuts
+*/
+class OsiCuts {
+  friend void OsiCutsUnitTest();
+
+public:
+  /**@name Iterator classes
+   */
+  //@{
+  /** Iterator
+
+      This is a class for iterating over the collection of cuts.
+    */
+  class iterator {
+    friend class OsiCuts;
+
+  public:
+    iterator(OsiCuts &cuts);
+    iterator(const iterator &src);
+    iterator &operator=(const iterator &rhs);
+    ~iterator();
+    OsiCut *operator*() const { return cutP_; }
+    iterator operator++();
+
+    iterator operator++(int)
+    {
+      iterator temp = *this;
+      ++*this;
+      return temp;
+    }
+
+    bool operator==(const iterator &it) const
+    {
+      return (colCutIndex_ + rowCutIndex_) == (it.colCutIndex_ + it.rowCutIndex_);
+    }
+
+    bool operator!=(const iterator &it) const
+    {
+      return !((*this) == it);
+    }
+
+    bool operator<(const iterator &it) const
+    {
+      return (colCutIndex_ + rowCutIndex_) < (it.colCutIndex_ + it.rowCutIndex_);
+    }
+
+  private:
+    iterator();
+    // *THINK* : how to inline these without sticking the code here (ugly...)
+    iterator begin();
+    iterator end();
+    OsiCuts &cuts_;
+    int rowCutIndex_;
+    int colCutIndex_;
+    OsiCut *cutP_;
+  };
+
+  /** Const Iterator
+
+      This is a class for iterating over the collection of cuts.
+    */
+  class const_iterator {
+    friend class OsiCuts;
+
+  public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef OsiCut *value_type;
+    typedef size_t difference_type;
+    typedef OsiCut **pointer;
+    typedef OsiCut *&reference;
+
+  public:
+    const_iterator(const OsiCuts &cuts);
+    const_iterator(const const_iterator &src);
+    const_iterator &operator=(const const_iterator &rhs);
+    ~const_iterator();
+    const OsiCut *operator*() const { return cutP_; }
+
+    const_iterator operator++();
+
+    const_iterator operator++(int)
+    {
+      const_iterator temp = *this;
+      ++*this;
+      return temp;
+    }
+
+    bool operator==(const const_iterator &it) const
+    {
+      return (colCutIndex_ + rowCutIndex_) == (it.colCutIndex_ + it.rowCutIndex_);
+    }
+
+    bool operator!=(const const_iterator &it) const
+    {
+      return !((*this) == it);
+    }
+
+    bool operator<(const const_iterator &it) const
+    {
+      return (colCutIndex_ + rowCutIndex_) < (it.colCutIndex_ + it.rowCutIndex_);
+    }
+
+  private:
+    inline const_iterator();
+    // *THINK* : how to inline these without sticking the code here (ugly...)
+    const_iterator begin();
+    const_iterator end();
+    const OsiCuts *cutsPtr_;
+    int rowCutIndex_;
+    int colCutIndex_;
+    const OsiCut *cutP_;
+  };
+  //@}
+
+  //-------------------------------------------------------------------
+  //
+  // Cuts class definition begins here:
+  //
+  //-------------------------------------------------------------------
+
+  /** \name Inserting a cut into collection */
+  //@{
+  /** \brief Insert a row cut */
+  inline void insert(const OsiRowCut &rc);
+  /** \brief Insert a row cut unless it is a duplicate - cut may get sorted.
+       Duplicate is defined as CoinAbsFltEq says same*/
+  void insertIfNotDuplicate(OsiRowCut &rc, CoinAbsFltEq treatAsSame = CoinAbsFltEq(1.0e-12));
+  /** \brief Insert a row cut unless it is a duplicate - cut may get sorted.
+       Duplicate is defined as CoinRelFltEq says same*/
+  void insertIfNotDuplicate(OsiRowCut &rc, CoinRelFltEq treatAsSame);
+  /** \brief Insert a column cut */
+  inline void insert(const OsiColCut &cc);
+
+  /** \brief Insert a row cut.
+    
+      The OsiCuts object takes control of the cut object.
+      On return, \c rcPtr is NULL.
+    */
+  inline void insert(OsiRowCut *&rcPtr);
+  /** \brief Insert a column cut.
+    
+      The OsiCuts object takes control of the cut object.
+      On return \c ccPtr is NULL.
+    */
+  inline void insert(OsiColCut *&ccPtr);
+#if 0
+    inline void insert( OsiCut    * & cPtr  );
+#endif
+
+  /** \brief Insert a set of cuts */
+  inline void insert(const OsiCuts &cs);
+
+  //@}
+
+  /**@name Number of cuts in collection */
+  //@{
+  /// Number of row cuts in collection
+  inline int sizeRowCuts() const;
+  /// Number of column cuts in collection
+  inline int sizeColCuts() const;
+  /// Number of cuts in collection
+  inline int sizeCuts() const;
+  //@}
+
+  /**@name Debug stuff */
+  //@{
+  /// Print cuts in collection
+  inline void printCuts() const;
+  //@}
+
+  /**@name Get a cut from collection */
+  //@{
+  /// Get pointer to i'th row cut
+  inline OsiRowCut *rowCutPtr(int i);
+  /// Get const pointer to i'th row cut
+  inline const OsiRowCut *rowCutPtr(int i) const;
+  /// Get pointer to i'th column cut
+  inline OsiColCut *colCutPtr(int i);
+  /// Get const pointer to i'th column cut
+  inline const OsiColCut *colCutPtr(int i) const;
+
+  /// Get reference to i'th row cut
+  inline OsiRowCut &rowCut(int i);
+  /// Get const reference to i'th row cut
+  inline const OsiRowCut &rowCut(int i) const;
+  /// Get reference to i'th column cut
+  inline OsiColCut &colCut(int i);
+  /// Get const reference to i'th column cut
+  inline const OsiColCut &colCut(int i) const;
+
+  /// Get const pointer to the most effective cut
+  inline const OsiCut *mostEffectiveCutPtr() const;
+  /// Get pointer to the most effective cut
+  inline OsiCut *mostEffectiveCutPtr();
+  //@}
+
+  /**@name Deleting cut from collection */
+  //@{
+  /// Remove i'th row cut from collection
+  inline void eraseRowCut(int i);
+  /// Remove i'th column cut from collection
+  inline void eraseColCut(int i);
+  /// Get pointer to i'th row cut and remove ptr from collection
+  inline OsiRowCut *rowCutPtrAndZap(int i);
+  /*! \brief Clear all row cuts without deleting them
+    
+      Handy in case one wants to use CGL without managing cuts in one of
+      the OSI containers. Client is ultimately responsible for deleting the
+      data structures holding the row cuts.
+    */
+  inline void dumpCuts();
+  /*! \brief Selective delete and clear for row cuts.
+
+      Deletes the cuts specified in \p to_erase then clears remaining cuts
+      without deleting them. A hybrid of eraseRowCut(int) and dumpCuts().
+      Client is ultimately responsible for deleting the data structures
+      for row cuts not specified in \p to_erase.
+    */
+  inline void eraseAndDumpCuts(const std::vector< int > to_erase);
+  //@}
+
+  /**@name Sorting collection */
+  //@{
+  /// Cuts with greatest effectiveness are first.
+  inline void sort();
+  //@}
+
+  /**@name Iterators 
+     Example of using an iterator to sum effectiveness
+     of all cuts in the collection.
+     <pre>
+     double sumEff=0.0;
+     for ( OsiCuts::iterator it=cuts.begin(); it!=cuts.end(); ++it )
+           sumEff+= (*it)->effectiveness();
+     </pre>
+  */
+  //@{
+  /// Get iterator to beginning of collection
+  inline iterator begin()
+  {
+    iterator it(*this);
+    it.begin();
+    return it;
+  }
+  /// Get const iterator to beginning of collection
+  inline const_iterator begin() const
+  {
+    const_iterator it(*this);
+    it.begin();
+    return it;
+  }
+  /// Get iterator to end of collection
+  inline iterator end()
+  {
+    iterator it(*this);
+    it.end();
+    return it;
+  }
+  /// Get const iterator to end of collection
+  inline const_iterator end() const
+  {
+    const_iterator it(*this);
+    it.end();
+    return it;
+  }
+  //@}
+
+  /**@name Constructors and destructors */
+  //@{
+  /// Default constructor
+  OsiCuts();
+
+  /// Copy constructor
+  OsiCuts(const OsiCuts &);
+
+  /// Assignment operator
+  OsiCuts &operator=(const OsiCuts &rhs);
+
+  /// Destructor
+  virtual ~OsiCuts();
+  //@}
+
+private:
+  //*@name Function operator for sorting cuts by efectiveness */
+  //@{
+  class OsiCutCompare {
+  public:
+    /// Function for sorting cuts by effectiveness
+    inline bool operator()(const OsiCut *c1P, const OsiCut *c2P)
+    {
+      return c1P->effectiveness() > c2P->effectiveness();
+    }
+  };
+  //@}
+
+  /**@name Private methods */
+  //@{
+  /// Copy internal data
+  void gutsOfCopy(const OsiCuts &source);
+  /// Delete internal data
+  void gutsOfDestructor();
+  //@}
+
+  /**@name Private member data */
+  //@{
+  /// Vector of row cuts pointers
+  OsiVectorRowCutPtr rowCutPtrs_;
+  /// Vector of column cuts pointers
+  OsiVectorColCutPtr colCutPtrs_;
+  //@}
+};
+
+//-------------------------------------------------------------------
+// insert cuts into collection
+//-------------------------------------------------------------------
+void OsiCuts::insert(const OsiRowCut &rc)
+{
+  OsiRowCut *newCutPtr = rc.clone();
+  //assert(dynamic_cast<OsiRowCut*>(newCutPtr) != NULL );
+  rowCutPtrs_.push_back(static_cast< OsiRowCut * >(newCutPtr));
+}
+void OsiCuts::insert(const OsiColCut &cc)
+{
+  OsiColCut *newCutPtr = cc.clone();
+  //assert(dynamic_cast<OsiColCut*>(newCutPtr) != NULL );
+  colCutPtrs_.push_back(static_cast< OsiColCut * >(newCutPtr));
+}
+
+void OsiCuts::insert(OsiRowCut *&rcPtr)
+{
+  rowCutPtrs_.push_back(rcPtr);
+  rcPtr = NULL;
+}
+void OsiCuts::insert(OsiColCut *&ccPtr)
+{
+  colCutPtrs_.push_back(ccPtr);
+  ccPtr = NULL;
+}
+#if 0
+void OsiCuts::insert( OsiCut* & cPtr )
+{
+  OsiRowCut * rcPtr = dynamic_cast<OsiRowCut*>(cPtr);
+  if ( rcPtr != NULL ) {
+    insert( rcPtr );
+    cPtr = rcPtr;
+  }
+  else {
+    OsiColCut * ccPtr = dynamic_cast<OsiColCut*>(cPtr);
+    assert( ccPtr != NULL );
+    insert( ccPtr );
+    cPtr = ccPtr;
+  }
+}
+#endif
+
+// LANNEZ SEBASTIEN added Thu May 25 01:22:51 EDT 2006
+void OsiCuts::insert(const OsiCuts &cs)
+{
+  for (OsiCuts::const_iterator it = cs.begin(); it != cs.end(); it++) {
+    const OsiRowCut *rCut = dynamic_cast< const OsiRowCut * >(*it);
+    const OsiColCut *cCut = dynamic_cast< const OsiColCut * >(*it);
+    assert(rCut || cCut);
+    if (rCut)
+      insert(*rCut);
+    else
+      insert(*cCut);
+  }
+}
+
+//-------------------------------------------------------------------
+// sort
+//-------------------------------------------------------------------
+void OsiCuts::sort()
+{
+  std::sort(colCutPtrs_.begin(), colCutPtrs_.end(), OsiCutCompare());
+  std::sort(rowCutPtrs_.begin(), rowCutPtrs_.end(), OsiCutCompare());
+}
+
+//-------------------------------------------------------------------
+// Get number of in collections
+//-------------------------------------------------------------------
+int OsiCuts::sizeRowCuts() const
+{
+  return static_cast< int >(rowCutPtrs_.size());
+}
+int OsiCuts::sizeColCuts() const
+{
+  return static_cast< int >(colCutPtrs_.size());
+}
+int OsiCuts::sizeCuts() const
+{
+  return static_cast< int >(sizeRowCuts() + sizeColCuts());
+}
+
+//----------------------------------------------------------------
+// Get i'th cut from the collection
+//----------------------------------------------------------------
+const OsiRowCut *OsiCuts::rowCutPtr(int i) const { return rowCutPtrs_[i]; }
+const OsiColCut *OsiCuts::colCutPtr(int i) const { return colCutPtrs_[i]; }
+OsiRowCut *OsiCuts::rowCutPtr(int i) { return rowCutPtrs_[i]; }
+OsiColCut *OsiCuts::colCutPtr(int i) { return colCutPtrs_[i]; }
+
+const OsiRowCut &OsiCuts::rowCut(int i) const { return *rowCutPtr(i); }
+const OsiColCut &OsiCuts::colCut(int i) const { return *colCutPtr(i); }
+OsiRowCut &OsiCuts::rowCut(int i) { return *rowCutPtr(i); }
+OsiColCut &OsiCuts::colCut(int i) { return *colCutPtr(i); }
+
+//----------------------------------------------------------------
+// Get most effective cut from collection
+//----------------------------------------------------------------
+const OsiCut *OsiCuts::mostEffectiveCutPtr() const
+{
+  const_iterator b = begin();
+  const_iterator e = end();
+  return *(std::min_element(b, e, OsiCutCompare()));
+}
+OsiCut *OsiCuts::mostEffectiveCutPtr()
+{
+  iterator b = begin();
+  iterator e = end();
+  //return *(std::min_element(b,e,OsiCutCompare()));
+  OsiCut *retVal = NULL;
+  double maxEff = COIN_DBL_MIN;
+  for (OsiCuts::iterator it = b; it != e; ++it) {
+    if (maxEff < (*it)->effectiveness()) {
+      maxEff = (*it)->effectiveness();
+      retVal = *it;
+    }
+  }
+  return retVal;
+}
+
+//----------------------------------------------------------------
+// Print all cuts
+//----------------------------------------------------------------
+void OsiCuts::printCuts() const
+{
+  // do all column cuts first
+  int i;
+  int numberColCuts = sizeColCuts();
+  for (i = 0; i < numberColCuts; i++) {
+    const OsiColCut *cut = colCutPtr(i);
+    cut->print();
+  }
+  int numberRowCuts = sizeRowCuts();
+  for (i = 0; i < numberRowCuts; i++) {
+    const OsiRowCut *cut = rowCutPtr(i);
+    cut->print();
+  }
+}
+
+//----------------------------------------------------------------
+// Erase i'th cut from the collection
+//----------------------------------------------------------------
+void OsiCuts::eraseRowCut(int i)
+{
+  delete rowCutPtrs_[i];
+  rowCutPtrs_.erase(rowCutPtrs_.begin() + i);
+}
+void OsiCuts::eraseColCut(int i)
+{
+  delete colCutPtrs_[i];
+  colCutPtrs_.erase(colCutPtrs_.begin() + i);
+}
+/// Get pointer to i'th row cut and remove ptr from collection
+OsiRowCut *
+OsiCuts::rowCutPtrAndZap(int i)
+{
+  OsiRowCut *cut = rowCutPtrs_[i];
+  rowCutPtrs_[i] = NULL;
+  rowCutPtrs_.erase(rowCutPtrs_.begin() + i);
+  return cut;
+}
+void OsiCuts::dumpCuts()
+{
+  rowCutPtrs_.clear();
+}
+void OsiCuts::eraseAndDumpCuts(const std::vector< int > to_erase)
+{
+  for (unsigned i = 0; i < to_erase.size(); i++) {
+    delete rowCutPtrs_[to_erase[i]];
+  }
+  rowCutPtrs_.clear();
+}
+
+#endif
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/