CoinLpIO.hpp

Go to the documentation of this file.

/* $Id$ */
// Last edit: 11/5/08
//
// Name:     CoinLpIO.hpp; Support for Lp files
// Author:   Francois Margot
//           Tepper School of Business
//           Carnegie Mellon University, Pittsburgh, PA 15213
//           email: fmargot@andrew.cmu.edu
// Date:     12/28/03
//-----------------------------------------------------------------------------
// Copyright (C) 2003, Francois Margot, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CoinLpIO_H
#define CoinLpIO_H
 
#include <cstdio>
 
#include "CoinPackedMatrix.hpp"
#include "CoinMessage.hpp"
#include "CoinFileIO.hpp"
class CoinSet;
 
const int MAX_OBJECTIVES = 2;
 
typedef int COINColumnIndex;
 
class CoinLpIO {
  friend void CoinLpIOUnitTest(const std::string &lpDir);
 
public:
  CoinLpIO();
 
  void gutsOfDestructor();
 
  void gutsOfCopy(const CoinLpIO &);
 
  CoinLpIO &operator=(const CoinLpIO &rhs);
 
  CoinLpIO(const CoinLpIO &);
 
  ~CoinLpIO();
 
  void freePreviousNames(const int section);
 
  void freeAll();
 
  inline void
  convertBoundToSense(const double lower, const double upper,
    char &sense, double &right, double &range) const;
 
 
  const char *getProblemName() const;
 
  void setProblemName(const char *name);
 
  int getNumCols() const;
 
  int getNumRows() const;
 
  CoinBigIndex getNumElements() const;
 
  const double *getColLower() const;
 
  const double *getColUpper() const;
 
  const double *getRowLower() const;
 
  const double *getRowUpper() const;
  const char *getRowSense() const;
 
  const double *getRightHandSide() const;
 
  const double *getRowRange() const;
 
  const int getNumObjectives() const;
 
  const double *getObjCoefficients() const;
 
  const double *getObjCoefficients(int j) const;
 
  const CoinPackedMatrix *getMatrixByRow() const;
 
  const CoinPackedMatrix *getMatrixByCol() const;
 
  const char *getObjName() const;
 
  const char *getObjName(int j) const;
 
  void getPreviousRowNames(char const *const *prev,
    int *card_prev) const;
 
  void getPreviousColNames(char const *const *prev,
    int *card_prev) const;
 
  char const *const *getRowNames() const;
 
  char const *const *getColNames() 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;
 
  double objectiveOffset(int j) const;
 
  inline void setObjectiveOffset(double value)
  {
    objectiveOffset_[0] = value;
  }
  inline bool wasMaximization() const
  {
    return wasMaximization_;
  }
 
  inline void setObjectiveOffset(double value, int j)
  {
    objectiveOffset_[j] = value;
  }
 
  bool isInteger(int columnNumber) const;
 
  const char *integerColumns() const;
 
  double getInfinity() const;
 
  void setInfinity(const double);
 
  double getEpsilon() const;
 
  void setEpsilon(const double);
 
  int getNumberAcross() const;
 
  void setNumberAcross(const int);
 
  int getDecimals() const;
 
  void setDecimals(const int);
 
  void setLpDataWithoutRowAndColNames(
    const CoinPackedMatrix &m,
    const double *collb, const double *colub,
    const double *obj_coeff,
    const char *integrality,
    const double *rowlb, const double *rowub);
 
  void setLpDataWithoutRowAndColNames(
    const CoinPackedMatrix &m,
    const double *collb, const double *colub,
    const double *obj_coeff[MAX_OBJECTIVES],
    int num_objectives,
    const char *integrality,
    const double *rowlb, const double *rowub);
 
  int is_invalid_name(const char *buff, const bool ranged) const;
 
  int are_invalid_names(char const *const *vnames,
    const int card_vnames,
    const bool check_ranged) const;
 
  void setDefaultRowNames();
 
  void setDefaultColNames();
 
  void setLpDataRowAndColNames(char const *const *const rownames,
    char const *const *const colnames);
 
  int writeLp(const char *filename,
    const double epsilon,
    const int numberAcross,
    const int decimals,
    const bool useRowNames = true);
 
