CoinMpsIO.hpp

Go to the documentation of this file.

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