CoinLpIO.hpp

Go to the documentation of this file.

/* $Id: CoinLpIO.hpp 1749 2014-10-24 20:00:14Z tkr $ */
// 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"
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;

  int 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 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_;
  
  int 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];

  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(FILE *fp) 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, FILE *fp) const;

  void scan_next(char *buff, FILE *fp) 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(FILE *fp, double *coeff, char **name, int *cnt, 
                     char **obj_name, int *num_objectives, int *obj_starts);

  int read_monom_row(FILE *fp, 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, int **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(FILE *fp, 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