casadi 3.7.2__cp314-none-manylinux2014_x86_64.whl

casadi/include/coin/CoinMpsIO.hpp

@@ -0,0 +1,1142 @@
+/* $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;
+
+/// The following lengths are in decreasing order (for 64 bit etc)
+/// Large enough to contain element index
+/// This is already defined as CoinBigIndex
+/// Large enough to contain column index
+typedef int COINColumnIndex;
+
+/// Large enough to contain row index (or basis)
+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;
+/// Very simple code for reading MPS data
+class CoinMpsCardReader {
+
+public:
+  /**@name Constructor and destructor */
+  //@{
+  /// Constructor expects file to be open
+  /// This one takes gzFile if fp null
+  CoinMpsCardReader(CoinFileInput *input, CoinMpsIO *reader);
+
+  /// Destructor
+  ~CoinMpsCardReader();
+  //@}
+
+  /**@name card stuff */
+  //@{
+  /// Read to next section
+  COINSectionType readToNextSection();
+  /// Gets next field and returns section type e.g. COIN_COLUMN_SECTION
+  COINSectionType nextField();
+  /** Gets next field for .gms file and returns type.
+      -1 - EOF
+      0 - what we expected (and processed so pointer moves past)
+      1 - not what we expected
+      leading blanks always ignored
+      input types 
+      0 - anything - stops on non blank card
+      1 - name (in columnname)
+      2 - value
+      3 - value name pair
+      4 - equation type
+      5 - ;
+  */
+  int nextGmsField(int expectedType);
+  /// Returns current section type
+  inline COINSectionType whichSection() const
+  {
+    return section_;
+  }
+  /// Sets current section type
+  inline void setWhichSection(COINSectionType section)
+  {
+    section_ = section;
+  }
+  /// Sees if free format.
+  inline bool freeFormat() const
+  {
+    return freeFormat_;
+  }
+  /// Sets whether free format.  Mainly for blank RHS etc
+  inline void setFreeFormat(bool yesNo)
+  {
+    freeFormat_ = yesNo;
+  }
+  /// Only for first field on card otherwise BLANK_COLUMN
+  /// e.g. COIN_E_ROW
+  inline COINMpsType mpsType() const
+  {
+    return mpsType_;
+  }
+  /// Reads and cleans card - taking out trailing blanks - return 1 if EOF
+  int cleanCard();
+  /// Returns row name of current field
+  inline const char *rowName() const
+  {
+    return rowName_;
+  }
+  /// Returns column name of current field
+  inline const char *columnName() const
+  {
+    return columnName_;
+  }
+  /// Returns value in current field
+  inline double value() const
+  {
+    return value_;
+  }
+  /// Returns value as string in current field
+  inline const char *valueString() const
+  {
+    return valueString_;
+  }
+  /// Whole card (for printing)
+  inline const char *card() const
+  {
+    return card_;
+  }
+  /// Whole card - so we look at it (not const so nextBlankOr will work for gms reader)
+  inline char *mutableCard()
+  {
+    return card_;
+  }
+  /// set position (again so gms reader will work)
+  inline void setPosition(char *position)
+  {
+    position_ = position;
+  }
+  /// get position (again so gms reader will work)
+  inline char *getPosition() const
+  {
+    return position_;
+  }
+  /// Returns card number
+  inline CoinBigIndex cardNumber() const
+  {
+    return cardNumber_;
+  }
+  /// Returns file input
+  inline CoinFileInput *fileInput() const
+  {
+    return input_;
+  }
+  /// Sets whether strings allowed
+  inline void setStringsAllowed()
+  {
+    stringsAllowed_ = true;
+  }
+  //@}
+
+  ////////////////// data //////////////////
+protected:
+  /**@name data */
+  //@{
+  /// Current value
+  double value_;
+  /// Current card image
+  char card_[MAX_CARD_LENGTH];
+  /// Current position within card image
+  char *position_;
+  /// End of card
+  char *eol_;
+  /// Current COINMpsType
+  COINMpsType mpsType_;
+  /// Current row name
+  char rowName_[COIN_MAX_FIELD_LENGTH];
+  /// Current column name
+  char columnName_[COIN_MAX_FIELD_LENGTH];
+  /// File input
+  CoinFileInput *input_;
+  /// Which section we think we are in
+  COINSectionType section_;
+  /// Card number
+  CoinBigIndex cardNumber_;
+  /// Whether free format.  Just for blank RHS etc
+  bool freeFormat_;
+  /// Whether IEEE - 0 no, 1 INTEL, 2 not INTEL
+  int ieeeFormat_;
+  /// If all names <= 8 characters then allow embedded blanks
+  bool eightChar_;
+  /// MpsIO
+  CoinMpsIO *reader_;
+  /// Message handler
+  CoinMessageHandler *handler_;
+  /// Messages
+  CoinMessages messages_;
+  /// Current element as characters (only if strings allowed)
+  char valueString_[COIN_MAX_FIELD_LENGTH];
+  /// Whether strings allowed
+  bool stringsAllowed_;
+  //@}
+public:
+  /**@name methods */
+  //@{
+  /// type - 0 normal, 1 INTEL IEEE, 2 other IEEE
+  double osi_strtod(char *ptr, char **output, int type);
+  /// remove blanks
+  static void strcpyAndCompress(char *to, const char *from);
+  ///
+  static char *nextBlankOr(char *image);
+  /// For strings
+  double osi_strtod(char *ptr, char **output);
+  //@}
+};
+
+//#############################################################################
+#ifdef USE_SBB
+class SbbObject;
+class SbbModel;
+#endif
+/// Very simple class for containing data on set
+class CoinSet {
+
+public:
+  /**@name Constructor and destructor */
+  //@{
+  /// Default constructor
+  CoinSet();
+  /// Constructor
+  CoinSet(int numberEntries, const int *which);
+
+  /// Copy constructor
+  CoinSet(const CoinSet &);
+
+  /// Assignment operator
+  CoinSet &operator=(const CoinSet &rhs);
+
+  /// Destructor
+  virtual ~CoinSet();
+  //@}
+
+  /**@name gets */
+  //@{
+  /// Returns number of entries
+  inline int numberEntries() const
+  {
+    return numberEntries_;
+  }
+  /// Sets number of entries
+  inline void setNumberEntries(int number)
+  {
+    numberEntries_ = number;
+  }
+  /// Returns type of set - 1 =SOS1, 2 =SOS2
+  inline int setType() const
+  {
+    return setType_;
+  }
+  /// Sets type of set - 1 =SOS1, 2 =SOS2
+  inline void setSetType(int type)
+  {
+    setType_ = type;
+  }
+  /// Returns list of variables
+  inline const int *which() const
+  {
+    return which_;
+  }
+  /// Returns weights
+  inline const double *weights() const
+  {
+    return weights_;
+  }
+  /// Returns modifiable list of variables
+  inline int *modifiableWhich() const
+  {
+    return which_;
+  }
+  /// Returns modifiable weights
+  inline double *modifiableWeights() const
+  {
+    return weights_;
+  }
+  //@}
+
+#ifdef USE_SBB
+  /**@name Use in sbb */
+  //@{
+  /// returns an object of type SbbObject
+  virtual SbbObject *sbbObject(SbbModel *model) const
+  {
+    return NULL;
+  }
+  //@}
+#endif
+
+  ////////////////// data //////////////////
+protected:
+  /**@name data */
+  //@{
+  /// Number of entries
+  int numberEntries_;
+  /// type of set
+  int setType_;
+  /// Which variables are in set
+  int *which_;
+  /// Weights
+  double *weights_;
+  //@}
+};
+
+//#############################################################################
+/// Very simple class for containing SOS set
+class CoinSosSet : public CoinSet {
+
+public:
+  /**@name Constructor and destructor */
+  //@{
+  /// Constructor
+  CoinSosSet(int numberEntries, const int *which, const double *weights, int type);
+
+  /// Destructor
+  virtual ~CoinSosSet();
+  //@}
+
+#ifdef USE_SBB
+  /**@name Use in sbb */
+  //@{
+  /// returns an object of type SbbObject
+  virtual SbbObject *sbbObject(SbbModel *model) const;
+  //@}
+#endif
+
+  ////////////////// data //////////////////
+protected:
+  /**@name data */
+  //@{
+  //@}
+};
+
+//#############################################################################
+
+/** MPS IO Interface
+
+    This class can be used to read in mps files without a solver.  After
+    reading the file, the CoinMpsIO object contains all relevant data, which
+    may be more than a particular OsiSolverInterface allows for.  Items may
+    be deleted to allow for flexibility of data storage.
+
+    The implementation makes the CoinMpsIO object look very like a dummy solver,
+    as the same conventions are used.
+*/
+
+class CoinMpsIO {
+  friend void CoinMpsIOUnitTest(const std::string &mpsDir);
+
+public:
+  /** @name Methods to retrieve problem information
+
+   These methods return information about the problem held by the CoinMpsIO
+   object.
+   
+   Querying an object that has no data associated with it result in zeros for
+   the number of rows and columns, and NULL pointers from the methods that
+   return vectors.  Const pointers returned from any data-query method are
+   always valid
+*/
+  //@{
+  /// Get number of columns
+  int getNumCols() const;
+
+  /// Get number of rows
+  int getNumRows() const;
+
+  /// Get number of nonzero elements
+  CoinBigIndex getNumElements() const;
+
+  /// Get pointer to array[getNumCols()] of column lower bounds
+  const double *getColLower() const;
+
+  /// Get pointer to array[getNumCols()] of column upper bounds
+  const double *getColUpper() const;
+
+  /** Get pointer to array[getNumRows()] of constraint senses.
+	<ul>
+	<li>'L': <= constraint
+	<li>'E': =  constraint
+	<li>'G': >= constraint
+	<li>'R': ranged constraint
+	<li>'N': free constraint
+	</ul>
+    */
+  const char *getRowSense() const;
+
+  /** Get pointer to array[getNumRows()] of constraint right-hand sides.
+
+	Given constraints with upper (rowupper) and/or lower (rowlower) bounds,
+	the constraint right-hand side (rhs) is set as
+	<ul>
+	  <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i]
+	  <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i]
+	  <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i]
+	  <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0
+	</ul>
+    */
+  const double *getRightHandSide() const;
+
+  /** Get pointer to array[getNumRows()] of row ranges.
+
+	Given constraints with upper (rowupper) and/or lower (rowlower) bounds, 
+	the constraint range (rowrange) is set as
+	<ul>
+          <li> if rowsense()[i] == 'R' then
+                  rowrange()[i] == rowupper()[i] - rowlower()[i]
+          <li> if rowsense()[i] != 'R' then
+                  rowrange()[i] is 0.0
+        </ul>
+	Put another way, only range constraints have a nontrivial value for
+	rowrange.
+    */
+  const double *getRowRange() const;
+
+  /// Get pointer to array[getNumRows()] of row lower bounds
+  const double *getRowLower() const;
+
+  /// Get pointer to array[getNumRows()] of row upper bounds
+  const double *getRowUpper() const;
+
+  /// Get pointer to array[getNumCols()] of objective function coefficients
+  const double *getObjCoefficients() const;
+
+  /// Get pointer to row-wise copy of the coefficient matrix
+  const CoinPackedMatrix *getMatrixByRow() const;
+
+  /// Get pointer to column-wise copy of the coefficient matrix
+  const CoinPackedMatrix *getMatrixByCol() const;
+
+  /// Return true if column is a continuous variable
+  bool isContinuous(int colNumber) const;
+
+  /** Return true if a column is an integer variable
+
+        Note: This function returns true if the the column
+        is a binary or general integer variable.
+    */
+  bool isInteger(int columnNumber) const;
+
+  /** Return 1 if a column is an integer variable, 2 if semi-continuous
+
+        Note: This function returns 1 if the the column
+        is a binary or general integer variable.
+    */
+  int isIntegerOrSemiContinuous(int columnNumber) const;
+
+  /** Returns array[getNumCols()] specifying if a variable is integer.
+
+	At present, simply coded as zero (continuous) and non-zero (integer)
+	May be extended at a later date.
+    */
+  const char *integerColumns() const;
+
+  /** Returns the row name for the specified index.
+
+	Returns 0 if the index is out of range.
+    */
+  const char *rowName(int index) const;
+
+  /** Returns the column name for the specified index.
+
+	Returns 0 if the index is out of range.
+    */
+  const char *columnName(int index) const;
+
+  /** Returns the index for the specified row name
+  
+	Returns -1 if the name is not found.
+        Returns numberRows for the objective row and > numberRows for
+	dropped free rows.
+    */
+  int rowIndex(const char *name) const;
+
+  /** Returns the index for the specified column name
+  
+	Returns -1 if the name is not found.
+    */
+  int columnIndex(const char *name) const;
+
+  /** Returns the (constant) objective offset
+    
+	This is the RHS entry for the objective row
+    */
+  double objectiveOffset() const;
+  /// Set objective offset
+  inline void setObjectiveOffset(double value)
+  {
+    objectiveOffset_ = value;
+  }
+
+  /// Return the problem name
+  const char *getProblemName() const;
+
+  /// Return the objective name
+  const char *getObjectiveName() const;
+
+  /// Return the RHS vector name
+  const char *getRhsName() const;
+
+  /// Return the range vector name
+  const char *getRangeName() const;
+
+  /// Return the bound vector name
+  const char *getBoundName() const;
+  /// Number of string elements
+  inline int numberStringElements() const
+  {
+    return numberStringElements_;
+  }
+  /// String element
+  inline const char *stringElement(int i) const
+  {
+    return stringElements_[i];
+  }
+  //@}
+
+  /** @name Methods to set problem information
+
+    Methods to load a problem into the CoinMpsIO object.
+*/
+  //@{
+
+  /// Set the problem data
+  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);
+
+  /** Pass in an array[getNumCols()] specifying if a variable is integer.
+
+	At present, simply coded as zero (continuous) and non-zero (integer)
+	May be extended at a later date.
+    */
+  void copyInIntegerInformation(const char *integerInformation);
+
+  /// Set problem name
+  void setProblemName(const char *name);
+
+  /// Set objective name
+  void setObjectiveName(const char *name);
+
+  //@}
+
+  /** @name Parameter set/get methods
+
+  Methods to set and retrieve MPS IO parameters.
+*/
+
+  //@{
+  /// Set infinity
+  void setInfinity(double value);
+
+  /// Get infinity
+  double getInfinity() const;
+
+  /// Set default upper bound for integer variables
+  void setDefaultBound(int value);
+
+  /// Get default upper bound for integer variables
+  int getDefaultBound() const;
+  /// Whether to allow string elements
+  inline int allowStringElements() const
+  {
+    return allowStringElements_;
+  }
+  /// Whether to allow string elements (0 no, 1 yes, 2 yes and try flip)
+  inline void setAllowStringElements(int yesNo)
+  {
+    allowStringElements_ = yesNo;
+  }
+  /** Small element value - elements less than this set to zero on input
+        default is 1.0e-14 */
+  inline double getSmallElementValue() const
+  {
+    return smallElement_;
+  }
+  inline void setSmallElementValue(double value)
+  {
+    smallElement_ = value;
+  }
+  //@}
+
+  /** @name Methods for problem input and output
+
+  Methods to read and write MPS format problem files.
+   
+  The read and write methods return the number of errors that occurred during
+  the IO operation, or -1 if no file is opened.
+
+  \note
+  If the CoinMpsIO class was compiled with support for libz then
+  readMps will automatically try to append .gz to the file name and open it as
+  a compressed file if the specified file name cannot be opened.
+  (Automatic append of the .bz2 suffix when libbz is used is on the TODO list.)
+
+  \todo
+  Allow for file pointers and positioning
+*/
+
+  //@{
+  /// Set the current file name for the CoinMpsIO object
+  void setFileName(const char *name);
+
+  /// Get the current file name for the CoinMpsIO object
+  const char *getFileName() const;
+
+  /** Read a problem in MPS format from the given filename.
+
+      Use "stdin" or "-" to read from stdin.
+    */
+  int readMps(const char *filename, const char *extension = "mps");
+
+  /** Read a problem in MPS format from the given filename.
+
+      Use "stdin" or "-" to read from stdin.
+      But do sets as well
+    */
+  int readMps(const char *filename, const char *extension,
+    int &numberSets, CoinSet **&sets);
+
+  /** Read a problem in MPS format from a previously opened file
+
+      More precisely, read a problem using a CoinMpsCardReader object already
+      associated with this CoinMpsIO object.
+
+      \todo
+      Provide an interface that will allow a client to associate a
+      CoinMpsCardReader object with a CoinMpsIO object by setting the
+      cardReader_ field.
+    */
+  int readMps();
+  /// and
+  int readMps(int &numberSets, CoinSet **&sets);
+  /** Read a basis in MPS format from the given filename.
+	If VALUES on NAME card and solution not NULL fills in solution
+	status values as for CoinWarmStartBasis (but one per char)
+	-1 file error, 0 normal, 1 has solution values
+
+      Use "stdin" or "-" to read from stdin.
+
+      If sizes of names incorrect - read without names
+    */
+  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);
+
+  /** Read a problem in GAMS format from the given filename.
+
+      Use "stdin" or "-" to read from stdin.
+      if convertObjective then massages objective column
+    */
+  int readGms(const char *filename, const char *extension = "gms", bool convertObjective = false);
+
+  /** Read a problem in GAMS format from the given filename.
+
+      Use "stdin" or "-" to read from stdin.
+      But do sets as well
+    */
+  int readGms(const char *filename, const char *extension,
+    int &numberSets, CoinSet **&sets);
+
+  /** Read a problem in GAMS format from a previously opened file
+
+      More precisely, read a problem using a CoinMpsCardReader object already
+      associated with this CoinMpsIO object.
+
+    */
+  // Not for now int readGms();
+  /// and
+  int readGms(int &numberSets, CoinSet **&sets);
+  /** Read a problem in GMPL (subset of AMPL)  format from the given filenames.
+    */
+  int readGMPL(const char *modelName, const char *dataName = NULL, bool keepNames = false);
+
+  /** Write the problem in MPS format to a file with the given filename.
+
+	\param compression can be set to three values to indicate what kind
+	of file should be written
+	<ul>
+	  <li> 0: plain text (default)
+	  <li> 1: gzip compressed (.gz is appended to \c filename)
+	  <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO)
+	</ul>
+	If the library was not compiled with the requested compression then
+	writeMps falls back to writing a plain text file.
+
+	\param formatType specifies the precision to used for values in the
+	MPS file
+	<ul>
+	  <li> 0: normal precision (default)
+	  <li> 1: extra accuracy
+	  <li> 2: IEEE hex
+	</ul>
+
+	\param numberAcross specifies whether 1 or 2 (default) values should be
+	specified on every data line in the MPS file.
+
+	\param quadratic specifies quadratic objective to be output
+    */
+  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;
+
+  /// Return card reader object so can see what last card was e.g. QUADOBJ
+  inline const CoinMpsCardReader *reader() const
+  {
+    return cardReader_;
+  }
+
+  /** Read in a quadratic objective from the given filename.
+
+      If filename is NULL (or the same as the currently open file) then
+      reading continues from the current file.
+      If not, the file is closed and the specified file is opened.
+      
+      Code should be added to
+      general MPS reader to read this if QSECTION
+      Data is assumed to be Q and objective is c + 1/2 xT Q x
+      No assumption is made for symmetry, positive definite, etc.
+      No check is made for duplicates or non-triangular if checkSymmetry==0.
+      If 1 checks lower triangular (so off diagonal should be 2*Q)
+      if 2 makes lower triangular and assumes full Q (but adds off diagonals)
+      
+      Arrays should be deleted by delete []
+
+      Returns number of errors:
+      <ul>
+	<li> -1: bad file
+	<li> -2: no Quadratic section
+	<li> -3: an empty section
+        <li> +n: then matching errors etc (symmetry forced)
+        <li> -4: no matching errors but fails triangular test
+		 (triangularity forced)
+      </ul>
+      columnStart is numberColumns+1 long, others numberNonZeros
+    */
+  int readQuadraticMps(const char *filename,
+    CoinBigIndex *&columnStart, int *&column, double *&elements,
+    int checkSymmetry);
+
+  /** Read in a list of cones from the given filename.  
+
+      If filename is NULL (or the same as the currently open file) then
+      reading continues from the current file.
+      If not, the file is closed and the specified file is opened.
+
+      Code should be added to
+      general MPS reader to read this if CSECTION
+      No checking is done that in unique cone
+
+      Arrays should be deleted by delete []
+
+      Returns number of errors, -1 bad file, -2 no conic section,
+      -3 empty section
+
+      columnStart is numberCones+1 long, other number of columns in matrix
+
+	  coneType is 1 for QUAD, 2 for RQUAD (numberCones long)
+*/
+  int readConicMps(const char *filename,
+    int *&columnStart, int *&column, int *&coneType, int &numberCones);
+  /// Set whether to move objective from matrix
+  inline void setConvertObjective(bool trueFalse)
+  {
+    convertObjective_ = trueFalse;
+  }
+  /// copies in strings from a CoinModel - returns number
+  int copyStringElements(const CoinModel *model);
+  //@}
+
+  /** @name Constructors and destructors */
+  //@{
+  /// Default Constructor
+  CoinMpsIO();
+
+  /// Copy constructor
+  CoinMpsIO(const CoinMpsIO &);
+
+  /// Assignment operator
+  CoinMpsIO &operator=(const CoinMpsIO &rhs);
+
+  /// Destructor
+  ~CoinMpsIO();
+  //@}
+
+  /**@name Message handling */
+  //@{
+  /** Pass in Message handler
+  
+      Supply a custom message handler. It will not be destroyed when the
+      CoinMpsIO object is destroyed.
+  */
+  void passInMessageHandler(CoinMessageHandler *handler);
+
+  /// Set the language for messages.
+  void newLanguage(CoinMessages::Language language);
+
+  /// Set the language for messages.
+  inline void setLanguage(CoinMessages::Language language) { newLanguage(language); }
+
+  /// Return the message handler
+  inline CoinMessageHandler *messageHandler() const { return handler_; }
+
+  /// Return the messages
+  inline CoinMessages messages() { return messages_; }
+  /// Return the messages pointer
+  inline CoinMessages *messagesPointer() { return &messages_; }
+  //@}
+
+  /**@name Methods to release storage
+
+  These methods allow the client to reduce the storage used by the CoinMpsIO
+  object be selectively releasing unneeded problem information.
+*/
+  //@{
+  /** Release all information which can be re-calculated.
+    
+	E.g., row sense, copies of rows, hash tables for names.
+    */
+  void releaseRedundantInformation();
+
+  /// Release all row information (lower, upper)
+  void releaseRowInformation();
+
+  /// Release all column information (lower, upper, objective)
+  void releaseColumnInformation();
+
+  /// Release integer information
+  void releaseIntegerInformation();
+
+  /// Release row names
+  void releaseRowNames();
+
+  /// Release column names
+  void releaseColumnNames();
+
+  /// Release matrix information
+  void releaseMatrixInformation();
+  //@}
+
+protected:
+  /**@name Miscellaneous helper functions */
+  //@{
+
+  /// Utility method used several times to implement public methods
+  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);
+
+  /// Does the heavy lifting for destruct and assignment.
+  void gutsOfDestructor();
+
+  /// Does the heavy lifting for copy and assignment.
+  void gutsOfCopy(const CoinMpsIO &);
+
+  /// Clears problem data from the CoinMpsIO object.
+  void freeAll();
+
+  /** A quick inlined function to convert from lb/ub style constraint
+	definition to sense/rhs/range style */
+  inline void
+  convertBoundToSense(const double lower, const double upper,
+    char &sense, double &right, double &range) const;
+  /** A quick inlined function to convert from sense/rhs/range stryle
+	constraint definition to lb/ub style */
+  inline void
+  convertSenseToBound(const char sense, const double right,
+    const double range,
+    double &lower, double &upper) const;
+
+  /** Deal with a filename
+  
+    As the name says.
+    Returns +1 if the file name is new, 0 if it's the same as before
+    (i.e., matches fileName_), and -1 if there's an error and the file
+    can't be opened.
+    Handles automatic append of .gz suffix when compiled with libz.
+
+    \todo
+    Add automatic append of .bz2 suffix when compiled with libbz.
+  */
+
+  int dealWithFileName(const char *filename, const char *extension,
+    CoinFileInput *&input);
+  /** Add string to list
+      iRow==numberRows is objective, nr+1 is lo, nr+2 is up
+      iColumn==nc is rhs (can't cope with ranges at present)
+  */
+  void addString(int iRow, int iColumn, const char *value);
+  /// Decode string
+  void decodeString(int iString, int &iRow, int &iColumn, const char *&value) const;
+  //@}
+
+  // for hashing
+  typedef struct {
+    int index, next;
+  } CoinHashLink;
+
+  /**@name Hash table methods */
+  //@{
+  /// Creates hash list for names (section = 0 for rows, 1 columns)
+  void startHash(char **names, const int number, int section);
+  /// This one does it when names are already in
+  void startHash(int section) const;
+  /// Deletes hash storage
+  void stopHash(int section);
+  /// Finds match using hash,  -1 not found
+  int findHash(const char *name, int section) const;
+  //@}
+
+  /**@name Cached problem information */
+  //@{
+  /// Problem name
+  char *problemName_;
+
+  /// Objective row name
+  char *objectiveName_;
+
+  /// Right-hand side vector name
+  char *rhsName_;
+
+  /// Range vector name
+  char *rangeName_;
+
+  /// Bounds vector name
+  char *boundName_;
+
+  /// Number of rows
+  int numberRows_;
+
+  /// Number of columns
+  int numberColumns_;
+
+  /// Number of coefficients
+  CoinBigIndex numberElements_;
+
+  /// Pointer to dense vector of row sense indicators
+  mutable char *rowsense_;
+
+  /// Pointer to dense vector of row right-hand side values
+  mutable double *rhs_;
+
+  /** Pointer to dense vector of slack variable upper bounds for range 
+          constraints (undefined for non-range rows)
+      */
+  mutable double *rowrange_;
+
+  /// Pointer to row-wise copy of problem matrix coefficients.
+  mutable CoinPackedMatrix *matrixByRow_;
+
+  /// Pointer to column-wise copy of problem matrix coefficients.
+  CoinPackedMatrix *matrixByColumn_;
+
+  /// Pointer to dense vector of row lower bounds
+  double *rowlower_;
+
+  /// Pointer to dense vector of row upper bounds
+  double *rowupper_;
+
+  /// Pointer to dense vector of column lower bounds
+  double *collower_;
+
+  /// Pointer to dense vector of column upper bounds
+  double *colupper_;
+
+  /// Pointer to dense vector of objective coefficients
+  double *objective_;
+
+  /// Constant offset for objective value (i.e., RHS value for OBJ row)
+  double objectiveOffset_;
+
+  /** Pointer to dense vector specifying if a variable is continuous
+	  (0) or integer (1).
+      */
+  char *integerType_;
+
+  /** Row and column names
+	  Linked to hash table sections (0 - row names, 1 column names)
+      */
+  char **names_[2];
+  //@}
+
+  /** @name Hash tables */
+  //@{
+  /// Current file name
+  char *fileName_;
+
+  /// Number of entries in a hash table section
+  int numberHash_[2];
+
+  /// Hash tables (two sections, 0 - row names, 1 - column names)
+  mutable CoinHashLink *hash_[2];
+  //@}
+
+  /** @name CoinMpsIO object parameters */
+  //@{
+  /// Upper bound when no bounds for integers
+  int defaultBound_;
+
+  /// Value to use for infinity
+  double infinity_;
+  /// Small element value
+  double smallElement_;
+
+  /// Message handler
+  CoinMessageHandler *handler_;
+  /** Flag to say if the message handler is the default handler.
+
+          If true, the handler will be destroyed when the CoinMpsIO
+	  object is destroyed; if false, it will not be destroyed.
+      */
+  bool defaultHandler_;
+  /// Messages
+  CoinMessages messages_;
+  /// Card reader
+  CoinMpsCardReader *cardReader_;
+  /// If .gms file should it be massaged to move objective
+  bool convertObjective_;
+  /// Whether to allow string elements
+  int allowStringElements_;
+  /// Maximum number of string elements
+  int maximumStringElements_;
+  /// Number of string elements
+  int numberStringElements_;
+  /// String elements
+  char **stringElements_;
+  //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CoinMpsIO class. The
+    only reason for it not to be a member method is that this way it doesn't
+    have to be compiled into the library. And that's a gain, because the
+    library should be compiled with optimization on, but this method should be
+    compiled with debugging. Also, if this method is compiled with
+    optimization, the compilation takes 10-15 minutes and the machine pages
+    (has 256M core memory!)... */
+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
+*/