# CoinMpsIO.hpp

Go to the documentation of this file.

    00001 /* $Id: CoinMpsIO.hpp 1642 2013-10-16 00:43:14Z tkr $ */
    00002 // Copyright (C) 2000, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef CoinMpsIO_H
    00007 #define CoinMpsIO_H
    00008
    00009 #if defined(_MSC_VER)
    00010 // Turn off compiler warning about long names
    00011 #  pragma warning(disable:4786)
    00012 #endif
    00013
    00014 #include <vector>
    00015 #include <string>
    00016
    00017 #include "CoinUtilsConfig.h"
    00018 #include "CoinPackedMatrix.hpp"
    00019 #include "CoinMessageHandler.hpp"
    00020 #include "CoinFileIO.hpp"
    00021 class CoinModel;
    00022
    00027 typedef int COINColumnIndex;
    00028
    00030 typedef int COINRowIndex;
    00031
    00032 // We are allowing free format - but there is a limit!
    00033 // User can override by using CXXFLAGS += -DCOIN_MAX_FIELD_LENGTH=nnn
    00034 #ifndef COIN_MAX_FIELD_LENGTH
    00035 #define COIN_MAX_FIELD_LENGTH 160
    00036 #endif
    00037 #define MAX_CARD_LENGTH 5*COIN_MAX_FIELD_LENGTH+80
    00038
    00039 enum COINSectionType { COIN_NO_SECTION, COIN_NAME_SECTION, COIN_ROW_SECTION,
    00040                        COIN_COLUMN_SECTION,
    00041                        COIN_RHS_SECTION, COIN_RANGES_SECTION, COIN_BOUNDS_SECTION,
    00042                        COIN_ENDATA_SECTION, COIN_EOF_SECTION, COIN_QUADRATIC_SECTION,
    00043                        COIN_CONIC_SECTION,COIN_QUAD_SECTION,COIN_SOS_SECTION,
    00044                        COIN_BASIS_SECTION,COIN_UNKNOWN_SECTION
    00045 };
    00046
    00047 enum COINMpsType { COIN_N_ROW, COIN_E_ROW, COIN_L_ROW, COIN_G_ROW,
    00048   COIN_BLANK_COLUMN, COIN_S1_COLUMN, COIN_S2_COLUMN, COIN_S3_COLUMN,
    00049   COIN_INTORG, COIN_INTEND, COIN_SOSEND, COIN_UNSET_BOUND,
    00050   COIN_UP_BOUND, COIN_FX_BOUND, COIN_LO_BOUND, COIN_FR_BOUND,
    00051                    COIN_MI_BOUND, COIN_PL_BOUND, COIN_BV_BOUND,
    00052                                    COIN_UI_BOUND, COIN_LI_BOUND, COIN_BOTH_BOUNDS_SET,
    00053                    COIN_SC_BOUND, COIN_S1_BOUND, COIN_S2_BOUND,
    00054                    COIN_BS_BASIS, COIN_XL_BASIS, COIN_XU_BASIS,
    00055                    COIN_LL_BASIS, COIN_UL_BASIS, COIN_UNKNOWN_MPS_TYPE
    00056 };
    00057 class CoinMpsIO;
    00059 class CoinMpsCardReader {
    00060
    00061 public:
    00062
    00065
    00066
    00067   CoinMpsCardReader ( CoinFileInput *input, CoinMpsIO * reader );
    00068
    00070   ~CoinMpsCardReader (  );
    00072
    00073
    00076
    00077   COINSectionType readToNextSection (  );
    00079   COINSectionType nextField (  );
    00093   int nextGmsField ( int expectedType );
    00095   inline COINSectionType whichSection (  ) const {
    00096     return section_;
    00097   }
    00099   inline void setWhichSection(COINSectionType section  ) {
    00100     section_=section;
    00101   }
    00103   inline bool freeFormat() const
    00104   { return freeFormat_;}
    00106   inline void setFreeFormat(bool yesNo)
    00107   { freeFormat_=yesNo;}
    00110   inline COINMpsType mpsType (  ) const {
    00111     return mpsType_;
    00112   }
    00114   int cleanCard();
    00116   inline const char *rowName (  ) const {
    00117     return rowName_;
    00118   }
    00120   inline const char *columnName (  ) const {
    00121     return columnName_;
    00122   }
    00124   inline double value (  ) const {
    00125     return value_;
    00126   }
    00128   inline const char *valueString (  ) const {
    00129     return valueString_;
    00130   }
    00132   inline const char *card (  ) const {
    00133     return card_;
    00134   }
    00136   inline char *mutableCard (  ) {
    00137     return card_;
    00138   }
    00140   inline void setPosition(char * position)
    00141   { position_=position;}
    00143   inline char * getPosition() const
    00144   { return position_;}
    00146   inline CoinBigIndex cardNumber (  ) const {
    00147     return cardNumber_;
    00148   }
    00150   inline CoinFileInput * fileInput (  ) const {
    00151     return input_;
    00152   }
    00154   inline void setStringsAllowed()
    00155   { stringsAllowed_=true;}
    00157
    00159 protected:
    00160
    00163
    00164   double value_;
    00166   char card_[MAX_CARD_LENGTH];
    00168   char *position_;
    00170   char *eol_;
    00172   COINMpsType mpsType_;
    00174   char rowName_[COIN_MAX_FIELD_LENGTH];
    00176   char columnName_[COIN_MAX_FIELD_LENGTH];
    00178   CoinFileInput *input_;
    00180   COINSectionType section_;
    00182   CoinBigIndex cardNumber_;
    00184   bool freeFormat_;
    00186   int ieeeFormat_;
    00188   bool eightChar_;
    00190   CoinMpsIO * reader_;
    00192   CoinMessageHandler * handler_;
    00194   CoinMessages messages_;
    00196   char valueString_[COIN_MAX_FIELD_LENGTH];
    00198   bool stringsAllowed_;
    00200 public:
    00203
    00204   double osi_strtod(char * ptr, char ** output, int type);
    00206   static void strcpyAndCompress ( char *to, const char *from );
    00208   static char * nextBlankOr ( char *image );
    00210   double osi_strtod(char * ptr, char ** output);
    00212
    00213 };
    00214
    00215 //#############################################################################
    00216 #ifdef USE_SBB
    00217 class SbbObject;
    00218 class SbbModel;
    00219 #endif
    00221 class CoinSet {
    00222
    00223 public:
    00224
    00227
    00228   CoinSet ( );
    00230   CoinSet ( int numberEntries, const int * which);
    00231
    00233   CoinSet (const CoinSet &);
    00234
    00236   CoinSet & operator=(const CoinSet& rhs);
    00237
    00239   virtual ~CoinSet (  );
    00241
    00242
    00245
    00246   inline int numberEntries (  ) const
    00247   { return numberEntries_;  }
    00249   inline int setType (  ) const
    00250   { return setType_;  }
    00252   inline const int * which (  ) const
    00253   { return which_;  }
    00255   inline const double * weights (  ) const
    00256   { return weights_;  }
    00258
    00259 #ifdef USE_SBB
    00260
    00262
    00263   virtual SbbObject * sbbObject(SbbModel * model) const
    00264   { return NULL;}
    00266 #endif
    00267
    00269 protected:
    00270
    00273
    00274   int numberEntries_;
    00276   int setType_;
    00278   int * which_;
    00280   double * weights_;
    00282 };
    00283
    00284 //#############################################################################
    00286 class CoinSosSet : public CoinSet{
    00287
    00288 public:
    00289
    00292
    00293   CoinSosSet ( int numberEntries, const int * which, const double * weights, int type);
    00294
    00296   virtual ~CoinSosSet (  );
    00298
    00299
    00300 #ifdef USE_SBB
    00301
    00303
    00304   virtual SbbObject * sbbObject(SbbModel * model) const ;
    00306 #endif
    00307
    00309 protected:
    00310
    00313
    00314 };
    00315
    00316 //#############################################################################
    00317
    00329 class CoinMpsIO {
    00330    friend void CoinMpsIOUnitTest(const std::string & mpsDir);
    00331
    00332 public:
    00333
    00345
    00346     int getNumCols() const;
    00347
    00349     int getNumRows() const;
    00350
    00352     int getNumElements() const;
    00353
    00355     const double * getColLower() const;
    00356
    00358     const double * getColUpper() const;
    00359
    00369     const char * getRowSense() const;
    00370
    00382     const double * getRightHandSide() const;
    00383
    00397     const double * getRowRange() const;
    00398
    00400     const double * getRowLower() const;
    00401
    00403     const double * getRowUpper() const;
    00404
    00406     const double * getObjCoefficients() const;
    00407
    00409     const CoinPackedMatrix * getMatrixByRow() const;
    00410
    00412     const CoinPackedMatrix * getMatrixByCol() const;
    00413
    00415     bool isContinuous(int colNumber) const;
    00416
    00422     bool isInteger(int columnNumber) const;
    00423
    00429     const char * integerColumns() const;
    00430
    00435     const char * rowName(int index) const;
    00436
    00441     const char * columnName(int index) const;
    00442
    00449     int rowIndex(const char * name) const;
    00450
    00455     int columnIndex(const char * name) const;
    00456
    00461     double objectiveOffset() const;
    00463     inline void setObjectiveOffset(double value)
    00464     { objectiveOffset_=value;}
    00465
    00467     const char * getProblemName() const;
    00468
    00470     const char * getObjectiveName() const;
    00471
    00473     const char * getRhsName() const;
    00474
    00476     const char * getRangeName() const;
    00477
    00479     const char * getBoundName() const;
    00481     inline int numberStringElements() const
    00482     { return numberStringElements_;}
    00484     inline const char * stringElement(int i) const
    00485     { return stringElements_[i];}
    00487
    00488
    00494
    00496     void setMpsData(const CoinPackedMatrix& m, const double infinity,
    00497                      const double* collb, const double* colub,
    00498                      const double* obj, const char* integrality,
    00499                      const double* rowlb, const double* rowub,
    00500                      char const * const * const colnames,
    00501                      char const * const * const rownames);
    00502     void setMpsData(const CoinPackedMatrix& m, const double infinity,
    00503                      const double* collb, const double* colub,
    00504                      const double* obj, const char* integrality,
    00505                      const double* rowlb, const double* rowub,
    00506                      const std::vector<std::string> & colnames,
    00507                      const std::vector<std::string> & rownames);
    00508     void setMpsData(const CoinPackedMatrix& m, const double infinity,
    00509                      const double* collb, const double* colub,
    00510                      const double* obj, const char* integrality,
    00511                      const char* rowsen, const double* rowrhs,
    00512                      const double* rowrng,
    00513                      char const * const * const colnames,
    00514                      char const * const * const rownames);
    00515     void setMpsData(const CoinPackedMatrix& m, const double infinity,
    00516                      const double* collb, const double* colub,
    00517                      const double* obj, const char* integrality,
    00518                      const char* rowsen, const double* rowrhs,
    00519                      const double* rowrng,
    00520                      const std::vector<std::string> & colnames,
    00521                      const std::vector<std::string> & rownames);
    00522
    00528     void copyInIntegerInformation(const char * integerInformation);
    00529
    00531     void setProblemName(const char *name) ;
    00532
    00534     void setObjectiveName(const char *name) ;
    00535
    00537
    00544
    00545     void setInfinity(double value);
    00546
    00548     double getInfinity() const;
    00549
    00551     void setDefaultBound(int value);
    00552
    00554     int getDefaultBound() const;
    00556     inline int allowStringElements() const
    00557     { return allowStringElements_;}
    00559     inline void setAllowStringElements(int yesNo)
    00560     { allowStringElements_ = yesNo;}
    00563     inline double getSmallElementValue() const
    00564     { return smallElement_;}
    00565     inline void setSmallElementValue(double value)
    00566     { smallElement_=value;}
    00568
    00569
    00588
    00589     void setFileName(const char * name);
    00590
    00592     const char * getFileName() const;
    00593
    00598     int readMps(const char *filename, const char *extension = "mps");
    00599
    00605      int readMps(const char *filename, const char *extension ,
    00606         int & numberSets, CoinSet **& sets);
    00607
    00618     int readMps();
    00620     int readMps(int & numberSets, CoinSet **& sets);
    00630     int readBasis(const char *filename, const char *extension ,
    00631                   double * solution, unsigned char *rowStatus, unsigned char *columnStatus,
    00632                   const std::vector<std::string> & colnames,int numberColumns,
    00633                   const std::vector<std::string> & rownames, int numberRows);
    00634
    00640     int readGms(const char *filename, const char *extension = "gms",bool convertObjective=false);
    00641
    00647      int readGms(const char *filename, const char *extension ,
    00648         int & numberSets, CoinSet **& sets);
    00649
    00656     // Not for now int readGms();
    00658     int readGms(int & numberSets, CoinSet **& sets);
    00661     int readGMPL(const char *modelName, const char * dataName=NULL, bool keepNames=false);
    00662
    00688     int writeMps(const char *filename, int compression = 0,
    00689                  int formatType = 0, int numberAcross = 2,
    00690                  CoinPackedMatrix * quadratic = NULL,
    00691                  int numberSOS=0,const CoinSet * setInfo=NULL) const;
    00692
    00694     inline const CoinMpsCardReader * reader() const
    00695     { return cardReader_;}
    00696
    00724     int readQuadraticMps(const char * filename,
    00725                          int * &columnStart, int * &column, double * &elements,
    00726                          int checkSymmetry);
    00727
    00747         int readConicMps(const char * filename,
    00748                         int * &columnStart, int * &column, int * &coneType, int & numberCones);
    00750     inline void setConvertObjective(bool trueFalse)
    00751     { convertObjective_=trueFalse;}
    00753   int copyStringElements(const CoinModel * model);
    00755
    00758
    00759     CoinMpsIO();
    00760
    00762     CoinMpsIO (const CoinMpsIO &);
    00763
    00765     CoinMpsIO & operator=(const CoinMpsIO& rhs);
    00766
    00768     ~CoinMpsIO ();
    00770
    00771
    00779   void passInMessageHandler(CoinMessageHandler * handler);
    00780
    00782   void newLanguage(CoinMessages::Language language);
    00783
    00785   inline void setLanguage(CoinMessages::Language language) {newLanguage(language);}
    00786
    00788   inline CoinMessageHandler * messageHandler() const {return handler_;}
    00789
    00791   inline CoinMessages messages() {return messages_;}
    00793   inline CoinMessages * messagesPointer() {return & messages_;}
    00795
    00796
    00807     void releaseRedundantInformation();
    00808
    00810     void releaseRowInformation();
    00811
    00813     void releaseColumnInformation();
    00814
    00816     void releaseIntegerInformation();
    00817
    00819     void releaseRowNames();
    00820
    00822     void releaseColumnNames();
    00823
    00825     void releaseMatrixInformation();
    00827
    00828 protected:
    00829
    00832
    00834     void
    00835     setMpsDataWithoutRowAndColNames(
    00836                       const CoinPackedMatrix& m, const double infinity,
    00837                       const double* collb, const double* colub,
    00838                       const double* obj, const char* integrality,
    00839                       const double* rowlb, const double* rowub);
    00840     void
    00841     setMpsDataColAndRowNames(
    00842                       const std::vector<std::string> & colnames,
    00843                       const std::vector<std::string> & rownames);
    00844     void
    00845     setMpsDataColAndRowNames(
    00846                       char const * const * const colnames,
    00847                       char const * const * const rownames);
    00848
    00849
    00851     void gutsOfDestructor();
    00852
    00854     void gutsOfCopy(const CoinMpsIO &);
    00855
    00857     void freeAll();
    00858
    00859
    00862     inline void
    00863     convertBoundToSense(const double lower, const double upper,
    00864                         char& sense, double& right, double& range) const;
    00867     inline void
    00868     convertSenseToBound(const char sense, const double right,
    00869                         const double range,
    00870                         double& lower, double& upper) const;
    00871
    00884   int dealWithFileName(const char * filename,  const char * extension,
    00885                        CoinFileInput * &input);
    00890   void addString(int iRow,int iColumn, const char * value);
    00892   void decodeString(int iString, int & iRow, int & iColumn, const char * & value) const;
    00894
    00895
    00896   // for hashing
    00897   typedef struct {
    00898     int index, next;
    00899   } CoinHashLink;
    00900
    00903
    00904   void startHash ( char **names, const int number , int section );
    00906   void startHash ( int section ) const;
    00908   void stopHash ( int section );
    00910   int findHash ( const char *name , int section ) const;
    00912
    00915
    00916       char * problemName_;
    00917
    00919       char * objectiveName_;
    00920
    00922       char * rhsName_;
    00923
    00925       char * rangeName_;
    00926
    00928       char * boundName_;
    00929
    00931       int numberRows_;
    00932
    00934       int numberColumns_;
    00935
    00937       CoinBigIndex numberElements_;
    00938
    00940       mutable char    *rowsense_;
    00941
    00943       mutable double  *rhs_;
    00944
    00948       mutable double  *rowrange_;
    00949
    00951       mutable CoinPackedMatrix *matrixByRow_;
    00952
    00954       CoinPackedMatrix *matrixByColumn_;
    00955
    00957       double * rowlower_;
    00958
    00960       double * rowupper_;
    00961
    00963       double * collower_;
    00964
    00966       double * colupper_;
    00967
    00969       double * objective_;
    00970
    00972       double objectiveOffset_;
    00973
    00974
    00978       char * integerType_;
    00979
    00983       char **names_[2];
    00985
    00988
    00989       char * fileName_;
    00990
    00992       int numberHash_[2];
    00993
    00995       mutable CoinHashLink *hash_[2];
    00997
    01000
    01001       int defaultBound_;
    01002
    01004       double infinity_;
    01006       double smallElement_;
    01007
    01009       CoinMessageHandler * handler_;
    01015       bool defaultHandler_;
    01017       CoinMessages messages_;
    01019       CoinMpsCardReader * cardReader_;
    01021       bool convertObjective_;
    01023       int allowStringElements_;
    01025       int maximumStringElements_;
    01027       int numberStringElements_;
    01029       char ** stringElements_;
    01031
    01032 };
    01033
    01034 //#############################################################################
    01042 void
    01043 CoinMpsIOUnitTest(const std::string & mpsDir);
    01044 // Function to return number in most efficient way
    01045 // section is 0 for columns, 1 for rhs,ranges and 2 for bounds
    01046 /* formatType is
    01047    0 - normal and 8 character names
    01048    1 - extra accuracy
    01049    2 - IEEE hex - INTEL
    01050    3 - IEEE hex - not INTEL
    01051 */
    01052 void
    01053 CoinConvertDouble(int section, int formatType, double value, char outputValue[24]);
    01054
    01055 #endif
    01056

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines