diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/CoinSnapshot.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/CoinSnapshot.hpp | 476 |
1 files changed, 476 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/CoinSnapshot.hpp b/newstructure/thirdparty/linux/include/coin/CoinSnapshot.hpp new file mode 100644 index 0000000..e928026 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/CoinSnapshot.hpp @@ -0,0 +1,476 @@ +/* $Id: CoinSnapshot.hpp 1416 2011-04-17 09:57:29Z stefan $ */ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinSnapshot_H +#define CoinSnapshot_H + +class CoinPackedMatrix; +#include "CoinTypes.hpp" + +//############################################################################# + +/** NON Abstract Base Class for interfacing with cut generators or branching code or .. + It is designed to be snapshot of a problem at a node in tree + + The class may or may not own the arrays - see owned_ + + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return arrays. +*/ + +class CoinSnapshot { + +public: + + //--------------------------------------------------------------------------- + /**@name Problem query methods + + The Matrix pointers may be NULL + */ + //@{ + /// Get number of columns + inline int getNumCols() const + { return numCols_;} + + /// Get number of rows + inline int getNumRows() const + { return numRows_;} + + /// Get number of nonzero elements + inline int getNumElements() const + { return numElements_;} + + /// Get number of integer variables + inline int getNumIntegers() const + { return numIntegers_;} + + /// Get pointer to array[getNumCols()] of column lower bounds + inline const double * getColLower() const + { return colLower_;} + + /// Get pointer to array[getNumCols()] of column upper bounds + inline const double * getColUpper() const + { return colUpper_;} + + /// Get pointer to array[getNumRows()] of row lower bounds + inline const double * getRowLower() const + { return rowLower_;} + + /// Get pointer to array[getNumRows()] of row upper bounds + inline const double * getRowUpper() const + { return rowUpper_;} + + /** Get pointer to array[getNumRows()] of row right-hand sides + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + inline const double * getRightHandSide() const + { return rightHandSide_;} + + /// Get pointer to array[getNumCols()] of objective function coefficients + inline const double * getObjCoefficients() const + { return objCoefficients_;} + + /// Get objective function sense (1 for min (default), -1 for max) + inline double getObjSense() const + { return objSense_;} + + /// Return true if variable is continuous + inline bool isContinuous(int colIndex) const + { return colType_[colIndex]=='C';} + + /// Return true if variable is binary + inline bool isBinary(int colIndex) const + { return colType_[colIndex]=='B';} + + /// Return true if column is integer. + inline bool isInteger(int colIndex) const + { return colType_[colIndex]=='B'||colType_[colIndex]=='I';} + + /// Return true if variable is general integer + inline bool isIntegerNonBinary(int colIndex) const + { return colType_[colIndex]=='I';} + + /// Return true if variable is binary and not fixed at either bound + inline bool isFreeBinary(int colIndex) const + { return colType_[colIndex]=='B'&&colUpper_[colIndex]>colLower_[colIndex];} + + /// Get colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + inline const char * getColType() const + { return colType_;} + + /// Get pointer to row-wise copy of current matrix + inline const CoinPackedMatrix * getMatrixByRow() const + { return matrixByRow_;} + + /// Get pointer to column-wise copy of current matrix + inline const CoinPackedMatrix * getMatrixByCol() const + { return matrixByCol_;} + + /// Get pointer to row-wise copy of "original" matrix + inline const CoinPackedMatrix * getOriginalMatrixByRow() const + { return originalMatrixByRow_;} + + /// Get pointer to column-wise copy of "original" matrix + inline const CoinPackedMatrix * getOriginalMatrixByCol() const + { return originalMatrixByCol_;} + //@} + + /**@name Solution query methods */ + //@{ + /// Get pointer to array[getNumCols()] of primal variable values + inline const double * getColSolution() const + { return colSolution_;} + + /// Get pointer to array[getNumRows()] of dual variable values + inline const double * getRowPrice() const + { return rowPrice_;} + + /// Get a pointer to array[getNumCols()] of reduced costs + inline const double * getReducedCost() const + { return reducedCost_;} + + /// Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + inline const double * getRowActivity() const + { return rowActivity_;} + + /// Get pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + inline const double * getDoNotSeparateThis() const + { return doNotSeparateThis_;} + //@} + + /**@name Other scalar get methods */ + //@{ + /// Get solver's value for infinity + inline double getInfinity() const + { return infinity_;} + + /** Get objective function value - includinbg any offset i.e. + sum c sub j * x subj - objValue = objOffset */ + inline double getObjValue() const + { return objValue_;} + + /// Get objective offset i.e. sum c sub j * x subj -objValue = objOffset + inline double getObjOffset() const + { return objOffset_;} + + /// Get dual tolerance + inline double getDualTolerance() const + { return dualTolerance_;} + + /// Get primal tolerance + inline double getPrimalTolerance() const + { return primalTolerance_;} + + /// Get integer tolerance + inline double getIntegerTolerance() const + { return integerTolerance_;} + + /// Get integer upper bound i.e. best solution * getObjSense + inline double getIntegerUpperBound() const + { return integerUpperBound_;} + + /// Get integer lower bound i.e. best possible solution * getObjSense + inline double getIntegerLowerBound() const + { return integerLowerBound_;} + //@} + + //--------------------------------------------------------------------------- + + /**@name Method to input a problem */ + //@{ + /** Load in an problem by copying the arguments (the constraints on the + rows are given by lower and upper bounds). If a pointer is NULL then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + All solution type arrays will be deleted + */ + void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub, + bool makeRowCopy=false); + + //@} + + //--------------------------------------------------------------------------- + + /**@name Methods to set data */ + //@{ + /// Set number of columns + inline void setNumCols(int value) + { numCols_ = value;} + + /// Set number of rows + inline void setNumRows(int value) + { numRows_ = value;} + + /// Set number of nonzero elements + inline void setNumElements(int value) + { numElements_ = value;} + + /// Set number of integer variables + inline void setNumIntegers(int value) + { numIntegers_ = value;} + + /// Set pointer to array[getNumCols()] of column lower bounds + void setColLower(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of column upper bounds + void setColUpper(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row lower bounds + void setRowLower(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row upper bounds + void setRowUpper(const double * array, bool copyIn=true); + + /** Set pointer to array[getNumRows()] of row right-hand sides + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + void setRightHandSide(const double * array, bool copyIn=true); + + /** Create array[getNumRows()] of row right-hand sides + using existing information + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + void createRightHandSide(); + + /// Set pointer to array[getNumCols()] of objective function coefficients + void setObjCoefficients(const double * array, bool copyIn=true); + + /// Set objective function sense (1 for min (default), -1 for max) + inline void setObjSense(double value) + { objSense_ = value;} + + /// Set colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + void setColType(const char *array, bool copyIn=true); + + /// Set pointer to row-wise copy of current matrix + void setMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Create row-wise copy from MatrixByCol + void createMatrixByRow(); + + /// Set pointer to column-wise copy of current matrix + void setMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to row-wise copy of "original" matrix + void setOriginalMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to column-wise copy of "original" matrix + void setOriginalMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of primal variable values + void setColSolution(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of dual variable values + void setRowPrice(const double * array, bool copyIn=true); + + /// Set a pointer to array[getNumCols()] of reduced costs + void setReducedCost(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + void setRowActivity(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + void setDoNotSeparateThis(const double * array, bool copyIn=true); + + /// Set solver's value for infinity + inline void setInfinity(double value) + { infinity_ = value;} + + /// Set objective function value (including any rhs offset) + inline void setObjValue(double value) + { objValue_ = value;} + + /// Set objective offset i.e. sum c sub j * x subj -objValue = objOffset + inline void setObjOffset(double value) + { objOffset_ = value;} + + /// Set dual tolerance + inline void setDualTolerance(double value) + { dualTolerance_ = value;} + + /// Set primal tolerance + inline void setPrimalTolerance(double value) + { primalTolerance_ = value;} + + /// Set integer tolerance + inline void setIntegerTolerance(double value) + { integerTolerance_ = value;} + + /// Set integer upper bound i.e. best solution * getObjSense + inline void setIntegerUpperBound(double value) + { integerUpperBound_ = value;} + + /// Set integer lower bound i.e. best possible solution * getObjSense + inline void setIntegerLowerBound(double value) + { integerLowerBound_ = value;} + //@} + + //--------------------------------------------------------------------------- + + ///@name Constructors and destructors + //@{ + /// Default Constructor + CoinSnapshot(); + + /// Copy constructor + CoinSnapshot(const CoinSnapshot &); + + /// Assignment operator + CoinSnapshot & operator=(const CoinSnapshot& rhs); + + /// Destructor + virtual ~CoinSnapshot (); + + //@} + +private: + ///@name private functions + //@{ + /** Does main work of destructor - type (or'ed) + 1 - NULLify pointers + 2 - delete pointers + 4 - initialize scalars (tolerances etc) + 8 - initialize scalars (objValue etc0 + */ + void gutsOfDestructor(int type); + /// Does main work of copy + void gutsOfCopy(const CoinSnapshot & rhs); + //@} + + ///@name Private member data + + /// objective function sense (1 for min (default), -1 for max) + double objSense_; + + /// solver's value for infinity + double infinity_; + + /// objective function value (including any rhs offset) + double objValue_; + + /// objective offset i.e. sum c sub j * x subj -objValue = objOffset + double objOffset_; + + /// dual tolerance + double dualTolerance_; + + /// primal tolerance + double primalTolerance_; + + /// integer tolerance + double integerTolerance_; + + /// integer upper bound i.e. best solution * getObjSense + double integerUpperBound_; + + /// integer lower bound i.e. best possible solution * getObjSense + double integerLowerBound_; + + /// pointer to array[getNumCols()] of column lower bounds + const double * colLower_; + + /// pointer to array[getNumCols()] of column upper bounds + const double * colUpper_; + + /// pointer to array[getNumRows()] of row lower bounds + const double * rowLower_; + + /// pointer to array[getNumRows()] of row upper bounds + const double * rowUpper_; + + /// pointer to array[getNumRows()] of rhs side values + const double * rightHandSide_; + + /// pointer to array[getNumCols()] of objective function coefficients + const double * objCoefficients_; + + /// colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + const char * colType_; + + /// pointer to row-wise copy of current matrix + const CoinPackedMatrix * matrixByRow_; + + /// pointer to column-wise copy of current matrix + const CoinPackedMatrix * matrixByCol_; + + /// pointer to row-wise copy of "original" matrix + const CoinPackedMatrix * originalMatrixByRow_; + + /// pointer to column-wise copy of "original" matrix + const CoinPackedMatrix * originalMatrixByCol_; + + /// pointer to array[getNumCols()] of primal variable values + const double * colSolution_; + + /// pointer to array[getNumRows()] of dual variable values + const double * rowPrice_; + + /// a pointer to array[getNumCols()] of reduced costs + const double * reducedCost_; + + /// pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + const double * rowActivity_; + + /// pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + const double * doNotSeparateThis_; + + /// number of columns + int numCols_; + + /// number of rows + int numRows_; + + /// number of nonzero elements + int numElements_; + + /// number of integer variables + int numIntegers_; + + /// To say whether arrays etc are owned by CoinSnapshot + typedef struct { + unsigned int colLower:1; + unsigned int colUpper:1; + unsigned int rowLower:1; + unsigned int rowUpper:1; + unsigned int rightHandSide:1; + unsigned int objCoefficients:1; + unsigned int colType:1; + unsigned int matrixByRow:1; + unsigned int matrixByCol:1; + unsigned int originalMatrixByRow:1; + unsigned int originalMatrixByCol:1; + unsigned int colSolution:1; + unsigned int rowPrice:1; + unsigned int reducedCost:1; + unsigned int rowActivity:1; + unsigned int doNotSeparateThis:1; + } coinOwned; + coinOwned owned_; + //@} +}; +#endif |