diff options
Diffstat (limited to 'build/Bonmin/include/coin/CoinMpsIO.hpp')
| -rw-r--r-- | build/Bonmin/include/coin/CoinMpsIO.hpp | 1056 |
1 files changed, 1056 insertions, 0 deletions
diff --git a/build/Bonmin/include/coin/CoinMpsIO.hpp b/build/Bonmin/include/coin/CoinMpsIO.hpp new file mode 100644 index 0000000..8f0226a --- /dev/null +++ b/build/Bonmin/include/coin/CoinMpsIO.hpp @@ -0,0 +1,1056 @@ +/* $Id: CoinMpsIO.hpp 1642 2013-10-16 00:43:14Z tkr $ */ +// Copyright (C) 2000, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinMpsIO_H +#define CoinMpsIO_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include <vector> +#include <string> + +#include "CoinUtilsConfig.h" +#include "CoinPackedMatrix.hpp" +#include "CoinMessageHandler.hpp" +#include "CoinFileIO.hpp" +class CoinModel; + +/// The following lengths are in decreasing order (for 64 bit etc) +/// Large enough to contain element index +/// This is already defined as CoinBigIndex +/// Large enough to contain column index +typedef int COINColumnIndex; + +/// Large enough to contain row index (or basis) +typedef int COINRowIndex; + +// We are allowing free format - but there is a limit! +// User can override by using CXXFLAGS += -DCOIN_MAX_FIELD_LENGTH=nnn +#ifndef COIN_MAX_FIELD_LENGTH +#define COIN_MAX_FIELD_LENGTH 160 +#endif +#define MAX_CARD_LENGTH 5*COIN_MAX_FIELD_LENGTH+80 + +enum COINSectionType { COIN_NO_SECTION, COIN_NAME_SECTION, COIN_ROW_SECTION, + COIN_COLUMN_SECTION, + COIN_RHS_SECTION, COIN_RANGES_SECTION, COIN_BOUNDS_SECTION, + COIN_ENDATA_SECTION, COIN_EOF_SECTION, COIN_QUADRATIC_SECTION, + COIN_CONIC_SECTION,COIN_QUAD_SECTION,COIN_SOS_SECTION, + COIN_BASIS_SECTION,COIN_UNKNOWN_SECTION +}; + +enum COINMpsType { COIN_N_ROW, COIN_E_ROW, COIN_L_ROW, COIN_G_ROW, + COIN_BLANK_COLUMN, COIN_S1_COLUMN, COIN_S2_COLUMN, COIN_S3_COLUMN, + COIN_INTORG, COIN_INTEND, COIN_SOSEND, COIN_UNSET_BOUND, + COIN_UP_BOUND, COIN_FX_BOUND, COIN_LO_BOUND, COIN_FR_BOUND, + COIN_MI_BOUND, COIN_PL_BOUND, COIN_BV_BOUND, + COIN_UI_BOUND, COIN_LI_BOUND, COIN_BOTH_BOUNDS_SET, + COIN_SC_BOUND, COIN_S1_BOUND, COIN_S2_BOUND, + COIN_BS_BASIS, COIN_XL_BASIS, COIN_XU_BASIS, + COIN_LL_BASIS, COIN_UL_BASIS, COIN_UNKNOWN_MPS_TYPE +}; +class CoinMpsIO; +/// Very simple code for reading MPS data +class CoinMpsCardReader { + +public: + + /**@name Constructor and destructor */ + //@{ + /// Constructor expects file to be open + /// This one takes gzFile if fp null + CoinMpsCardReader ( CoinFileInput *input, CoinMpsIO * reader ); + + /// Destructor + ~CoinMpsCardReader ( ); + //@} + + + /**@name card stuff */ + //@{ + /// Read to next section + COINSectionType readToNextSection ( ); + /// Gets next field and returns section type e.g. COIN_COLUMN_SECTION + COINSectionType nextField ( ); + /** Gets next field for .gms file and returns type. + -1 - EOF + 0 - what we expected (and processed so pointer moves past) + 1 - not what we expected + leading blanks always ignored + input types + 0 - anything - stops on non blank card + 1 - name (in columnname) + 2 - value + 3 - value name pair + 4 - equation type + 5 - ; + */ + int nextGmsField ( int expectedType ); + /// Returns current section type + inline COINSectionType whichSection ( ) const { + return section_; + } + /// Sets current section type + inline void setWhichSection(COINSectionType section ) { + section_=section; + } + /// Sees if free format. + inline bool freeFormat() const + { return freeFormat_;} + /// Sets whether free format. Mainly for blank RHS etc + inline void setFreeFormat(bool yesNo) + { freeFormat_=yesNo;} + /// Only for first field on card otherwise BLANK_COLUMN + /// e.g. COIN_E_ROW + inline COINMpsType mpsType ( ) const { + return mpsType_; + } + /// Reads and cleans card - taking out trailing blanks - return 1 if EOF + int cleanCard(); + /// Returns row name of current field + inline const char *rowName ( ) const { + return rowName_; + } + /// Returns column name of current field + inline const char *columnName ( ) const { + return columnName_; + } + /// Returns value in current field + inline double value ( ) const { + return value_; + } + /// Returns value as string in current field + inline const char *valueString ( ) const { + return valueString_; + } + /// Whole card (for printing) + inline const char *card ( ) const { + return card_; + } + /// Whole card - so we look at it (not const so nextBlankOr will work for gms reader) + inline char *mutableCard ( ) { + return card_; + } + /// set position (again so gms reader will work) + inline void setPosition(char * position) + { position_=position;} + /// get position (again so gms reader will work) + inline char * getPosition() const + { return position_;} + /// Returns card number + inline CoinBigIndex cardNumber ( ) const { + return cardNumber_; + } + /// Returns file input + inline CoinFileInput * fileInput ( ) const { + return input_; + } + /// Sets whether strings allowed + inline void setStringsAllowed() + { stringsAllowed_=true;} + //@} + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Current value + double value_; + /// Current card image + char card_[MAX_CARD_LENGTH]; + /// Current position within card image + char *position_; + /// End of card + char *eol_; + /// Current COINMpsType + COINMpsType mpsType_; + /// Current row name + char rowName_[COIN_MAX_FIELD_LENGTH]; + /// Current column name + char columnName_[COIN_MAX_FIELD_LENGTH]; + /// File input + CoinFileInput *input_; + /// Which section we think we are in + COINSectionType section_; + /// Card number + CoinBigIndex cardNumber_; + /// Whether free format. Just for blank RHS etc + bool freeFormat_; + /// Whether IEEE - 0 no, 1 INTEL, 2 not INTEL + int ieeeFormat_; + /// If all names <= 8 characters then allow embedded blanks + bool eightChar_; + /// MpsIO + CoinMpsIO * reader_; + /// Message handler + CoinMessageHandler * handler_; + /// Messages + CoinMessages messages_; + /// Current element as characters (only if strings allowed) + char valueString_[COIN_MAX_FIELD_LENGTH]; + /// Whether strings allowed + bool stringsAllowed_; + //@} +public: + /**@name methods */ + //@{ + /// type - 0 normal, 1 INTEL IEEE, 2 other IEEE + double osi_strtod(char * ptr, char ** output, int type); + /// remove blanks + static void strcpyAndCompress ( char *to, const char *from ); + /// + static char * nextBlankOr ( char *image ); + /// For strings + double osi_strtod(char * ptr, char ** output); + //@} + +}; + +//############################################################################# +#ifdef USE_SBB +class SbbObject; +class SbbModel; +#endif +/// Very simple class for containing data on set +class CoinSet { + +public: + + /**@name Constructor and destructor */ + //@{ + /// Default constructor + CoinSet ( ); + /// Constructor + CoinSet ( int numberEntries, const int * which); + + /// Copy constructor + CoinSet (const CoinSet &); + + /// Assignment operator + CoinSet & operator=(const CoinSet& rhs); + + /// Destructor + virtual ~CoinSet ( ); + //@} + + + /**@name gets */ + //@{ + /// Returns number of entries + inline int numberEntries ( ) const + { return numberEntries_; } + /// Returns type of set - 1 =SOS1, 2 =SOS2 + inline int setType ( ) const + { return setType_; } + /// Returns list of variables + inline const int * which ( ) const + { return which_; } + /// Returns weights + inline const double * weights ( ) const + { return weights_; } + //@} + +#ifdef USE_SBB + /**@name Use in sbb */ + //@{ + /// returns an object of type SbbObject + virtual SbbObject * sbbObject(SbbModel * model) const + { return NULL;} + //@} +#endif + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Number of entries + int numberEntries_; + /// type of set + int setType_; + /// Which variables are in set + int * which_; + /// Weights + double * weights_; + //@} +}; + +//############################################################################# +/// Very simple class for containing SOS set +class CoinSosSet : public CoinSet{ + +public: + + /**@name Constructor and destructor */ + //@{ + /// Constructor + CoinSosSet ( int numberEntries, const int * which, const double * weights, int type); + + /// Destructor + virtual ~CoinSosSet ( ); + //@} + + +#ifdef USE_SBB + /**@name Use in sbb */ + //@{ + /// returns an object of type SbbObject + virtual SbbObject * sbbObject(SbbModel * model) const ; + //@} +#endif + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + //@} +}; + +//############################################################################# + +/** MPS IO Interface + + This class can be used to read in mps files without a solver. After + reading the file, the CoinMpsIO object contains all relevant data, which + may be more than a particular OsiSolverInterface allows for. Items may + be deleted to allow for flexibility of data storage. + + The implementation makes the CoinMpsIO object look very like a dummy solver, + as the same conventions are used. +*/ + +class CoinMpsIO { + friend void CoinMpsIOUnitTest(const std::string & mpsDir); + +public: + +/** @name Methods to retrieve problem information + + These methods return information about the problem held by the CoinMpsIO + object. + + Querying an object that has no data associated with it result in zeros for + the number of rows and columns, and NULL pointers from the methods that + return vectors. Const pointers returned from any data-query method are + always valid +*/ +//@{ + /// Get number of columns + int getNumCols() const; + + /// Get number of rows + int getNumRows() const; + + /// Get number of nonzero elements + int getNumElements() const; + + /// Get pointer to array[getNumCols()] of column lower bounds + const double * getColLower() const; + + /// Get pointer to array[getNumCols()] of column upper bounds + const double * getColUpper() const; + + /** Get pointer to array[getNumRows()] of constraint senses. + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + const char * getRowSense() const; + + /** Get pointer to array[getNumRows()] of constraint right-hand sides. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint right-hand side (rhs) is set as + <ul> + <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] + <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 + </ul> + */ + const double * getRightHandSide() const; + + /** Get pointer to array[getNumRows()] of row ranges. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint range (rowrange) is set as + <ul> + <li> if rowsense()[i] == 'R' then + rowrange()[i] == rowupper()[i] - rowlower()[i] + <li> if rowsense()[i] != 'R' then + rowrange()[i] is 0.0 + </ul> + Put another way, only range constraints have a nontrivial value for + rowrange. + */ + const double * getRowRange() const; + + /// Get pointer to array[getNumRows()] of row lower bounds + const double * getRowLower() const; + + /// Get pointer to array[getNumRows()] of row upper bounds + const double * getRowUpper() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const double * getObjCoefficients() const; + + /// Get pointer to row-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByCol() const; + + /// Return true if column is a continuous variable + bool isContinuous(int colNumber) const; + + /** Return true if a column is an integer variable + + Note: This function returns true if the the column + is a binary or general integer variable. + */ + bool isInteger(int columnNumber) const; + + /** Returns array[getNumCols()] specifying if a variable is integer. + + At present, simply coded as zero (continuous) and non-zero (integer) + May be extended at a later date. + */ + const char * integerColumns() const; + + /** Returns the row name for the specified index. + + Returns 0 if the index is out of range. + */ + const char * rowName(int index) const; + + /** Returns the column name for the specified index. + + Returns 0 if the index is out of range. + */ + const char * columnName(int index) const; + + /** Returns the index for the specified row name + + Returns -1 if the name is not found. + Returns numberRows for the objective row and > numberRows for + dropped free rows. + */ + int rowIndex(const char * name) const; + + /** Returns the index for the specified column name + + Returns -1 if the name is not found. + */ + int columnIndex(const char * name) const; + + /** Returns the (constant) objective offset + + This is the RHS entry for the objective row + */ + double objectiveOffset() const; + /// Set objective offset + inline void setObjectiveOffset(double value) + { objectiveOffset_=value;} + + /// Return the problem name + const char * getProblemName() const; + + /// Return the objective name + const char * getObjectiveName() const; + + /// Return the RHS vector name + const char * getRhsName() const; + + /// Return the range vector name + const char * getRangeName() const; + + /// Return the bound vector name + const char * getBoundName() const; + /// Number of string elements + inline int numberStringElements() const + { return numberStringElements_;} + /// String element + inline const char * stringElement(int i) const + { return stringElements_[i];} +//@} + + +/** @name Methods to set problem information + + Methods to load a problem into the CoinMpsIO object. +*/ +//@{ + + /// Set the problem data + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub, + char const * const * const colnames, + char const * const * const rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub, + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const char* rowsen, const double* rowrhs, + const double* rowrng, + char const * const * const colnames, + char const * const * const rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const char* rowsen, const double* rowrhs, + const double* rowrng, + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + + /** Pass in an array[getNumCols()] specifying if a variable is integer. + + At present, simply coded as zero (continuous) and non-zero (integer) + May be extended at a later date. + */ + void copyInIntegerInformation(const char * integerInformation); + + /// Set problem name + void setProblemName(const char *name) ; + + /// Set objective name + void setObjectiveName(const char *name) ; + +//@} + +/** @name Parameter set/get methods + + Methods to set and retrieve MPS IO parameters. +*/ + +//@{ + /// Set infinity + void setInfinity(double value); + + /// Get infinity + double getInfinity() const; + + /// Set default upper bound for integer variables + void setDefaultBound(int value); + + /// Get default upper bound for integer variables + int getDefaultBound() const; + /// Whether to allow string elements + inline int allowStringElements() const + { return allowStringElements_;} + /// Whether to allow string elements (0 no, 1 yes, 2 yes and try flip) + inline void setAllowStringElements(int yesNo) + { allowStringElements_ = yesNo;} + /** Small element value - elements less than this set to zero on input + default is 1.0e-14 */ + inline double getSmallElementValue() const + { return smallElement_;} + inline void setSmallElementValue(double value) + { smallElement_=value;} +//@} + + +/** @name Methods for problem input and output + + Methods to read and write MPS format problem files. + + The read and write methods return the number of errors that occurred during + the IO operation, or -1 if no file is opened. + + \note + If the CoinMpsIO class was compiled with support for libz then + readMps will automatically try to append .gz to the file name and open it as + a compressed file if the specified file name cannot be opened. + (Automatic append of the .bz2 suffix when libbz is used is on the TODO list.) + + \todo + Allow for file pointers and positioning +*/ + +//@{ + /// Set the current file name for the CoinMpsIO object + void setFileName(const char * name); + + /// Get the current file name for the CoinMpsIO object + const char * getFileName() const; + + /** Read a problem in MPS format from the given filename. + + Use "stdin" or "-" to read from stdin. + */ + int readMps(const char *filename, const char *extension = "mps"); + + /** Read a problem in MPS format from the given filename. + + Use "stdin" or "-" to read from stdin. + But do sets as well + */ + int readMps(const char *filename, const char *extension , + int & numberSets, CoinSet **& sets); + + /** Read a problem in MPS format from a previously opened file + + More precisely, read a problem using a CoinMpsCardReader object already + associated with this CoinMpsIO object. + + \todo + Provide an interface that will allow a client to associate a + CoinMpsCardReader object with a CoinMpsIO object by setting the + cardReader_ field. + */ + int readMps(); + /// and + int readMps(int & numberSets, CoinSet **& sets); + /** Read a basis in MPS format from the given filename. + If VALUES on NAME card and solution not NULL fills in solution + status values as for CoinWarmStartBasis (but one per char) + -1 file error, 0 normal, 1 has solution values + + Use "stdin" or "-" to read from stdin. + + If sizes of names incorrect - read without names + */ + int readBasis(const char *filename, const char *extension , + double * solution, unsigned char *rowStatus, unsigned char *columnStatus, + const std::vector<std::string> & colnames,int numberColumns, + const std::vector<std::string> & rownames, int numberRows); + + /** Read a problem in GAMS format from the given filename. + + Use "stdin" or "-" to read from stdin. + if convertObjective then massages objective column + */ + int readGms(const char *filename, const char *extension = "gms",bool convertObjective=false); + + /** Read a problem in GAMS format from the given filename. + + Use "stdin" or "-" to read from stdin. + But do sets as well + */ + int readGms(const char *filename, const char *extension , + int & numberSets, CoinSet **& sets); + + /** Read a problem in GAMS format from a previously opened file + + More precisely, read a problem using a CoinMpsCardReader object already + associated with this CoinMpsIO object. + + */ + // Not for now int readGms(); + /// and + int readGms(int & numberSets, CoinSet **& sets); + /** Read a problem in GMPL (subset of AMPL) format from the given filenames. + */ + int readGMPL(const char *modelName, const char * dataName=NULL, bool keepNames=false); + + /** Write the problem in MPS format to a file with the given filename. + + \param compression can be set to three values to indicate what kind + of file should be written + <ul> + <li> 0: plain text (default) + <li> 1: gzip compressed (.gz is appended to \c filename) + <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO) + </ul> + If the library was not compiled with the requested compression then + writeMps falls back to writing a plain text file. + + \param formatType specifies the precision to used for values in the + MPS file + <ul> + <li> 0: normal precision (default) + <li> 1: extra accuracy + <li> 2: IEEE hex + </ul> + + \param numberAcross specifies whether 1 or 2 (default) values should be + specified on every data line in the MPS file. + + \param quadratic specifies quadratic objective to be output + */ + int writeMps(const char *filename, int compression = 0, + int formatType = 0, int numberAcross = 2, + CoinPackedMatrix * quadratic = NULL, + int numberSOS=0,const CoinSet * setInfo=NULL) const; + + /// Return card reader object so can see what last card was e.g. QUADOBJ + inline const CoinMpsCardReader * reader() const + { return cardReader_;} + + /** Read in a quadratic objective from the given filename. + + If filename is NULL (or the same as the currently open file) then + reading continues from the current file. + If not, the file is closed and the specified file is opened. + + Code should be added to + general MPS reader to read this if QSECTION + Data is assumed to be Q and objective is c + 1/2 xT Q x + No assumption is made for symmetry, positive definite, etc. + No check is made for duplicates or non-triangular if checkSymmetry==0. + If 1 checks lower triangular (so off diagonal should be 2*Q) + if 2 makes lower triangular and assumes full Q (but adds off diagonals) + + Arrays should be deleted by delete [] + + Returns number of errors: + <ul> + <li> -1: bad file + <li> -2: no Quadratic section + <li> -3: an empty section + <li> +n: then matching errors etc (symmetry forced) + <li> -4: no matching errors but fails triangular test + (triangularity forced) + </ul> + columnStart is numberColumns+1 long, others numberNonZeros + */ + int readQuadraticMps(const char * filename, + int * &columnStart, int * &column, double * &elements, + int checkSymmetry); + + /** Read in a list of cones from the given filename. + + If filename is NULL (or the same as the currently open file) then + reading continues from the current file. + If not, the file is closed and the specified file is opened. + + Code should be added to + general MPS reader to read this if CSECTION + No checking is done that in unique cone + + Arrays should be deleted by delete [] + + Returns number of errors, -1 bad file, -2 no conic section, + -3 empty section + + columnStart is numberCones+1 long, other number of columns in matrix + + coneType is 1 for QUAD, 2 for RQUAD (numberCones long) +*/ + int readConicMps(const char * filename, + int * &columnStart, int * &column, int * &coneType, int & numberCones); + /// Set whether to move objective from matrix + inline void setConvertObjective(bool trueFalse) + { convertObjective_=trueFalse;} + /// copies in strings from a CoinModel - returns number + int copyStringElements(const CoinModel * model); + //@} + +/** @name Constructors and destructors */ +//@{ + /// Default Constructor + CoinMpsIO(); + + /// Copy constructor + CoinMpsIO (const CoinMpsIO &); + + /// Assignment operator + CoinMpsIO & operator=(const CoinMpsIO& rhs); + + /// Destructor + ~CoinMpsIO (); +//@} + + +/**@name Message handling */ +//@{ + /** Pass in Message handler + + Supply a custom message handler. It will not be destroyed when the + CoinMpsIO object is destroyed. + */ + void passInMessageHandler(CoinMessageHandler * handler); + + /// Set the language for messages. + void newLanguage(CoinMessages::Language language); + + /// Set the language for messages. + inline void setLanguage(CoinMessages::Language language) {newLanguage(language);} + + /// Return the message handler + inline CoinMessageHandler * messageHandler() const {return handler_;} + + /// Return the messages + inline CoinMessages messages() {return messages_;} + /// Return the messages pointer + inline CoinMessages * messagesPointer() {return & messages_;} +//@} + + +/**@name Methods to release storage + + These methods allow the client to reduce the storage used by the CoinMpsIO + object be selectively releasing unneeded problem information. +*/ +//@{ + /** Release all information which can be re-calculated. + + E.g., row sense, copies of rows, hash tables for names. + */ + void releaseRedundantInformation(); + + /// Release all row information (lower, upper) + void releaseRowInformation(); + + /// Release all column information (lower, upper, objective) + void releaseColumnInformation(); + + /// Release integer information + void releaseIntegerInformation(); + + /// Release row names + void releaseRowNames(); + + /// Release column names + void releaseColumnNames(); + + /// Release matrix information + void releaseMatrixInformation(); + //@} + +protected: + +/**@name Miscellaneous helper functions */ + //@{ + + /// Utility method used several times to implement public methods + void + setMpsDataWithoutRowAndColNames( + const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub); + void + setMpsDataColAndRowNames( + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + void + setMpsDataColAndRowNames( + char const * const * const colnames, + char const * const * const rownames); + + + /// Does the heavy lifting for destruct and assignment. + void gutsOfDestructor(); + + /// Does the heavy lifting for copy and assignment. + void gutsOfCopy(const CoinMpsIO &); + + /// Clears problem data from the CoinMpsIO object. + void freeAll(); + + + /** A quick inlined function to convert from lb/ub style constraint + definition to sense/rhs/range style */ + inline void + convertBoundToSense(const double lower, const double upper, + char& sense, double& right, double& range) const; + /** A quick inlined function to convert from sense/rhs/range stryle + constraint definition to lb/ub style */ + inline void + convertSenseToBound(const char sense, const double right, + const double range, + double& lower, double& upper) const; + + /** Deal with a filename + + As the name says. + Returns +1 if the file name is new, 0 if it's the same as before + (i.e., matches fileName_), and -1 if there's an error and the file + can't be opened. + Handles automatic append of .gz suffix when compiled with libz. + + \todo + Add automatic append of .bz2 suffix when compiled with libbz. + */ + + int dealWithFileName(const char * filename, const char * extension, + CoinFileInput * &input); + /** Add string to list + iRow==numberRows is objective, nr+1 is lo, nr+2 is up + iColumn==nc is rhs (can't cope with ranges at present) + */ + void addString(int iRow,int iColumn, const char * value); + /// Decode string + void decodeString(int iString, int & iRow, int & iColumn, const char * & value) const; + //@} + + + // for hashing + typedef struct { + int index, next; + } CoinHashLink; + + /**@name Hash table methods */ + //@{ + /// Creates hash list for names (section = 0 for rows, 1 columns) + void startHash ( char **names, const int number , int section ); + /// This one does it when names are already in + void startHash ( int section ) const; + /// Deletes hash storage + void stopHash ( int section ); + /// Finds match using hash, -1 not found + int findHash ( const char *name , int section ) const; + //@} + + /**@name Cached problem information */ + //@{ + /// Problem name + char * problemName_; + + /// Objective row name + char * objectiveName_; + + /// Right-hand side vector name + char * rhsName_; + + /// Range vector name + char * rangeName_; + + /// Bounds vector name + char * boundName_; + + /// Number of rows + int numberRows_; + + /// Number of columns + int numberColumns_; + + /// Number of coefficients + CoinBigIndex numberElements_; + + /// Pointer to dense vector of row sense indicators + mutable char *rowsense_; + + /// Pointer to dense vector of row right-hand side values + mutable double *rhs_; + + /** Pointer to dense vector of slack variable upper bounds for range + constraints (undefined for non-range rows) + */ + mutable double *rowrange_; + + /// Pointer to row-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByRow_; + + /// Pointer to column-wise copy of problem matrix coefficients. + CoinPackedMatrix *matrixByColumn_; + + /// Pointer to dense vector of row lower bounds + double * rowlower_; + + /// Pointer to dense vector of row upper bounds + double * rowupper_; + + /// Pointer to dense vector of column lower bounds + double * collower_; + + /// Pointer to dense vector of column upper bounds + double * colupper_; + + /// Pointer to dense vector of objective coefficients + double * objective_; + + /// Constant offset for objective value (i.e., RHS value for OBJ row) + double objectiveOffset_; + + + /** Pointer to dense vector specifying if a variable is continuous + (0) or integer (1). + */ + char * integerType_; + + /** Row and column names + Linked to hash table sections (0 - row names, 1 column names) + */ + char **names_[2]; + //@} + + /** @name Hash tables */ + //@{ + /// Current file name + char * fileName_; + + /// Number of entries in a hash table section + int numberHash_[2]; + + /// Hash tables (two sections, 0 - row names, 1 - column names) + mutable CoinHashLink *hash_[2]; + //@} + + /** @name CoinMpsIO object parameters */ + //@{ + /// Upper bound when no bounds for integers + int defaultBound_; + + /// Value to use for infinity + double infinity_; + /// Small element value + double smallElement_; + + /// Message handler + CoinMessageHandler * handler_; + /** Flag to say if the message handler is the default handler. + + If true, the handler will be destroyed when the CoinMpsIO + object is destroyed; if false, it will not be destroyed. + */ + bool defaultHandler_; + /// Messages + CoinMessages messages_; + /// Card reader + CoinMpsCardReader * cardReader_; + /// If .gms file should it be massaged to move objective + bool convertObjective_; + /// Whether to allow string elements + int allowStringElements_; + /// Maximum number of string elements + int maximumStringElements_; + /// Number of string elements + int numberStringElements_; + /// String elements + char ** stringElements_; + //@} + +}; + +//############################################################################# +/** A function that tests the methods in the CoinMpsIO class. The + only reason for it not to be a member method is that this way it doesn't + have to be compiled into the library. And that's a gain, because the + library should be compiled with optimization on, but this method should be + compiled with debugging. Also, if this method is compiled with + optimization, the compilation takes 10-15 minutes and the machine pages + (has 256M core memory!)... */ +void +CoinMpsIOUnitTest(const std::string & mpsDir); +// Function to return number in most efficient way +// section is 0 for columns, 1 for rhs,ranges and 2 for bounds +/* formatType is + 0 - normal and 8 character names + 1 - extra accuracy + 2 - IEEE hex - INTEL + 3 - IEEE hex - not INTEL +*/ +void +CoinConvertDouble(int section, int formatType, double value, char outputValue[24]); + +#endif + |