/* $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: 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