/home/coin/SVN-release/CoinAll-1.1.0/Osi/src/OsiCuts.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef OsiCuts_H
#define OsiCuts_H

#if defined(_MSC_VER)
// Turn off compiler warning about long names
#  pragma warning(disable:4786)
#endif

#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::bidirectional_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 rowCutPtrs_.size(); }
int OsiCuts::sizeColCuts() const { return colCutPtrs_.size(); }
int OsiCuts::sizeCuts()    const { return 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 = 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();
}

//#############################################################################
void
OsiCutsUnitTest();

#endif

---