CoinLpIO.hpp

Go to the documentation of this file.

/* $Id: CoinLpIO.hpp 2088 2019-01-22 09:15:46Z forrest $ */
// 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 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];

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