Bcp 1.4.4
Loading...
Searching...
No Matches
BCP_matrix.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_MATRIX_H
4#define _BCP_MATRIX_H
5
6// This file is fully docified.
7
8// #include <cmath>
9// #include <cfloat>
10
11#include "CoinPackedVector.hpp"
12#include "CoinPackedMatrix.hpp"
13
14#include "BCP_math.hpp"
15#include "BCP_vector.hpp"
16
17//#############################################################################
18
19class BCP_buffer;
20
21//#############################################################################
22
25
26class BCP_col : public CoinPackedVector {
27
28protected:
32 double _Objective;
34 double _LowerBound;
38 //--------------------------------------------------------------------------
39
40public:
44 inline double Objective() const { return _Objective; }
46 inline double LowerBound() const { return _LowerBound; }
48 inline double UpperBound() const { return _UpperBound; }
50 //--------------------------------------------------------------------------
51
55 inline void Objective(const double obj) { _Objective = obj; }
57 inline void LowerBound(const double lb) { _LowerBound = lb; }
59 inline void UpperBound(const double ub) { _UpperBound = ub; }
60
67 return *this;
68 }
69
72 inline void
73 assign(const int size, int*& ElementIndices, double*& ElementValues,
74 const double Obj, const double LB, const double UB) {
75 CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
76 false /* no test for duplicate index */);
77 _Objective = Obj;
78 _LowerBound = LB;
79 _UpperBound = UB;
80 }
81
82 inline void
83 copy(const int size, const int* ElementIndices, const double* ElementValues,
84 const double Obj, const double LB, const double UB) {
85 CoinPackedVector::setVector(size, ElementIndices, ElementValues,
86 false /* no test for duplicate index */);
87 _Objective = Obj;
88 _LowerBound = LB;
89 _UpperBound = UB;
90 }
91
94 inline void
99 const double Obj, const double LB, const double UB) {
100 CoinPackedVector::setVector(lastind - firstind, firstind, firstval,
101 false /* no test for duplicate index */);
102 _Objective = Obj;
103 _LowerBound = LB;
104 _UpperBound = UB;
105 }
106
107 //--------------------------------------------------------------------------
108
113 BCP_col() : CoinPackedVector(false /* no test for duplicate index */),
115
119
125 const double Obj, const double LB, const double UB) :
126 CoinPackedVector(lastind - firstind, firstind, firstval,
127 false /* no test for duplicate index */),
128 _Objective(Obj), _LowerBound(LB), _UpperBound(UB) {}
129
131 BCP_col(const int size, int*& ElementIndices, double*& ElementValues,
132 const double Obj, const double LB, const double UB) :
134 CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
135 false /* no test for duplicate index */);
136 }
138 const double Obj, const double LB, const double UB) :
140 vec.getIndices(), vec.getElements()),
141 _Objective(Obj), _LowerBound(LB), _UpperBound(UB) {}
142
145};
146
147//#############################################################################
148
151
152class BCP_row : public CoinPackedVector {
153protected:
157 double _LowerBound;
161 //--------------------------------------------------------------------------
162
163public:
167 inline double LowerBound() const { return _LowerBound; }
169 inline double UpperBound() const { return _UpperBound; }
171 //--------------------------------------------------------------------------
172
176 inline void LowerBound(double lb) { _LowerBound = lb; }
178 inline void UpperBound(double ub) { _UpperBound = ub; }
179
185 return *this;
186 }
187
190 void
191 assign(const int size, int*& ElementIndices, double*& ElementValues,
192 const double LB, const double UB) {
193 CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
194 false /* no test for duplicate index */);
195 _LowerBound = LB;
196 _UpperBound = UB;
197 }
198
199 void
200 copy(const int size, const int* ElementIndices, const double* ElementValues,
201 const double LB, const double UB) {
202 CoinPackedVector::setVector(size, ElementIndices, ElementValues,
203 false /* no test for duplicate index */);
204 _LowerBound = LB;
205 _UpperBound = UB;
206 }
207
210 void
215 const double LB, const double UB) {
216 CoinPackedVector::setVector(lastind - firstind, firstind, firstval,
217 false /* no test for duplicate index */);
218 _LowerBound = LB;
219 _UpperBound = UB;
220 }
221
222 //--------------------------------------------------------------------------
223
228 BCP_row() : CoinPackedVector(false /* no test for duplicate index */),
230
234
240 const double LB, const double UB) :
241 CoinPackedVector(lastind - firstind, firstind, firstval,
242 false /* no test for duplicate index */),
243 _LowerBound(LB), _UpperBound(UB) {}
244
246 BCP_row(const int size, int*& ElementIndices, double*& ElementValues,
247 const double LB, const double UB) :
249 CoinPackedVector::assignVector(size, ElementIndices, ElementValues,
250 false /* no test for duplicate index */);
251 }
252 BCP_row(const CoinPackedVectorBase& vec, const double LB, const double UB) :
254 vec.getIndices(), vec.getElements()),
255 _LowerBound(LB), _UpperBound(UB) {}
256
259};
260
261//#############################################################################
262//#############################################################################
263
268private:
272 BCP_vec<double> _Objective;
274 BCP_vec<double> _ColLowerBound;
276 BCP_vec<double> _ColUpperBound;
278 BCP_vec<double> _RowLowerBound;
280 BCP_vec<double> _RowUpperBound;
282 //--------------------------------------------------------------------------
283
284public:
288 inline size_t colnum() const { return _ColLowerBound.size(); }
290 inline size_t rownum() const { return _RowLowerBound.size(); }
292 inline const BCP_vec<double>& Objective() const {return _Objective;}
294 inline const BCP_vec<double>& ColLowerBound() const {return _ColLowerBound;}
296 inline const BCP_vec<double>& ColUpperBound() const {return _ColUpperBound;}
298 inline const BCP_vec<double>& RowLowerBound() const {return _RowLowerBound;}
300 inline const BCP_vec<double>& RowUpperBound() const {return _RowUpperBound;}
302 //--------------------------------------------------------------------------
303
313 void reserve(const int MaxColNum, const int MaxRowNum,
314 const int MaxNonzeros);
316 void clear();
319 const double* OBJ, const double* CLB, const double* CUB,
320 const double* RLB, const double* RUB);
323 double*& OBJ, double*& CLB, double*& CUB,
324 double*& RLB, double*& RUB);
326 //--------------------------------------------------------------------------
327
330#if 0
333 void add_col_set(const BCP_col_set& Cols);
336 void add_row_set(const BCP_row_set& Rows);
337#endif
340 void erase_col_set(const BCP_vec<int>& pos);
343 void erase_row_set(const BCP_vec<int>& pos);
345 //--------------------------------------------------------------------------
346#if 0
351 double dot_product_col(const int index, const BCP_vec<double>& col) const;
354 double dot_product_row(const int index, const BCP_vec<double>& row) const;
357 double dot_product_col(const int index, const double* col) const;
360 double dot_product_row(const int index, const double* row) const;
362#endif
363 //--------------------------------------------------------------------------
364
368 void pack(BCP_buffer& buf) const;
370 void unpack(BCP_buffer& buf);
372 //--------------------------------------------------------------------------
373
377 BCP_lp_relax(const bool colordered = true) :
378 CoinPackedMatrix(colordered, 0, 0, 0, NULL, NULL, NULL, NULL),
379 _Objective(), _ColLowerBound(), _ColUpperBound(),
380 _RowLowerBound(), _RowUpperBound() {}
381
384
391 BCP_vec<double>& OBJ);
392
399 BCP_vec<double>& OBJ,
400 double extra_gap, double extra_major);
401
408
415 double extra_gap, double extra_major);
416
419 BCP_lp_relax(const bool colordered,
420 const BCP_vec<int>& VB, const BCP_vec<int>& EI,
421 const BCP_vec<double>& EV, const BCP_vec<double>& OBJ,
422 const BCP_vec<double>& CLB, const BCP_vec<double>& CUB,
423 const BCP_vec<double>& RLB, const BCP_vec<double>& RUB);
428 BCP_lp_relax(const bool colordered,
429 const int rownum, const int colnum, const int nznum,
430 int*& VB, int*& EI, double*& EV,
431 double*& OBJ, double*& CLB, double*& CUB,
432 double*& RLB, double*& RUB);
433
437private:
441 void BCP_createColumnOrderedMatrix(BCP_vec<BCP_row*>& rows,
442 BCP_vec<double>& CLB,
443 BCP_vec<double>& CUB,
444 BCP_vec<double>& OBJ);
446 void BCP_createRowOrderedMatrix(BCP_vec<BCP_col*>& cols,
447 BCP_vec<double>& RLB,
448 BCP_vec<double>& RUB);
450};
451
452#endif
#define BCP_DBL_MAX
Definition BCP_math.hpp:6
This class describes the message buffer used for all processes of BCP.
BCP_col(const int size, int *&ElementIndices, double *&ElementValues, const double Obj, const double LB, const double UB)
This constructor acts exactly like the assign method with the same argument list.
void copy(const int size, const int *ElementIndices, const double *ElementValues, const double Obj, const double LB, const double UB)
Copy the arguments into the appropriate data members.
BCP_col(const CoinPackedVectorBase &vec, const double Obj, const double LB, const double UB)
double _LowerBound
The lower bound corresponding to the column.
double _Objective
The objective function coefficient corresponding to the column.
double UpperBound() const
Return the upper bound.
~BCP_col()
The destructor deletes all data members.
void LowerBound(const double lb)
Set the lower bound to the given value.
BCP_col(BCP_vec< int >::const_iterator firstind, BCP_vec< int >::const_iterator lastind, BCP_vec< double >::const_iterator firstval, BCP_vec< double >::const_iterator lastval, const double Obj, const double LB, const double UB)
This constructor acts exactly like the copy method with the same argument list.
double Objective() const
Return the objective coefficient.
BCP_col & operator=(const BCP_col &x)
Assignment operator: copy over the contents of x.
double _UpperBound
The upper bound corresponding to the column.
void UpperBound(const double ub)
Set the upper bound to the given value.
BCP_col()
The default constructor creates an empty column with 0 as objective coefficient, 0....
double LowerBound() const
Return the lower bound.
void Objective(const double obj)
Set the objective coefficient to the given value.
void assign(const int size, int *&ElementIndices, double *&ElementValues, const double Obj, const double LB, const double UB)
Set the objective coefficient, lower and upper bounds to the given values.
BCP_col(const BCP_col &x)
The copy constructor makes a copy of x.
void copy(BCP_vec< int >::const_iterator firstind, BCP_vec< int >::const_iterator lastind, BCP_vec< double >::const_iterator firstval, BCP_vec< double >::const_iterator lastval, const double Obj, const double LB, const double UB)
Same as the other copy() method, except that instead of using vectors the indices (values) are given ...
BCP_lp_relax(BCP_vec< BCP_col * > &cols, BCP_vec< double > &RLB, BCP_vec< double > &RUB, double extra_gap, double extra_major)
Same as the previous method except that this method allows extra_gap and extra_major to be specified.
size_t colnum() const
The number of columns.
BCP_lp_relax(const bool colordered, const BCP_vec< int > &VB, const BCP_vec< int > &EI, const BCP_vec< double > &EV, const BCP_vec< double > &OBJ, const BCP_vec< double > &CLB, const BCP_vec< double > &CUB, const BCP_vec< double > &RLB, const BCP_vec< double > &RUB)
Create an LP relaxation of the given ordering by copying the content of the arguments to the LP relax...
const BCP_vec< double > & Objective() const
A const reference to the vector of objective coefficients.
~BCP_lp_relax()
The destructor deletes the data members.
const BCP_vec< double > & ColUpperBound() const
A const reference to the vector of upper bounds on the variables.
void erase_row_set(const BCP_vec< int > &pos)
Remove the rows whose indices are listed in pos from the LP relaxation.
void pack(BCP_buffer &buf) const
Pack the LP relaxation into the buffer.
BCP_lp_relax(BCP_vec< BCP_col * > &cols, BCP_vec< double > &RLB, BCP_vec< double > &RUB)
Create a column major ordered LP relaxation by assigning the content of the arguments to the LP relax...
void copyOf(const CoinPackedMatrix &m, const double *OBJ, const double *CLB, const double *CUB, const double *RLB, const double *RUB)
Set up the LP relaxation by making a copy of the arguments.
size_t rownum() const
The number of rows.
BCP_lp_relax(const bool colordered=true)
Create an empty LP relaxation with given ordering.
void assign(CoinPackedMatrix &m, double *&OBJ, double *&CLB, double *&CUB, double *&RLB, double *&RUB)
Set up the LP relaxation by taking over the pointers in the arguments.
const BCP_vec< double > & RowLowerBound() const
A const reference to the vector of lower bounds on the cuts.
void clear()
Clear the LP relaxation.
void unpack(BCP_buffer &buf)
Unpack the LP relaxation from the buffer.
const BCP_vec< double > & RowUpperBound() const
A const reference to the vector of upper bounds on the cuts.
void erase_col_set(const BCP_vec< int > &pos)
Remove the columns whose indices are listed in pos from the LP relaxation.
BCP_lp_relax(const bool colordered, const int rownum, const int colnum, const int nznum, int *&VB, int *&EI, double *&EV, double *&OBJ, double *&CLB, double *&CUB, double *&RLB, double *&RUB)
Create an LP relaxation of the given ordering by assigning the content of the arguments to the LP rel...
const BCP_vec< double > & ColLowerBound() const
A const reference to the vector of lower bounds on the variables.
BCP_lp_relax(BCP_vec< BCP_row * > &rows, BCP_vec< double > &CLB, BCP_vec< double > &CUB, BCP_vec< double > &OBJ)
Create a row major ordered LP relaxation by assigning the content of the arguments to the LP relaxati...
BCP_lp_relax(const BCP_lp_relax &mat)
The copy constructor makes a copy of the argument LP relaxation.
BCP_lp_relax & operator=(const BCP_lp_relax &mat)
Copy the content of x into the LP relaxation.
void reserve(const int MaxColNum, const int MaxRowNum, const int MaxNonzeros)
Reserve space in the LP relaxation for at least MaxColNum columns, MaxRowNum rows and MaxNonzeros non...
BCP_lp_relax(BCP_vec< BCP_row * > &rows, BCP_vec< double > &CLB, BCP_vec< double > &CUB, BCP_vec< double > &OBJ, double extra_gap, double extra_major)
Same as the previous method except that this method allows extra_gap and extra_major to be specified.
BCP_row & operator=(const BCP_row &x)
Assignment operator: copy over the contents of x.
BCP_row()
The default constructor creates an empty row with -infinity as lower and +infinity as upper bound.
void copy(const int size, const int *ElementIndices, const double *ElementValues, const double LB, const double UB)
Copy the arguments into the appropriate data members.
double _UpperBound
The upper bound corresponding to the row.
double _LowerBound
The lower bound corresponding to the row.
double LowerBound() const
Return the lower bound.
BCP_row(const CoinPackedVectorBase &vec, const double LB, const double UB)
void UpperBound(double ub)
Set the upper bound to the given value.
~BCP_row()
The destructor deletes all data members.
BCP_row(const int size, int *&ElementIndices, double *&ElementValues, const double LB, const double UB)
This constructor acts exactly like the assign method with the same argument list.
void assign(const int size, int *&ElementIndices, double *&ElementValues, const double LB, const double UB)
Set the lower and upper bounds to the given values.
void LowerBound(double lb)
Set the lower bound to the given value.
void copy(BCP_vec< int >::const_iterator firstind, BCP_vec< int >::const_iterator lastind, BCP_vec< double >::const_iterator firstval, BCP_vec< double >::const_iterator lastval, const double LB, const double UB)
Same as the other copy() method, except that instead of using vectors the indices (values) are given ...
BCP_row(const BCP_row &x)
The copy constructor makes a copy of x.
BCP_row(BCP_vec< int >::const_iterator firstind, BCP_vec< int >::const_iterator lastind, BCP_vec< double >::const_iterator firstval, BCP_vec< double >::const_iterator lastval, const double LB, const double UB)
This constructor acts exactly like the copy method with the same argument list.
double UpperBound() const
Return the upper bound.
The class BCP_vec serves the same purpose as the vector class in the standard template library.
const T * const_iterator
CoinPackedVectorBase(const CoinPackedVectorBase &)
virtual const int * getIndices() const
void setVector(int size, const int *inds, const double *elems, bool testForDuplicateIndex=COIN_DEFAULT_VALUE_FOR_DUPLICATE)
CoinPackedVector(bool testForDuplicateIndex=COIN_DEFAULT_VALUE_FOR_DUPLICATE)
CoinPackedVector & operator=(const CoinPackedVector &)
virtual const double * getElements() const
virtual int getNumElements() const
void assignVector(int size, int *&inds, double *&elems, bool testForDuplicateIndex=COIN_DEFAULT_VALUE_FOR_DUPLICATE)