  int writeLp(FILE *fp,
    const double epsilon,
    const int numberAcross,
    const int decimals,
    const bool useRowNames = true);
 
  int writeLp(const char *filename, const bool useRowNames = true);
 
  int writeLp(FILE *fp, const bool useRowNames = true);
 
  void readLp(const char *filename, const double epsilon);
 
  void readLp(const char *filename);
 
  void readLp(FILE *fp, const double epsilon);
 
  void readLp(FILE *fp);
 
  void readLp();
  void print() const;
 
  void loadSOS(int numberSets, const CoinSet *sets);
 
  void loadSOS(int numberSets, const CoinSet **sets);
 
  inline int numberSets() const
  {
    return numberSets_;
  }
 
  inline CoinSet **setInformation() const
  {
    return set_;
  }
 
  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_; }
 
protected:
  char *problemName_;
 
  CoinMessageHandler *handler_;
  bool defaultHandler_;
  CoinMessages messages_;
 
  int numberRows_;
 
  int numberColumns_;
 
  CoinBigIndex numberElements_;
 
  mutable CoinPackedMatrix *matrixByColumn_;
 
  CoinPackedMatrix *matrixByRow_;
 
  double *rowlower_;
 
  double *rowupper_;
 
  double *collower_;
 
  double *colupper_;
 
  mutable double *rhs_;
 
  mutable double *rowrange_;
 
  mutable char *rowsense_;
 
  double *objective_[MAX_OBJECTIVES];
 
  int num_objectives_;
 
  double objectiveOffset_[MAX_OBJECTIVES];
 
  char *integerType_;
 
  CoinSet **set_;
 
  int numberSets_;
 
  char *fileName_;
 
  double infinity_;
 
  double epsilon_;
 
  int numberAcross_;
 
  int decimals_;
 
  char *objName_[MAX_OBJECTIVES];
 
  bool wasMaximization_;
 
  char **previous_names_[2];
 
  int card_previous_names_[2];
 
  char **names_[2];
 
  typedef struct {
    int index, next;
  } CoinHashLink;
 
  int maxHash_[2];
 
  int numberHash_[2];
 
  mutable CoinHashLink *hash_[2];
 
  mutable char inputBuffer_[1028];
  mutable int bufferLength_;
  mutable int bufferPosition_;
  CoinFileInput *input_;
  mutable bool eofFound_;
  int fscanfLpIO(char *buff) const;
  int newCardLpIO() const;
 
  void startHash(char const *const *const names,
    const COINColumnIndex number,
    int section);
 
  void stopHash(int section);
 
  COINColumnIndex findHash(const char *name, int section) const;
 
  void insertHash(const char *thisName, int section);
 
  void out_coeff(FILE *fp, double v, int print_1) const;
 
  int find_obj() const;
 
  int is_subject_to(const char *buff) const;
 
  int first_is_number(const char *buff) const;
 
  int is_comment(const char *buff) const;
 
  void skip_comment(char *buff) const;
 
  int is_free(const char *buff) const;
 
  int is_inf(const char *buff) const;
 
  int is_sense(const char *buff) const;
 
  int is_keyword(const char *buff) const;
 
  int read_monom_obj(double *coeff, char **name, int *cnt,
    char **obj_name, int *num_objectives, int *obj_starts);
 
  int read_monom_row(char *start_str, double *coeff, char **name,
    int cnt_coeff) const;
 
  void realloc_coeff(double **coeff, char ***colNames, int *maxcoeff) const;
 
  void realloc_row(char ***rowNames, CoinBigIndex **start, double **rhs,
    double **rowlow, double **rowup, int *maxrow) const;
 
  void realloc_col(double **collow, double **colup, char **is_int,
    int *maxcol) const;
 
  void read_row(char *buff, double **pcoeff, char ***pcolNames,
    int *cnt_coeff, int *maxcoeff,
    double *rhs, double *rowlow, double *rowup,
    int *cnt_row, double inf) const;
 
  void checkRowNames();
 
  void checkColNames();
};
 
void CoinLpIOUnitTest(const std::string &lpDir);
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/