Bcp  1.4.4
BCP_lp_pool.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 #ifndef _BCP_LP_POOL_H
4 #define _BCP_LP_POOL_H
5 
6 #include "BCP_error.hpp"
7 #include "BCP_vector.hpp"
8 #include "BCP_lp_result.hpp"
9 #include "BCP_matrix.hpp"
10 #include "BCP_var.hpp"
11 #include "BCP_cut.hpp"
12 
13 //#############################################################################
14 
16 private:
18  BCP_lp_waiting_row& operator=(const BCP_lp_waiting_row&);
19 private:
20  BCP_cut* _cut;
21  BCP_row* _row;
22  double _violation;
23 public:
24  BCP_lp_waiting_row(BCP_cut* cut, BCP_row* row=0, double viol=-1) :
25  _cut(cut), _row(row), _violation(viol) {}
27  delete _row;
28  delete _cut;
29  }
30 
31  inline BCP_cut* cut() { return _cut; }
32  inline BCP_row* row() { return _row; }
33  inline const BCP_cut* cut() const { return _cut; }
34  inline const BCP_row* row() const { return _row; }
35 
36  inline void clear_cut() { _cut = 0; }
37  inline void delete_row() { delete _row; _row = 0; _violation = -1;}
38  inline void set_row(BCP_row*& row) { _row = row; row = 0; }
39 
40  inline double violation() const { return _violation; }
41  inline void set_violation(double v) { _violation = v; }
42  void compute_violation(const BCP_lp_result& lpres);
43 };
44 
45 //-----------------------------------------------------------------------------
46 
47 class BCP_lp_cut_pool : public BCP_vec<BCP_lp_waiting_row*> {
48 private:
49  static bool _rows_are_valid;
50  // disable the default copy constructor and assignment operator
52  BCP_lp_cut_pool& operator=(const BCP_lp_cut_pool&);
53 public:
56  purge_ptr_vector(dynamic_cast< BCP_vec<BCP_lp_waiting_row*>& >(*this));
57  }
58 
59  inline bool rows_are_valid() const { return _rows_are_valid; }
60  inline void rows_are_valid(bool status) { _rows_are_valid = status; }
61 
62  inline void compute_violations(const BCP_lp_result& lpres,
65  if (! _rows_are_valid)
66  throw BCP_fatal_error("\
67 BCP_lp_cut_pool::compute_violations() : rows are not valid\n");
68  while (first != last) {
69  (*first)->compute_violation(lpres);
70  ++first;
71  }
72  }
73  int remove_nonviolated(const double etol);
74 };
75 
76 //#############################################################################
77 
79 private:
81  BCP_lp_waiting_col& operator=(const BCP_lp_waiting_col&);
82 private:
83  BCP_var* _var;
84  BCP_col* _col;
85  double _red_cost;
86 public:
87  BCP_lp_waiting_col(BCP_var* var, BCP_col* col=0, double rc=0) :
88  _var(var), _col(col), _red_cost(rc) {}
90  delete _col;
91  delete _var;
92  }
93 
94  inline BCP_var* var() { return _var; }
95  inline BCP_col* col() { return _col; }
96  inline const BCP_var* var() const { return _var; }
97  inline const BCP_col* col() const { return _col; }
98 
99  inline void clear_var() { _var = 0; }
100  inline void delete_col() { delete _col; _col = 0; _red_cost = 0; }
101  inline void set_col(BCP_col*& col) { _col = col; col = 0; }
102 
103  inline double red_cost() const { return _red_cost; }
104  void compute_red_cost(const BCP_lp_result& lpres);
105 };
106 
107 //-----------------------------------------------------------------------------
108 
109 class BCP_lp_var_pool : public BCP_vec<BCP_lp_waiting_col*> {
110 private:
111  static bool _cols_are_valid;
112  // disable the default copy constructor and assignment operator
114  BCP_lp_var_pool& operator=(const BCP_lp_var_pool&);
115 public:
118  purge_ptr_vector(*(dynamic_cast<BCP_vec<BCP_lp_waiting_col*>*>(this)));
119  }
120 
121  inline bool cols_are_valid() const { return _cols_are_valid; }
122  inline void cols_are_valid(bool status) { _cols_are_valid = status; }
123 
124  inline void compute_red_costs(const BCP_lp_result& lpres,
127  if (! _cols_are_valid)
128  throw BCP_fatal_error("\
129 BCP_lp_var_pool::compute_red_costs() : cols are not valid\n");
130  while (first != last) {
131  (*first)->compute_red_cost(lpres);
132  ++first;
133  }
134  }
135  int remove_positives(const double etol);
136 };
137 
138 #endif
BCP_col
This class holds a column in a compressed form.
Definition: BCP_matrix.hpp:26
BCP_lp_waiting_col::clear_var
void clear_var()
Definition: BCP_lp_pool.hpp:99
BCP_vector.hpp
BCP_lp_var_pool::BCP_lp_var_pool
BCP_lp_var_pool()
Definition: BCP_lp_pool.hpp:116
BCP_lp_waiting_row::set_violation
void set_violation(double v)
Definition: BCP_lp_pool.hpp:41
BCP_lp_waiting_col::delete_col
void delete_col()
Definition: BCP_lp_pool.hpp:100
BCP_lp_waiting_row::row
BCP_row * row()
Definition: BCP_lp_pool.hpp:32
BCP_lp_waiting_row::violation
double violation() const
Definition: BCP_lp_pool.hpp:40
purge_ptr_vector
void purge_ptr_vector(BCP_vec< T * > &pvec, typename BCP_vec< T * >::iterator first, typename BCP_vec< T * >::iterator last)
This function purges the entries [first,last) from the vector of pointers pvec.
Definition: BCP_vector.hpp:266
BCP_lp_waiting_col::set_col
void set_col(BCP_col *&col)
Definition: BCP_lp_pool.hpp:101
BCP_matrix.hpp
BCP_lp_cut_pool
Definition: BCP_lp_pool.hpp:47
BCP_lp_waiting_col::red_cost
double red_cost() const
Definition: BCP_lp_pool.hpp:103
BCP_vec
The class BCP_vec serves the same purpose as the vector class in the standard template library.
Definition: BCP_vector.hpp:24
BCP_lp_waiting_col::var
BCP_var * var()
Definition: BCP_lp_pool.hpp:94
BCP_lp_waiting_col::~BCP_lp_waiting_col
~BCP_lp_waiting_col()
Definition: BCP_lp_pool.hpp:89
BCP_lp_waiting_col::var
const BCP_var * var() const
Definition: BCP_lp_pool.hpp:96
BCP_lp_waiting_col::col
const BCP_col * col() const
Definition: BCP_lp_pool.hpp:97
BCP_cut.hpp
BCP_error.hpp
BCP_lp_var_pool::remove_positives
int remove_positives(const double etol)
BCP_lp_waiting_col::BCP_lp_waiting_col
BCP_lp_waiting_col(BCP_var *var, BCP_col *col=0, double rc=0)
Definition: BCP_lp_pool.hpp:87
BCP_lp_waiting_row::cut
BCP_cut * cut()
Definition: BCP_lp_pool.hpp:31
BCP_lp_result
This class holds the results after solving an LP relaxation.
Definition: BCP_lp_result.hpp:39
BCP_lp_waiting_row
Definition: BCP_lp_pool.hpp:15
BCP_lp_waiting_row::delete_row
void delete_row()
Definition: BCP_lp_pool.hpp:37
BCP_lp_waiting_row::clear_cut
void clear_cut()
Definition: BCP_lp_pool.hpp:36
BCP_lp_waiting_col::compute_red_cost
void compute_red_cost(const BCP_lp_result &lpres)
BCP_lp_waiting_row::BCP_lp_waiting_row
BCP_lp_waiting_row(BCP_cut *cut, BCP_row *row=0, double viol=-1)
Definition: BCP_lp_pool.hpp:24
BCP_lp_cut_pool::compute_violations
void compute_violations(const BCP_lp_result &lpres, BCP_lp_cut_pool::iterator first, BCP_lp_cut_pool::iterator last)
Definition: BCP_lp_pool.hpp:62
BCP_lp_cut_pool::~BCP_lp_cut_pool
~BCP_lp_cut_pool()
Definition: BCP_lp_pool.hpp:55
BCP_lp_waiting_row::compute_violation
void compute_violation(const BCP_lp_result &lpres)
BCP_var.hpp
BCP_lp_waiting_col::col
BCP_col * col()
Definition: BCP_lp_pool.hpp:95
BCP_lp_cut_pool::rows_are_valid
bool rows_are_valid() const
Definition: BCP_lp_pool.hpp:59
BCP_lp_var_pool::cols_are_valid
bool cols_are_valid() const
Definition: BCP_lp_pool.hpp:121
BCP_lp_var_pool
Definition: BCP_lp_pool.hpp:109
BCP_lp_var_pool::cols_are_valid
void cols_are_valid(bool status)
Definition: BCP_lp_pool.hpp:122
BCP_lp_cut_pool::remove_nonviolated
int remove_nonviolated(const double etol)
BCP_cut
Abstract base class that defines members common to all types of cuts.
Definition: BCP_cut.hpp:29
BCP_lp_waiting_col
Definition: BCP_lp_pool.hpp:78
BCP_lp_cut_pool::rows_are_valid
void rows_are_valid(bool status)
Definition: BCP_lp_pool.hpp:60
BCP_row
This class holds a row in a compressed form.
Definition: BCP_matrix.hpp:152
cut
BCP_lp_waiting_row::row
const BCP_row * row() const
Definition: BCP_lp_pool.hpp:34
BCP_var
Abstract base class that defines members common to all types of variables.
Definition: BCP_var.hpp:28
BCP_lp_result.hpp
BCP_lp_waiting_row::cut
const BCP_cut * cut() const
Definition: BCP_lp_pool.hpp:33
BCP_lp_var_pool::compute_red_costs
void compute_red_costs(const BCP_lp_result &lpres, BCP_lp_var_pool::iterator first, BCP_lp_var_pool::iterator last)
Definition: BCP_lp_pool.hpp:124
BCP_lp_waiting_row::~BCP_lp_waiting_row
~BCP_lp_waiting_row()
Definition: BCP_lp_pool.hpp:26
BCP_lp_var_pool::~BCP_lp_var_pool
~BCP_lp_var_pool()
Definition: BCP_lp_pool.hpp:117
BCP_lp_waiting_row::set_row
void set_row(BCP_row *&row)
Definition: BCP_lp_pool.hpp:38
BCP_fatal_error
Currently there isn't any error handling in BCP.
Definition: BCP_error.hpp:20
BCP_lp_cut_pool::BCP_lp_cut_pool
BCP_lp_cut_pool()
Definition: BCP_lp_pool.hpp:54