CoinUtils 2.11.4
CoinSnapshot.hpp
Go to the documentation of this file.
1/* $Id$ */
2// Copyright (C) 2006, International Business Machines
3// Corporation and others. All Rights Reserved.
4// This code is licensed under the terms of the Eclipse Public License (EPL).
5
6#ifndef CoinSnapshot_H
7#define CoinSnapshot_H
8
10#include "CoinTypes.hpp"
11
12//#############################################################################
13
26
27public:
28 //---------------------------------------------------------------------------
34
35 inline int getNumCols() const
36 {
37 return numCols_;
38 }
39
41 inline int getNumRows() const
42 {
43 return numRows_;
44 }
45
47 inline int getNumElements() const
48 {
49 return numElements_;
50 }
51
53 inline int getNumIntegers() const
54 {
55 return numIntegers_;
56 }
57
59 inline const double *getColLower() const
60 {
61 return colLower_;
62 }
63
65 inline const double *getColUpper() const
66 {
67 return colUpper_;
68 }
69
71 inline const double *getRowLower() const
72 {
73 return rowLower_;
74 }
75
77 inline const double *getRowUpper() const
78 {
79 return rowUpper_;
80 }
81
89 inline const double *getRightHandSide() const
90 {
91 return rightHandSide_;
92 }
93
95 inline const double *getObjCoefficients() const
96 {
97 return objCoefficients_;
98 }
99
101 inline double getObjSense() const
102 {
103 return objSense_;
104 }
105
107 inline bool isContinuous(int colIndex) const
108 {
109 return colType_[colIndex] == 'C';
110 }
111
113 inline bool isBinary(int colIndex) const
114 {
115 return colType_[colIndex] == 'B';
116 }
117
119 inline bool isInteger(int colIndex) const
120 {
121 return colType_[colIndex] == 'B' || colType_[colIndex] == 'I';
122 }
123
125 inline bool isIntegerNonBinary(int colIndex) const
126 {
127 return colType_[colIndex] == 'I';
128 }
129
131 inline bool isFreeBinary(int colIndex) const
132 {
133 return colType_[colIndex] == 'B' && colUpper_[colIndex] > colLower_[colIndex];
134 }
135
137 inline const char *getColType() const
138 {
139 return colType_;
140 }
141
143 inline const CoinPackedMatrix *getMatrixByRow() const
144 {
145 return matrixByRow_;
146 }
147
149 inline const CoinPackedMatrix *getMatrixByCol() const
150 {
151 return matrixByCol_;
152 }
153
156 {
158 }
159
162 {
164 }
166
170 inline const double *getColSolution() const
171 {
172 return colSolution_;
173 }
174
176 inline const double *getRowPrice() const
177 {
178 return rowPrice_;
179 }
180
182 inline const double *getReducedCost() const
183 {
184 return reducedCost_;
185 }
186
188 inline const double *getRowActivity() const
189 {
190 return rowActivity_;
191 }
192
194 inline const double *getDoNotSeparateThis() const
195 {
196 return doNotSeparateThis_;
197 }
199
203 inline double getInfinity() const
204 {
205 return infinity_;
206 }
207
210 inline double getObjValue() const
211 {
212 return objValue_;
213 }
214
216 inline double getObjOffset() const
217 {
218 return objOffset_;
219 }
220
222 inline double getDualTolerance() const
223 {
224 return dualTolerance_;
225 }
226
228 inline double getPrimalTolerance() const
229 {
230 return primalTolerance_;
231 }
232
234 inline double getIntegerTolerance() const
235 {
236 return integerTolerance_;
237 }
238
240 inline double getIntegerUpperBound() const
241 {
242 return integerUpperBound_;
243 }
244
246 inline double getIntegerLowerBound() const
247 {
248 return integerLowerBound_;
249 }
251
252 //---------------------------------------------------------------------------
253
268 void loadProblem(const CoinPackedMatrix &matrix,
269 const double *collb, const double *colub,
270 const double *obj,
271 const double *rowlb, const double *rowub,
272 bool makeRowCopy = false);
273
275
276 //---------------------------------------------------------------------------
277
281 inline void setNumCols(int value)
282 {
283 numCols_ = value;
284 }
285
287 inline void setNumRows(int value)
288 {
289 numRows_ = value;
290 }
291
293 inline void setNumElements(int value)
294 {
295 numElements_ = value;
296 }
297
299 inline void setNumIntegers(int value)
300 {
301 numIntegers_ = value;
302 }
303
305 void setColLower(const double *array, bool copyIn = true);
306
308 void setColUpper(const double *array, bool copyIn = true);
309
311 void setRowLower(const double *array, bool copyIn = true);
312
314 void setRowUpper(const double *array, bool copyIn = true);
315
323 void setRightHandSide(const double *array, bool copyIn = true);
324
334
336 void setObjCoefficients(const double *array, bool copyIn = true);
337
339 inline void setObjSense(double value)
340 {
341 objSense_ = value;
342 }
343
345 void setColType(const char *array, bool copyIn = true);
346
348 void setMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn = true);
349
352
354 void setMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn = true);
355
357 void setOriginalMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn = true);
358
360 void setOriginalMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn = true);
361
363 void setColSolution(const double *array, bool copyIn = true);
364
366 void setRowPrice(const double *array, bool copyIn = true);
367
369 void setReducedCost(const double *array, bool copyIn = true);
370
372 void setRowActivity(const double *array, bool copyIn = true);
373
375 void setDoNotSeparateThis(const double *array, bool copyIn = true);
376
378 inline void setInfinity(double value)
379 {
380 infinity_ = value;
381 }
382
384 inline void setObjValue(double value)
385 {
386 objValue_ = value;
387 }
388
390 inline void setObjOffset(double value)
391 {
392 objOffset_ = value;
393 }
394
396 inline void setDualTolerance(double value)
397 {
398 dualTolerance_ = value;
399 }
400
402 inline void setPrimalTolerance(double value)
403 {
404 primalTolerance_ = value;
405 }
406
408 inline void setIntegerTolerance(double value)
409 {
410 integerTolerance_ = value;
411 }
412
414 inline void setIntegerUpperBound(double value)
415 {
416 integerUpperBound_ = value;
417 }
418
420 inline void setIntegerLowerBound(double value)
421 {
422 integerLowerBound_ = value;
423 }
425
426 //---------------------------------------------------------------------------
427
429
430
432
435
438
440 virtual ~CoinSnapshot();
441
443
444private:
446
447
453 void gutsOfDestructor(int type);
455 void gutsOfCopy(const CoinSnapshot &rhs);
457
459
461 double objSense_;
462
464 double infinity_;
465
467 double objValue_;
468
471
474
477
480
483
486
488 const double *colLower_;
489
491 const double *colUpper_;
492
494 const double *rowLower_;
495
497 const double *rowUpper_;
498
500 const double *rightHandSide_;
501
503 const double *objCoefficients_;
504
506 const char *colType_;
507
510
513
516
519
521 const double *colSolution_;
522
524 const double *rowPrice_;
525
527 const double *reducedCost_;
528
530 const double *rowActivity_;
531
533 const double *doNotSeparateThis_;
534
537
540
543
546
548 typedef struct {
549 unsigned int colLower : 1;
550 unsigned int colUpper : 1;
551 unsigned int rowLower : 1;
552 unsigned int rowUpper : 1;
553 unsigned int rightHandSide : 1;
554 unsigned int objCoefficients : 1;
555 unsigned int colType : 1;
556 unsigned int matrixByRow : 1;
557 unsigned int matrixByCol : 1;
558 unsigned int originalMatrixByRow : 1;
559 unsigned int originalMatrixByCol : 1;
560 unsigned int colSolution : 1;
561 unsigned int rowPrice : 1;
562 unsigned int reducedCost : 1;
563 unsigned int rowActivity : 1;
564 unsigned int doNotSeparateThis : 1;
565 } coinOwned;
568};
569#endif
570
571/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
572*/
Sparse Matrix Base Class.
NON Abstract Base Class for interfacing with cut generators or branching code or .
double primalTolerance_
primal tolerance
double objValue_
objective function value (including any rhs offset)
int numIntegers_
number of integer variables
const double * objCoefficients_
pointer to array[getNumCols()] of objective function coefficients
double objSense_
objective function sense (1 for min (default), -1 for max)
int numElements_
number of nonzero elements
double integerUpperBound_
integer upper bound i.e. best solution * getObjSense
void setObjValue(double value)
Set objective function value (including any rhs offset)
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
const char * colType_
colType array ('B', 'I', or 'C' for Binary, Integer and Continuous)
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
void setRowLower(const double *array, bool copyIn=true)
Set pointer to array[getNumRows()] of row lower bounds.
void setIntegerLowerBound(double value)
Set integer lower bound i.e. best possible solution * getObjSense.
const char * getColType() const
Get colType array ('B', 'I', or 'C' for Binary, Integer and Continuous)
double getPrimalTolerance() const
Get primal tolerance.
void setDualTolerance(double value)
Set dual tolerance.
const CoinPackedMatrix * originalMatrixByRow_
pointer to row-wise copy of "original" matrix
const double * reducedCost_
a pointer to array[getNumCols()] of reduced costs
void gutsOfDestructor(int type)
Does main work of destructor - type (or'ed) 1 - NULLify pointers 2 - delete pointers 4 - initialize s...
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
void setColLower(const double *array, bool copyIn=true)
Set pointer to array[getNumCols()] of column lower bounds.
void setDoNotSeparateThis(const double *array, bool copyIn=true)
Set pointer to array[getNumCols()] of primal variable values which should not be separated (for debug...
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
CoinSnapshot & operator=(const CoinSnapshot &rhs)
Assignment operator.
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
void setRowUpper(const double *array, bool copyIn=true)
Set pointer to array[getNumRows()] of row upper bounds.
double integerTolerance_
integer tolerance
bool isInteger(int colIndex) const
Return true if column is integer.
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
const double * rowLower_
pointer to array[getNumRows()] of row lower bounds
double getIntegerUpperBound() const
Get integer upper bound i.e. best solution * getObjSense.
const double * rowUpper_
pointer to array[getNumRows()] of row upper bounds
double getDualTolerance() const
Get dual tolerance.
int getNumIntegers() const
Get number of integer variables.
void setObjOffset(double value)
Set objective offset i.e. sum c sub j * x subj -objValue = objOffset.
void setRowActivity(const double *array, bool copyIn=true)
Set pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
const double * colLower_
pointer to array[getNumCols()] of column lower bounds
void createMatrixByRow()
Create row-wise copy from MatrixByCol.
void setMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn=true)
Set pointer to row-wise copy of current matrix.
double getInfinity() const
Get solver's value for infinity.
void setRightHandSide(const double *array, bool copyIn=true)
Set pointer to array[getNumRows()] of row right-hand sides This gives same results as OsiSolverInterf...
const double * doNotSeparateThis_
pointer to array[getNumCols()] of primal variable values which should not be separated (for debug)
void setIntegerUpperBound(double value)
Set integer upper bound i.e. best solution * getObjSense.
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of current matrix.
int getNumRows() const
Get number of rows.
const double * rightHandSide_
pointer to array[getNumRows()] of rhs side values
const double * colUpper_
pointer to array[getNumCols()] of column upper bounds
double integerLowerBound_
integer lower bound i.e. best possible solution * getObjSense
double getObjOffset() const
Get objective offset i.e. sum c sub j * x subj -objValue = objOffset.
void setColUpper(const double *array, bool copyIn=true)
Set pointer to array[getNumCols()] of column upper bounds.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal variable values.
void setColSolution(const double *array, bool copyIn=true)
Set pointer to array[getNumCols()] of primal variable values.
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of current matrix.
coinOwned owned_
virtual ~CoinSnapshot()
Destructor.
double getObjValue() const
Get objective function value - includinbg any offset i.e.
const CoinPackedMatrix * matrixByRow_
pointer to row-wise copy of current matrix
const CoinPackedMatrix * getOriginalMatrixByCol() const
Get pointer to column-wise copy of "original" matrix.
void setPrimalTolerance(double value)
Set primal tolerance.
const double * rowActivity_
pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector).
const double * rowPrice_
pointer to array[getNumRows()] of dual variable values
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual variable values.
void setRowPrice(const double *array, bool copyIn=true)
Set pointer to array[getNumRows()] of dual variable values.
const CoinPackedMatrix * originalMatrixByCol_
pointer to column-wise copy of "original" matrix
void setInfinity(double value)
Set solver's value for infinity.
int numCols_
number of columns
void gutsOfCopy(const CoinSnapshot &rhs)
Does main work of copy.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
int numRows_
number of rows
void createRightHandSide()
Create array[getNumRows()] of row right-hand sides using existing information This gives same results...
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
void setObjSense(double value)
Set objective function sense (1 for min (default), -1 for max)
int getNumCols() const
Get number of columns.
double infinity_
solver's value for infinity
void setOriginalMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn=true)
Set pointer to column-wise copy of "original" matrix.
void setNumElements(int value)
Set number of nonzero elements.
double getIntegerTolerance() const
Get integer tolerance.
const double * colSolution_
pointer to array[getNumCols()] of primal variable values
const CoinPackedMatrix * matrixByCol_
pointer to column-wise copy of current matrix
const double * getDoNotSeparateThis() const
Get pointer to array[getNumCols()] of primal variable values which should not be separated (for debug...
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of row right-hand sides This gives same results as OsiSolverInterf...
void setReducedCost(const double *array, bool copyIn=true)
Set a pointer to array[getNumCols()] of reduced costs.
bool isBinary(int colIndex) const
Return true if variable is binary.
void setObjCoefficients(const double *array, bool copyIn=true)
Set pointer to array[getNumCols()] of objective function coefficients.
void setMatrixByCol(const CoinPackedMatrix *matrix, bool copyIn=true)
Set pointer to column-wise copy of current matrix.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
double dualTolerance_
dual tolerance
const CoinPackedMatrix * getOriginalMatrixByRow() const
Get pointer to row-wise copy of "original" matrix.
CoinSnapshot(const CoinSnapshot &)
Copy constructor.
void setNumIntegers(int value)
Set number of integer variables.
CoinSnapshot()
Default Constructor.
void setOriginalMatrixByRow(const CoinPackedMatrix *matrix, bool copyIn=true)
Set pointer to row-wise copy of "original" matrix.
bool isContinuous(int colIndex) const
Return true if variable is continuous.
int getNumElements() const
Get number of nonzero elements.
void setNumRows(int value)
Set number of rows.
void setIntegerTolerance(double value)
Set integer tolerance.
void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub, bool makeRowCopy=false)
Load in an problem by copying the arguments (the constraints on the rows are given by lower and upper...
double getIntegerLowerBound() const
Get integer lower bound i.e. best possible solution * getObjSense.
void setNumCols(int value)
Set number of columns.
double objOffset_
objective offset i.e. sum c sub j * x subj -objValue = objOffset
void setColType(const char *array, bool copyIn=true)
Set colType array ('B', 'I', or 'C' for Binary, Integer and Continuous)
To say whether arrays etc are owned by CoinSnapshot.
unsigned int doNotSeparateThis
unsigned int originalMatrixByCol
unsigned int originalMatrixByRow
unsigned int objCoefficients