CoinMpsIO.hpp

Go to the documentation of this file.

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

typedef int COINColumnIndex;

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;
class CoinMpsCardReader {

public:

  CoinMpsCardReader ( CoinFileInput *input, CoinMpsIO * reader );

  ~CoinMpsCardReader (  );


  COINSectionType readToNextSection (  );
  COINSectionType nextField (  );
  int nextGmsField ( int expectedType );
  inline COINSectionType whichSection (  ) const {
    return section_;
  }
  inline void setWhichSection(COINSectionType section  ) {
    section_=section;
  }
  inline bool freeFormat() const
  { return freeFormat_;}
  inline void setFreeFormat(bool yesNo) 
  { freeFormat_=yesNo;}
  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 *valueString (  ) const {
    return valueString_;
  }
  inline const char *card (  ) const {
    return card_;
  }
  inline char *mutableCard (  ) {
    return card_;
  }
  inline void setPosition(char * position)
  { position_=position;}
  inline char * getPosition() const
  { return position_;}
  inline CoinBigIndex cardNumber (  ) const {
    return cardNumber_;
  }
  inline CoinFileInput * fileInput (  ) const {
    return input_;
  }
  inline void setStringsAllowed()
  { stringsAllowed_=true;}

protected:

  double value_;
  char card_[MAX_CARD_LENGTH];
  char *position_;
  char *eol_;
  COINMpsType mpsType_;
  char rowName_[COIN_MAX_FIELD_LENGTH];
  char columnName_[COIN_MAX_FIELD_LENGTH];
  CoinFileInput *input_;
  COINSectionType section_;
  CoinBigIndex cardNumber_;
  bool freeFormat_;
  int ieeeFormat_;
  bool eightChar_;
  CoinMpsIO * reader_;
  CoinMessageHandler * handler_;
  CoinMessages messages_;
  char valueString_[COIN_MAX_FIELD_LENGTH];
  bool stringsAllowed_;
public:
  double osi_strtod(char * ptr, char ** output, int type);
  static void strcpyAndCompress ( char *to, const char *from );
  static char * nextBlankOr ( char *image );
  double osi_strtod(char * ptr, char ** output);

};

//#############################################################################
#ifdef USE_SBB
class SbbObject;
class SbbModel;
#endif
class CoinSet {

public:

  CoinSet ( );
  CoinSet ( int numberEntries, const int * which);

  CoinSet (const CoinSet &);
  
  CoinSet & operator=(const CoinSet& rhs);  
  
  virtual ~CoinSet (  );


  inline int numberEntries (  ) const 
  { return numberEntries_;  }
  inline int setType (  ) const 
  { return setType_;  }
  inline const int * which (  ) const 
  { return which_;  }
  inline const double * weights (  ) const 
  { return weights_;  }

#ifdef USE_SBB

  virtual SbbObject * sbbObject(SbbModel * model) const 
  { return NULL;}
#endif

protected:

  int numberEntries_;
  int setType_;
  int * which_;
  double * weights_;
};

//#############################################################################
class CoinSosSet : public CoinSet{

public:

  CoinSosSet ( int numberEntries, const int * which, const double * weights, int type);

  virtual ~CoinSosSet (  );


#ifdef USE_SBB

  virtual SbbObject * sbbObject(SbbModel * model) const ;
#endif

protected:


};

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

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;
    inline void setObjectiveOffset(double value)
    { objectiveOffset_=value;}

    const char * getProblemName() const;

    const char * getObjectiveName() const;

    const char * getRhsName() const;

    const char * getRangeName() const;

    const char * getBoundName() const;
    inline int numberStringElements() const
    { return numberStringElements_;}
    inline const char * stringElement(int i) const
    { return stringElements_[i];}


  
    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 setProblemName(const char *name) ;

    void setObjectiveName(const char *name) ;


    void setInfinity(double value);

    double getInfinity() const;

    void setDefaultBound(int value);

    int getDefaultBound() const;
    inline int allowStringElements() const
    { return allowStringElements_;}
    inline void setAllowStringElements(int yesNo)
    { allowStringElements_ = yesNo;}
    inline double getSmallElementValue() const
    { return smallElement_;}
    inline void setSmallElementValue(double value)
    { smallElement_=value;} 


    void setFileName(const char * name);

    const char * getFileName() const;

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

     int readMps(const char *filename, const char *extension ,
        int & numberSets, CoinSet **& sets);

    int readMps();
    int readMps(int & numberSets, CoinSet **& sets);
    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);

    int readGms(const char *filename, const char *extension = "gms",bool convertObjective=false);

     int readGms(const char *filename, const char *extension ,
        int & numberSets, CoinSet **& sets);

    // Not for now int readGms();
    int readGms(int & numberSets, CoinSet **& sets);
    int readGMPL(const char *modelName, const char * dataName=NULL, bool keepNames=false);

    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;

    inline const CoinMpsCardReader * reader() const
    { return cardReader_;}
  
    int readQuadraticMps(const char * filename,
                         int * &columnStart, int * &column, double * &elements,
                         int checkSymmetry);

        int readConicMps(const char * filename,
                        int * &columnStart, int * &column, int * &coneType, int & numberCones);
    inline void setConvertObjective(bool trueFalse)
    { convertObjective_=trueFalse;}
  int copyStringElements(const CoinModel * model);

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


  void passInMessageHandler(CoinMessageHandler * handler);

  void newLanguage(CoinMessages::Language language);

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

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

  inline CoinMessages messages() {return messages_;}
  inline CoinMessages * messagesPointer() {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,
                       CoinFileInput * &input); 
  void addString(int iRow,int iColumn, const char * value);
  void decodeString(int iString, int & iRow, int & iColumn, const char * & value) const;

  
  // 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_;
      double smallElement_;

      CoinMessageHandler * handler_;
      bool defaultHandler_;
      CoinMessages messages_;
      CoinMpsCardReader * cardReader_;
      bool convertObjective_;
      int allowStringElements_;
      int maximumStringElements_;
      int numberStringElements_;
      char ** stringElements_;

};

//#############################################################################
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