CoinMpsIO.hpp

Go to the documentation of this file.

/* $Id: CoinMpsIO.hpp 2083 2019-01-06 19:38:09Z unxusr $ */
// 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 void setNumberEntries(int number)
  {
    numberEntries_ = number;
  }
  inline int setType() const
  {
    return setType_;
  }
  inline void setSetType(int type)
  {
    setType_ = type;
  }
  inline const int *which() const
  {
    return which_;
  }
  inline const double *weights() const
  {
    return weights_;
  }
  inline int *modifiableWhich() const
  {
    return which_;
  }
  inline double *modifiableWeights() 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;

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

  int isIntegerOrSemiContinuous(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,
    CoinBigIndex *&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

/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/