OsiCuts.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 #ifndef OsiCuts_H
4 #define OsiCuts_H
5 
6 #if defined(_MSC_VER)
7 // Turn off compiler warning about long names
8 # pragma warning(disable:4786)
9 #endif
10 
11 #include <cmath>
12 #include <cfloat>
13 #include "OsiCollections.hpp"
14 #include "OsiRowCut.hpp"
15 #include "OsiColCut.hpp"
16 #include "CoinFloatEqual.hpp"
17 
20 class OsiCuts {
21  friend void OsiCutsUnitTest();
22 
23 public:
31  class iterator {
32  friend class OsiCuts;
33  public:
34  iterator(OsiCuts& cuts);
35  iterator(const iterator & src);
36  iterator & operator=( const iterator& rhs);
37  ~iterator ();
38  OsiCut* operator*() const { return cutP_; }
40 
42  {
43  iterator temp = *this;
44  ++*this;
45  return temp;
46  }
47 
48  bool operator==(const iterator& it) const {
50  }
51 
52  bool operator!=(const iterator& it) const {
53  return !((*this)==it);
54  }
55 
56  bool operator<(const iterator& it) const {
58  }
59 
60  private:
61  iterator();
62  // *THINK* : how to inline these without sticking the code here (ugly...)
63  iterator begin();
64  iterator end();
69  };
70 
76  friend class OsiCuts;
77  public:
78  typedef std::bidirectional_iterator_tag iterator_category;
79  typedef OsiCut* value_type;
80  typedef size_t difference_type;
81  typedef OsiCut ** pointer;
82  typedef OsiCut *& reference;
83 
84  public:
85  const_iterator(const OsiCuts& cuts);
86  const_iterator(const const_iterator & src);
87  const_iterator & operator=( const const_iterator& rhs);
88  ~const_iterator ();
89  const OsiCut* operator*() const { return cutP_; }
90 
92 
94  {
95  const_iterator temp = *this;
96  ++*this;
97  return temp;
98  }
99 
100  bool operator==(const const_iterator& it) const {
102  }
103 
104  bool operator!=(const const_iterator& it) const {
105  return !((*this)==it);
106  }
107 
108  bool operator<(const const_iterator& it) const {
110  }
111  private:
112  inline const_iterator();
113  // *THINK* : how to inline these without sticking the code here (ugly...)
116  const OsiCuts * cutsPtr_;
119  const OsiCut * cutP_;
120  };
122 
123  //-------------------------------------------------------------------
124  //
125  // Cuts class definition begins here:
126  //
127  //-------------------------------------------------------------------
128 
132  inline void insert( const OsiRowCut & rc );
135  void insertIfNotDuplicate( OsiRowCut & rc , CoinAbsFltEq treatAsSame=CoinAbsFltEq(1.0e-12) );
138  void insertIfNotDuplicate( OsiRowCut & rc , CoinRelFltEq treatAsSame );
140  inline void insert( const OsiColCut & cc );
141 
147  inline void insert( OsiRowCut * & rcPtr );
153  inline void insert( OsiColCut * & ccPtr );
154 #if 0
155  inline void insert( OsiCut * & cPtr );
156 #endif
157 
159  inline void insert(const OsiCuts & cs);
160 
162 
165  inline int sizeRowCuts() const;
168  inline int sizeColCuts() const;
170  inline int sizeCuts() const;
172 
175  inline void printCuts() const;
178 
181  inline OsiRowCut * rowCutPtr(int i);
184  inline const OsiRowCut * rowCutPtr(int i) const;
186  inline OsiColCut * colCutPtr(int i);
188  inline const OsiColCut * colCutPtr(int i) const;
189 
191  inline OsiRowCut & rowCut(int i);
193  inline const OsiRowCut & rowCut(int i) const;
195  inline OsiColCut & colCut(int i);
197  inline const OsiColCut & colCut(int i) const;
198 
200  inline const OsiCut * mostEffectiveCutPtr() const;
202  inline OsiCut * mostEffectiveCutPtr();
204 
207  inline void eraseRowCut(int i);
210  inline void eraseColCut(int i);
212  inline OsiRowCut * rowCutPtrAndZap(int i);
219  inline void dumpCuts() ;
227  inline void eraseAndDumpCuts(const std::vector<int> to_erase) ;
229 
232  inline void sort();
235 
236 
247  inline iterator begin() { iterator it(*this); it.begin(); return it; }
250  inline const_iterator begin() const { const_iterator it(*this); it.begin(); return it; }
252  inline iterator end() { iterator it(*this); it.end(); return it; }
254  inline const_iterator end() const { const_iterator it(*this); it.end(); return it; }
256 
257 
260  OsiCuts ();
262 
264  OsiCuts ( const OsiCuts &);
265 
267  OsiCuts & operator=( const OsiCuts& rhs);
268 
270  virtual ~OsiCuts ();
272 
273 private:
274  //*@name Function operator for sorting cuts by efectiveness */
277  {
278  public:
280  inline bool operator()(const OsiCut * c1P,const OsiCut * c2P)
281  { return c1P->effectiveness() > c2P->effectiveness(); }
282  };
284 
287  void gutsOfCopy( const OsiCuts & source );
290  void gutsOfDestructor();
292 
300 
301 };
302 
303 
304 //-------------------------------------------------------------------
305 // insert cuts into collection
306 //-------------------------------------------------------------------
307 void OsiCuts::insert( const OsiRowCut & rc )
308 {
309  OsiRowCut * newCutPtr = rc.clone();
310  //assert(dynamic_cast<OsiRowCut*>(newCutPtr) != NULL );
311  rowCutPtrs_.push_back(static_cast<OsiRowCut*>(newCutPtr));
312 }
313 void OsiCuts::insert( const OsiColCut & cc )
314 {
315  OsiColCut * newCutPtr = cc.clone();
316  //assert(dynamic_cast<OsiColCut*>(newCutPtr) != NULL );
317  colCutPtrs_.push_back(static_cast<OsiColCut*>(newCutPtr));
318 }
319 
320 void OsiCuts::insert( OsiRowCut* & rcPtr )
321 {
322  rowCutPtrs_.push_back(rcPtr);
323  rcPtr = NULL;
324 }
325 void OsiCuts::insert( OsiColCut* &ccPtr )
326 {
327  colCutPtrs_.push_back(ccPtr);
328  ccPtr = NULL;
329 }
330 #if 0
331 void OsiCuts::insert( OsiCut* & cPtr )
332 {
333  OsiRowCut * rcPtr = dynamic_cast<OsiRowCut*>(cPtr);
334  if ( rcPtr != NULL ) {
335  insert( rcPtr );
336  cPtr = rcPtr;
337  }
338  else {
339  OsiColCut * ccPtr = dynamic_cast<OsiColCut*>(cPtr);
340  assert( ccPtr != NULL );
341  insert( ccPtr );
342  cPtr = ccPtr;
343  }
344 }
345 #endif
346 
347 // LANNEZ SEBASTIEN added Thu May 25 01:22:51 EDT 2006
348 void OsiCuts::insert(const OsiCuts & cs)
349 {
350  for (OsiCuts::const_iterator it = cs.begin (); it != cs.end (); it++)
351  {
352  const OsiRowCut * rCut = dynamic_cast <const OsiRowCut * >(*it);
353  const OsiColCut * cCut = dynamic_cast <const OsiColCut * >(*it);
354  assert (rCut || cCut);
355  if (rCut)
356  insert (*rCut);
357  else
358  insert (*cCut);
359  }
360 }
361 
362 //-------------------------------------------------------------------
363 // sort
364 //-------------------------------------------------------------------
366 {
367  std::sort(colCutPtrs_.begin(),colCutPtrs_.end(),OsiCutCompare());
368  std::sort(rowCutPtrs_.begin(),rowCutPtrs_.end(),OsiCutCompare());
369 }
370 
371 
372 //-------------------------------------------------------------------
373 // Get number of in collections
374 //-------------------------------------------------------------------
375 int OsiCuts::sizeRowCuts() const {
376  return static_cast<int>(rowCutPtrs_.size()); }
377 int OsiCuts::sizeColCuts() const {
378  return static_cast<int>(colCutPtrs_.size()); }
379 int OsiCuts::sizeCuts() const {
380  return static_cast<int>(sizeRowCuts()+sizeColCuts()); }
381 
382 //----------------------------------------------------------------
383 // Get i'th cut from the collection
384 //----------------------------------------------------------------
385 const OsiRowCut * OsiCuts::rowCutPtr(int i) const { return rowCutPtrs_[i]; }
386 const OsiColCut * OsiCuts::colCutPtr(int i) const { return colCutPtrs_[i]; }
387 OsiRowCut * OsiCuts::rowCutPtr(int i) { return rowCutPtrs_[i]; }
388 OsiColCut * OsiCuts::colCutPtr(int i) { return colCutPtrs_[i]; }
389 
390 const OsiRowCut & OsiCuts::rowCut(int i) const { return *rowCutPtr(i); }
391 const OsiColCut & OsiCuts::colCut(int i) const { return *colCutPtr(i); }
392 OsiRowCut & OsiCuts::rowCut(int i) { return *rowCutPtr(i); }
393 OsiColCut & OsiCuts::colCut(int i) { return *colCutPtr(i); }
394 
395 //----------------------------------------------------------------
396 // Get most effective cut from collection
397 //----------------------------------------------------------------
399 {
400  const_iterator b=begin();
401  const_iterator e=end();
402  return *(std::min_element(b,e,OsiCutCompare()));
403 }
405 {
406  iterator b=begin();
407  iterator e=end();
408  //return *(std::min_element(b,e,OsiCutCompare()));
409  OsiCut * retVal = NULL;
410  double maxEff = DBL_MIN;
411  for ( OsiCuts::iterator it=b; it!=e; ++it ) {
412  if (maxEff < (*it)->effectiveness() ) {
413  maxEff = (*it)->effectiveness();
414  retVal = *it;
415  }
416  }
417  return retVal;
418 }
419 
420 //----------------------------------------------------------------
421 // Print all cuts
422 //----------------------------------------------------------------
423 void
425 {
426  // do all column cuts first
427  int i;
428  int numberColCuts=sizeColCuts();
429  for (i=0;i<numberColCuts;i++) {
430  const OsiColCut * cut = colCutPtr(i);
431  cut->print();
432  }
433  int numberRowCuts=sizeRowCuts();
434  for (i=0;i<numberRowCuts;i++) {
435  const OsiRowCut * cut = rowCutPtr(i);
436  cut->print();
437  }
438 }
439 
440 //----------------------------------------------------------------
441 // Erase i'th cut from the collection
442 //----------------------------------------------------------------
444 {
445  delete rowCutPtrs_[i];
446  rowCutPtrs_.erase( rowCutPtrs_.begin()+i );
447 }
449 {
450  delete colCutPtrs_[i];
451  colCutPtrs_.erase( colCutPtrs_.begin()+i );
452 }
454 OsiRowCut *
456 {
457  OsiRowCut * cut = rowCutPtrs_[i];
458  rowCutPtrs_[i]=NULL;
459  rowCutPtrs_.erase( rowCutPtrs_.begin()+i );
460  return cut;
461 }
463 {
464  rowCutPtrs_.clear() ;
465 }
466 void OsiCuts::eraseAndDumpCuts(const std::vector<int> to_erase)
467 {
468  for (unsigned i=0; i<to_erase.size(); i++) {
469  delete rowCutPtrs_[to_erase[i]];
470  }
471  rowCutPtrs_.clear();
472 }
473 
474 //#############################################################################
480 void
482 
483 #endif