Cbc  2.10.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OsiCuts.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 // This code is licensed under the terms of the Eclipse Public License (EPL).
4 
5 #ifndef OsiCuts_H
6 #define OsiCuts_H
7 
8 #include "CoinPragma.hpp"
9 
10 #include <cmath>
11 #include <cfloat>
12 #include "OsiCollections.hpp"
13 #include "OsiRowCut.hpp"
14 #include "OsiColCut.hpp"
15 #include "CoinFloatEqual.hpp"
16 
19 class OsiCuts {
20  friend void OsiCutsUnitTest();
21 
22 public:
30  class iterator {
31  friend class OsiCuts;
32 
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
49  {
50  return (colCutIndex_ + rowCutIndex_) == (it.colCutIndex_ + it.rowCutIndex_);
51  }
52 
53  bool operator!=(const iterator &it) const
54  {
55  return !((*this) == it);
56  }
57 
58  bool operator<(const iterator &it) const
59  {
60  return (colCutIndex_ + rowCutIndex_) < (it.colCutIndex_ + it.rowCutIndex_);
61  }
62 
63  private:
64  iterator();
65  // *THINK* : how to inline these without sticking the code here (ugly...)
66  iterator begin();
67  iterator end();
72  };
73 
79  friend class OsiCuts;
80 
81  public:
82  typedef std::forward_iterator_tag iterator_category;
83  typedef OsiCut *value_type;
84  typedef size_t difference_type;
85  typedef OsiCut **pointer;
86  typedef OsiCut *&reference;
87 
88  public:
89  const_iterator(const OsiCuts &cuts);
90  const_iterator(const const_iterator &src);
93  const OsiCut *operator*() const { return cutP_; }
94 
96 
98  {
99  const_iterator temp = *this;
100  ++*this;
101  return temp;
102  }
103 
104  bool operator==(const const_iterator &it) const
105  {
106  return (colCutIndex_ + rowCutIndex_) == (it.colCutIndex_ + it.rowCutIndex_);
107  }
108 
109  bool operator!=(const const_iterator &it) const
110  {
111  return !((*this) == it);
112  }
113 
114  bool operator<(const const_iterator &it) const
115  {
116  return (colCutIndex_ + rowCutIndex_) < (it.colCutIndex_ + it.rowCutIndex_);
117  }
118 
119  private:
120  inline const_iterator();
121  // *THINK* : how to inline these without sticking the code here (ugly...)
127  const OsiCut *cutP_;
128  };
130 
131  //-------------------------------------------------------------------
132  //
133  // Cuts class definition begins here:
134  //
135  //-------------------------------------------------------------------
136 
140  inline void insert(const OsiRowCut &rc);
143  void insertIfNotDuplicate(OsiRowCut &rc, CoinAbsFltEq treatAsSame = CoinAbsFltEq(1.0e-12));
146  void insertIfNotDuplicate(OsiRowCut &rc, CoinRelFltEq treatAsSame);
148  inline void insert(const OsiColCut &cc);
149 
155  inline void insert(OsiRowCut *&rcPtr);
161  inline void insert(OsiColCut *&ccPtr);
162 #if 0
163  inline void insert( OsiCut * & cPtr );
164 #endif
165 
167  inline void insert(const OsiCuts &cs);
168 
170 
173  inline int sizeRowCuts() const;
176  inline int sizeColCuts() const;
178  inline int sizeCuts() const;
180 
183  inline void printCuts() const;
186 
189  inline OsiRowCut *rowCutPtr(int i);
192  inline const OsiRowCut *rowCutPtr(int i) const;
194  inline OsiColCut *colCutPtr(int i);
196  inline const OsiColCut *colCutPtr(int i) const;
197 
199  inline OsiRowCut &rowCut(int i);
201  inline const OsiRowCut &rowCut(int i) const;
203  inline OsiColCut &colCut(int i);
205  inline const OsiColCut &colCut(int i) const;
206 
208  inline const OsiCut *mostEffectiveCutPtr() const;
210  inline OsiCut *mostEffectiveCutPtr();
212 
215  inline void eraseRowCut(int i);
218  inline void eraseColCut(int i);
220  inline OsiRowCut *rowCutPtrAndZap(int i);
227  inline void dumpCuts();
235  inline void eraseAndDumpCuts(const std::vector< int > to_erase);
237 
240  inline void sort();
243 
254  inline iterator begin()
256  {
257  iterator it(*this);
258  it.begin();
259  return it;
260  }
262  inline const_iterator begin() const
263  {
264  const_iterator it(*this);
265  it.begin();
266  return it;
267  }
269  inline iterator end()
270  {
271  iterator it(*this);
272  it.end();
273  return it;
274  }
276  inline const_iterator end() const
277  {
278  const_iterator it(*this);
279  it.end();
280  return it;
281  }
283 
286  OsiCuts();
288 
290  OsiCuts(const OsiCuts &);
291 
293  OsiCuts &operator=(const OsiCuts &rhs);
294 
296  virtual ~OsiCuts();
298 
299 private:
300  //*@name Function operator for sorting cuts by efectiveness */
303  public:
305  inline bool operator()(const OsiCut *c1P, const OsiCut *c2P)
306  {
307  return c1P->effectiveness() > c2P->effectiveness();
308  }
309  };
311 
314  void gutsOfCopy(const OsiCuts &source);
317  void gutsOfDestructor();
319 
327 };
328 
329 //-------------------------------------------------------------------
330 // insert cuts into collection
331 //-------------------------------------------------------------------
332 void OsiCuts::insert(const OsiRowCut &rc)
333 {
334  OsiRowCut *newCutPtr = rc.clone();
335  //assert(dynamic_cast<OsiRowCut*>(newCutPtr) != NULL );
336  rowCutPtrs_.push_back(static_cast< OsiRowCut * >(newCutPtr));
337 }
338 void OsiCuts::insert(const OsiColCut &cc)
339 {
340  OsiColCut *newCutPtr = cc.clone();
341  //assert(dynamic_cast<OsiColCut*>(newCutPtr) != NULL );
342  colCutPtrs_.push_back(static_cast< OsiColCut * >(newCutPtr));
343 }
344 
346 {
347  rowCutPtrs_.push_back(rcPtr);
348  rcPtr = NULL;
349 }
351 {
352  colCutPtrs_.push_back(ccPtr);
353  ccPtr = NULL;
354 }
355 #if 0
356 void OsiCuts::insert( OsiCut* & cPtr )
357 {
358  OsiRowCut * rcPtr = dynamic_cast<OsiRowCut*>(cPtr);
359  if ( rcPtr != NULL ) {
360  insert( rcPtr );
361  cPtr = rcPtr;
362  }
363  else {
364  OsiColCut * ccPtr = dynamic_cast<OsiColCut*>(cPtr);
365  assert( ccPtr != NULL );
366  insert( ccPtr );
367  cPtr = ccPtr;
368  }
369 }
370 #endif
371 
372 // LANNEZ SEBASTIEN added Thu May 25 01:22:51 EDT 2006
373 void OsiCuts::insert(const OsiCuts &cs)
374 {
375  for (OsiCuts::const_iterator it = cs.begin(); it != cs.end(); it++) {
376  const OsiRowCut *rCut = dynamic_cast< const OsiRowCut * >(*it);
377  const OsiColCut *cCut = dynamic_cast< const OsiColCut * >(*it);
378  assert(rCut || cCut);
379  if (rCut)
380  insert(*rCut);
381  else
382  insert(*cCut);
383  }
384 }
385 
386 //-------------------------------------------------------------------
387 // sort
388 //-------------------------------------------------------------------
390 {
391  std::sort(colCutPtrs_.begin(), colCutPtrs_.end(), OsiCutCompare());
392  std::sort(rowCutPtrs_.begin(), rowCutPtrs_.end(), OsiCutCompare());
393 }
394 
395 //-------------------------------------------------------------------
396 // Get number of in collections
397 //-------------------------------------------------------------------
399 {
400  return static_cast< int >(rowCutPtrs_.size());
401 }
403 {
404  return static_cast< int >(colCutPtrs_.size());
405 }
406 int OsiCuts::sizeCuts() const
407 {
408  return static_cast< int >(sizeRowCuts() + sizeColCuts());
409 }
410 
411 //----------------------------------------------------------------
412 // Get i'th cut from the collection
413 //----------------------------------------------------------------
414 const OsiRowCut *OsiCuts::rowCutPtr(int i) const { return rowCutPtrs_[i]; }
415 const OsiColCut *OsiCuts::colCutPtr(int i) const { return colCutPtrs_[i]; }
418 
419 const OsiRowCut &OsiCuts::rowCut(int i) const { return *rowCutPtr(i); }
420 const OsiColCut &OsiCuts::colCut(int i) const { return *colCutPtr(i); }
421 OsiRowCut &OsiCuts::rowCut(int i) { return *rowCutPtr(i); }
422 OsiColCut &OsiCuts::colCut(int i) { return *colCutPtr(i); }
423 
424 //----------------------------------------------------------------
425 // Get most effective cut from collection
426 //----------------------------------------------------------------
428 {
429  const_iterator b = begin();
430  const_iterator e = end();
431  return *(std::min_element(b, e, OsiCutCompare()));
432 }
434 {
435  iterator b = begin();
436  iterator e = end();
437  //return *(std::min_element(b,e,OsiCutCompare()));
438  OsiCut *retVal = NULL;
439  double maxEff = COIN_DBL_MIN;
440  for (OsiCuts::iterator it = b; it != e; ++it) {
441  if (maxEff < (*it)->effectiveness()) {
442  maxEff = (*it)->effectiveness();
443  retVal = *it;
444  }
445  }
446  return retVal;
447 }
448 
449 //----------------------------------------------------------------
450 // Print all cuts
451 //----------------------------------------------------------------
452 void OsiCuts::printCuts() const
453 {
454  // do all column cuts first
455  int i;
456  int numberColCuts = sizeColCuts();
457  for (i = 0; i < numberColCuts; i++) {
458  const OsiColCut *cut = colCutPtr(i);
459  cut->print();
460  }
461  int numberRowCuts = sizeRowCuts();
462  for (i = 0; i < numberRowCuts; i++) {
463  const OsiRowCut *cut = rowCutPtr(i);
464  cut->print();
465  }
466 }
467 
468 //----------------------------------------------------------------
469 // Erase i'th cut from the collection
470 //----------------------------------------------------------------
472 {
473  delete rowCutPtrs_[i];
474  rowCutPtrs_.erase(rowCutPtrs_.begin() + i);
475 }
477 {
478  delete colCutPtrs_[i];
479  colCutPtrs_.erase(colCutPtrs_.begin() + i);
480 }
482 OsiRowCut *
484 {
485  OsiRowCut *cut = rowCutPtrs_[i];
486  rowCutPtrs_[i] = NULL;
487  rowCutPtrs_.erase(rowCutPtrs_.begin() + i);
488  return cut;
489 }
491 {
492  rowCutPtrs_.clear();
493 }
494 void OsiCuts::eraseAndDumpCuts(const std::vector< int > to_erase)
495 {
496  for (unsigned i = 0; i < to_erase.size(); i++) {
497  delete rowCutPtrs_[to_erase[i]];
498  }
499  rowCutPtrs_.clear();
500 }
501 
502 #endif
503 
504 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
505 */
void gutsOfDestructor()
Delete internal data.
OsiVectorColCutPtr colCutPtrs_
Vector of column cuts pointers.
Definition: OsiCuts.hpp:325
const_iterator operator++(int)
Definition: OsiCuts.hpp:97
void dumpCuts()
Clear all row cuts without deleting them.
Definition: OsiCuts.hpp:490
virtual ~OsiCuts()
Destructor.
virtual OsiColCut * clone() const
Clone.
iterator begin()
Get iterator to beginning of collection.
Definition: OsiCuts.hpp:255
OsiRowCut * rowCutPtrAndZap(int i)
Get pointer to i&#39;th row cut and remove ptr from collection.
Definition: OsiCuts.hpp:483
void insertIfNotDuplicate(OsiRowCut &rc, CoinAbsFltEq treatAsSame=CoinAbsFltEq(1.0e-12))
Insert a row cut unless it is a duplicate - cut may get sorted.
const_iterator operator++()
iterator begin()
double effectiveness() const
Get effectiveness.
Definition: OsiCut.hpp:217
OsiRowCut * rowCutPtr(int i)
Get pointer to i&#39;th row cut.
Definition: OsiCuts.hpp:416
const_iterator begin() const
Get const iterator to beginning of collection.
Definition: OsiCuts.hpp:262
void eraseColCut(int i)
Remove i&#39;th column cut from collection.
Definition: OsiCuts.hpp:476
OsiCuts & cuts_
Definition: OsiCuts.hpp:68
OsiCut * operator*() const
Definition: OsiCuts.hpp:38
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
Const Iterator.
Definition: OsiCuts.hpp:78
iterator operator++()
virtual OsiRowCut * clone() const
Clone.
OsiCut * cutP_
Definition: OsiCuts.hpp:71
const OsiCuts * cutsPtr_
Definition: OsiCuts.hpp:124
virtual void print() const
Print cuts in collection.
virtual void print() const
Print cuts in collection.
bool operator<(const const_iterator &it) const
Definition: OsiCuts.hpp:114
const_iterator end() const
Get const iterator to end of collection.
Definition: OsiCuts.hpp:276
const double COIN_DBL_MIN
Definition: CoinFinite.hpp:17
OsiColCut * colCutPtr(int i)
Get pointer to i&#39;th column cut.
Definition: OsiCuts.hpp:417
const OsiCut * mostEffectiveCutPtr() const
Get const pointer to the most effective cut.
Definition: OsiCuts.hpp:427
std::vector< OsiColCut * > OsiVectorColCutPtr
Vector of OsiColCut pointers.
const_iterator end()
const_iterator & operator=(const const_iterator &rhs)
const OsiCut * operator*() const
Definition: OsiCuts.hpp:93
const OsiCut * cutP_
Definition: OsiCuts.hpp:127
Iterator.
Definition: OsiCuts.hpp:30
Equality to a scaled tolerance.
bool operator!=(const iterator &it) const
Definition: OsiCuts.hpp:53
std::forward_iterator_tag iterator_category
Definition: OsiCuts.hpp:82
friend void OsiCutsUnitTest()
A function that tests the methods in the OsiCuts class.
iterator & operator=(const iterator &rhs)
OsiRowCut & rowCut(int i)
Get reference to i&#39;th row cut.
Definition: OsiCuts.hpp:421
void eraseRowCut(int i)
Remove i&#39;th row cut from collection.
Definition: OsiCuts.hpp:471
bool operator!=(const const_iterator &it) const
Definition: OsiCuts.hpp:109
bool operator==(const const_iterator &it) const
Definition: OsiCuts.hpp:104
Row Cut Class.
Definition: OsiRowCut.hpp:29
void printCuts() const
Print cuts in collection.
Definition: OsiCuts.hpp:452
void eraseAndDumpCuts(const std::vector< int > to_erase)
Selective delete and clear for row cuts.
Definition: OsiCuts.hpp:494
Equality to an absolute tolerance.
void insert(const OsiRowCut &rc)
Insert a row cut.
Definition: OsiCuts.hpp:332
Function objects for testing equality of real numbers.
int sizeCuts() const
Number of cuts in collection.
Definition: OsiCuts.hpp:406
void gutsOfCopy(const OsiCuts &source)
Copy internal data.
const_iterator begin()
OsiColCut & colCut(int i)
Get reference to i&#39;th column cut.
Definition: OsiCuts.hpp:422
void sort()
Cuts with greatest effectiveness are first.
Definition: OsiCuts.hpp:389
iterator operator++(int)
Definition: OsiCuts.hpp:41
OsiCuts & operator=(const OsiCuts &rhs)
Assignment operator.
bool operator<(const iterator &it) const
Definition: OsiCuts.hpp:58
iterator end()
Get iterator to end of collection.
Definition: OsiCuts.hpp:269
bool operator==(const iterator &it) const
Definition: OsiCuts.hpp:48
OsiCuts()
Default constructor.
std::vector< OsiRowCut * > OsiVectorRowCutPtr
Vector of OsiRowCut pointers.
OsiVectorRowCutPtr rowCutPtrs_
Vector of row cuts pointers.
Definition: OsiCuts.hpp:323
int sizeRowCuts() const
Number of row cuts in collection.
Definition: OsiCuts.hpp:398
bool operator()(const OsiCut *c1P, const OsiCut *c2P)
Function for sorting cuts by effectiveness.
Definition: OsiCuts.hpp:305
int sizeColCuts() const
Number of column cuts in collection.
Definition: OsiCuts.hpp:402