CoinMpsIO.hpp

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinMpsIO_H
#define CoinMpsIO_H

#include <vector>
#include <string>

#include "CoinPackedMatrix.hpp"
#include "CoinMessageHandler.hpp"
#ifdef COIN_USE_ZLIB
#include "zlib.h"
#else
/* just to make the code much nicer (no need for so many ifdefs */
typedef void* gzFile;
#endif

// Plus infinity
#ifndef COIN_DBL_MAX
#define COIN_DBL_MAX DBL_MAX
#endif

typedef int COINColumnIndex;

typedef int COINRowIndex;

// We are allowing free format - but there is a limit!
#define MAX_FIELD_LENGTH 100
#define MAX_CARD_LENGTH 5*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_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_SC_BOUND, COIN_UNKNOWN_MPS_TYPE
};
class CoinMpsIO;
class CoinMpsCardReader {

public:



  CoinMpsCardReader ( FILE * fp, gzFile gzfp, CoinMpsIO * reader );

  ~CoinMpsCardReader (  );



  COINSectionType readToNextSection (  );
  COINSectionType nextField (  );
  inline COINSectionType whichSection (  ) const {
    return section_;
  };
  inline COINMpsType mpsType (  ) const {
    return mpsType_;
  };
  int cleanCard();
  inline const char *rowName (  ) const {
    return rowName_;
  };
  inline const char *columnName (  ) const {
    return columnName_;
  };
  inline double value (  ) const {
    return value_;
  };
  inline const char *card (  ) const {
    return card_;
  };
  inline CoinBigIndex cardNumber (  ) const {
    return cardNumber_;
  };
  inline FILE * filePointer (  ) const {
    return fp_;
  };

protected:


  double value_;
  char card_[MAX_CARD_LENGTH];
  char *position_;
  char *eol_;
  COINMpsType mpsType_;
  char rowName_[MAX_FIELD_LENGTH];
  char columnName_[MAX_FIELD_LENGTH];
  FILE *fp_;
  gzFile gzfp_;
  COINSectionType section_;
  CoinBigIndex cardNumber_;
  bool freeFormat_;
  bool eightChar_;
  CoinMpsIO * reader_;
  CoinMessageHandler * handler_;
  CoinMessages messages_;
};

//#############################################################################

class CoinMpsIO {
   friend void CoinMpsIOUnitTest(const std::string & mpsDir);

public:


    int getNumCols() const;

    int getNumRows() const;

    int getNumElements() const;

    const double * getColLower() const;

    const double * getColUpper() const;

    const char * getRowSense() const;

    const double * getRightHandSide() const;

    const double * getRowRange() const;

    const double * getRowLower() const;

    const double * getRowUpper() const;

    const double * getObjCoefficients() const;

    const CoinPackedMatrix * getMatrixByRow() const;

    const CoinPackedMatrix * getMatrixByCol() const;

    bool isContinuous(int colNumber) const;

    bool isInteger(int columnNumber) const;
  
    const char * integerColumns() const;

    const char * rowName(int index) const;

    const char * columnName(int index) const;

    int rowIndex(const char * name) const;

    int columnIndex(const char * name) const;

    double objectiveOffset() const;

    const char * getProblemName() const;

    const char * getObjectiveName() const;

    const char * getRhsName() const;

    const char * getRangeName() const;

    const char * getBoundName() const;


  
    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);

    void copyInIntegerInformation(const char * integerInformation);


    void setInfinity(double value);

    double getInfinity() const;

    void setDefaultBound(int value);

    int getDefaultBound() const;



    void setFileName(const char * name);

    const char * getFileName() const;

    const bool fileReadable() const;

    int readMps(const char *filename, const char *extension = "mps");

    int readMps();

    int writeMps(const char *filename, int compression = 0,
                 int formatType = 0, int numberAcross = 2) const;

    int readQuadraticMps(const char * filename,
                         int * &columnStart, int * &column, double * &elements,
                         int checkSymmetry);

    int readConicMps(const char * filename,
                     int * &columnStart, int * &column, int & numberCones);


    CoinMpsIO(); 
      
    CoinMpsIO (const CoinMpsIO &);
  
    CoinMpsIO & operator=(const CoinMpsIO& rhs);
  
    ~CoinMpsIO ();


  void passInMessageHandler(CoinMessageHandler * handler);

  void newLanguage(CoinMessages::Language language);

  void setLanguage(CoinMessages::Language language) {newLanguage(language);};

  CoinMessageHandler * messageHandler() const {return handler_;};

  CoinMessages messages() {return messages_;};


    void releaseRedundantInformation();

    void releaseRowInformation();

    void releaseColumnInformation();

    void releaseIntegerInformation();

    void releaseRowNames();

    void releaseColumnNames();

    void releaseMatrixInformation();

protected:
  

    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);

  
    void gutsOfDestructor();

    void gutsOfCopy(const CoinMpsIO &);
  
    void freeAll();

    inline void
    convertBoundToSense(const double lower, const double upper,
                        char& sense, double& right, double& range) const;
    inline void
    convertSenseToBound(const char sense, const double right,
                        const double range,
                        double& lower, double& upper) const;

  int dealWithFileName(const char * filename,  const char * extension,
                       FILE * & fp, gzFile  & gzfp); 

  
  // for hashing
  typedef struct {
    int index, next;
  } CoinHashLink;


  void startHash ( char **names, const int number , int section );
  void startHash ( int section ) const;
  void stopHash ( int section );
  int findHash ( const char *name , int section ) const;


      char * problemName_;

      char * objectiveName_;

      char * rhsName_;

      char * rangeName_;

      char * boundName_;

      int numberRows_;

      int numberColumns_;

      CoinBigIndex numberElements_;

      mutable char    *rowsense_;
  
      mutable double  *rhs_;
  
      mutable double  *rowrange_;
   
      mutable CoinPackedMatrix *matrixByRow_;  

      CoinPackedMatrix *matrixByColumn_;  

      double * rowlower_;

      double * rowupper_;

      double * collower_;

      double * colupper_;

      double * objective_;

      double objectiveOffset_;


      char * integerType_;

      char **names_[2];


      char * fileName_;

      int numberHash_[2];

      mutable CoinHashLink *hash_[2];


      int defaultBound_; 

      double infinity_;

      CoinMessageHandler * handler_;
      bool defaultHandler_;
      CoinMessages messages_;
      CoinMpsCardReader * cardReader_;

};

//#############################################################################
void
CoinMpsIOUnitTest(const std::string & mpsDir);

#endif

---