OsiCuts.hpp

Go to the documentation of this file.

// 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"
 
class OsiCuts {
  friend void OsiCutsUnitTest();
 
public:
  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_;
  };
 
  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:
  //
  //-------------------------------------------------------------------
 
  inline void insert(const OsiRowCut &rc);
  void insertIfNotDuplicate(OsiRowCut &rc, CoinAbsFltEq treatAsSame = CoinAbsFltEq(1.0e-12));
  void insertIfNotDuplicate(OsiRowCut &rc, CoinRelFltEq treatAsSame);
  inline void insert(const OsiColCut &cc);
 
  inline void insert(OsiRowCut *&rcPtr);
  inline void insert(OsiColCut *&ccPtr);
#if 0
    inline void insert( OsiCut    * & cPtr  );
#endif
 
  inline void insert(const OsiCuts &cs);
 
 
  inline int sizeRowCuts() const;
  inline int sizeColCuts() const;
  inline int sizeCuts() const;
 
  inline void printCuts() const;
 
  inline OsiRowCut *rowCutPtr(int i);
  inline const OsiRowCut *rowCutPtr(int i) const;
  inline OsiColCut *colCutPtr(int i);
  inline const OsiColCut *colCutPtr(int i) const;
 
  inline OsiRowCut &rowCut(int i);
  inline const OsiRowCut &rowCut(int i) const;
  inline OsiColCut &colCut(int i);
  inline const OsiColCut &colCut(int i) const;
 
  inline const OsiCut *mostEffectiveCutPtr() const;
  inline OsiCut *mostEffectiveCutPtr();
 
  inline void eraseRowCut(int i);
  inline void eraseColCut(int i);
  inline OsiRowCut *rowCutPtrAndZap(int i);
  inline void dumpCuts();
  inline void eraseAndDumpCuts(const std::vector< int > to_erase);
 
  inline void sort();
 
  inline iterator begin()
  {
    iterator it(*this);
    it.begin();
    return it;
  }
  inline const_iterator begin() const
  {
    const_iterator it(*this);
    it.begin();
    return it;
  }
  inline iterator end()
  {
    iterator it(*this);
    it.end();
    return it;
  }
  inline const_iterator end() const
  {
    const_iterator it(*this);
    it.end();
    return it;
  }
 
  OsiCuts();
 
  OsiCuts(const OsiCuts &);
 
  OsiCuts &operator=(const OsiCuts &rhs);
 
  virtual ~OsiCuts();
 
private:
  //*@name Function operator for sorting cuts by efectiveness */
  class OsiCutCompare {
  public:
    inline bool operator()(const OsiCut *c1P, const OsiCut *c2P)
    {
      return c1P->effectiveness() > c2P->effectiveness();
    }
  };
 
  void gutsOfCopy(const OsiCuts &source);
  void gutsOfDestructor();
 
  OsiVectorRowCutPtr rowCutPtrs_;
  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);
}
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
*/