Added linux shared libraries and header files for int and ecos functions

1 files changed, 1054 insertions, 0 deletions

diff --git a/thirdparty/linux/include/coin1/CoinModel.hpp b/thirdparty/linux/include/coin1/CoinModel.hpp
new file mode 100644
index 0000000..6d1ff5b
--- /dev/null
+++ b/thirdparty/linux/include/coin1/CoinModel.hpp
@@ -0,0 +1,1054 @@
+/* $Id: CoinModel.hpp 1691 2014-03-19 12:43:56Z forrest $ */
+// Copyright (C) 2005, International Business Machines
+// Corporation and others.  All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CoinModel_H
+#define CoinModel_H
+
+#include "CoinModelUseful.hpp"
+#include "CoinMessageHandler.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CoinFinite.hpp"
+class CoinBaseModel {
+
+public:
+
+
+  /**@name Constructors, destructor */
+   //@{
+  /// Default Constructor 
+  CoinBaseModel ();
+
+  /// Copy constructor 
+  CoinBaseModel ( const CoinBaseModel &rhs);
+   
+  /// Assignment operator 
+  CoinBaseModel & operator=( const CoinBaseModel& rhs);
+
+  /// Clone
+  virtual CoinBaseModel * clone() const=0;
+
+  /// Destructor 
+  virtual ~CoinBaseModel () ;
+   //@}
+
+  /**@name For getting information */
+   //@{
+   /// Return number of rows
+  inline int numberRows() const
+  { return numberRows_;}
+   /// Return number of columns
+  inline int numberColumns() const
+  { return numberColumns_;}
+   /// Return number of elements
+  virtual CoinBigIndex numberElements() const = 0;
+  /** Returns the (constant) objective offset
+      This is the RHS entry for the objective row
+  */
+  inline double objectiveOffset() const
+  { return objectiveOffset_;}
+  /// Set objective offset
+  inline void setObjectiveOffset(double value)
+  { objectiveOffset_=value;}
+  /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline double optimizationDirection() const {
+    return  optimizationDirection_;
+  }
+  /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline void setOptimizationDirection(double value)
+  { optimizationDirection_=value;}
+  /// Get print level 0 - off, 1 - errors, 2 - more
+  inline int logLevel() const
+  { return logLevel_;}
+  /// Set print level 0 - off, 1 - errors, 2 - more
+  void setLogLevel(int value);
+  /// Return the problem name
+  inline const char * getProblemName() const
+  { return problemName_.c_str();}
+  /// Set problem name
+  void setProblemName(const char *name) ;
+  /// Set problem name
+  void setProblemName(const std::string &name) ;
+  /// Return the row block name
+  inline const std::string & getRowBlock() const
+  { return rowBlockName_;}
+  /// Set row block name
+  inline void setRowBlock(const std::string &name) 
+  { rowBlockName_ = name;}
+  /// Return the column block name
+  inline const std::string & getColumnBlock() const
+  { return columnBlockName_;}
+  /// Set column block name
+  inline void setColumnBlock(const std::string &name) 
+  { columnBlockName_ = name;}
+  /// Pass in message handler
+  void setMessageHandler(CoinMessageHandler * handler);
+   //@}
+  
+protected:
+  /**@name Data members */
+   //@{
+  /// Current number of rows
+  int numberRows_;
+  /// Current number of columns
+  int numberColumns_;
+  /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  double optimizationDirection_;
+  /// Objective offset to be passed on
+  double objectiveOffset_;
+  /// Problem name
+  std::string problemName_;
+  /// Rowblock name
+  std::string rowBlockName_;
+  /// Columnblock name
+  std::string columnBlockName_;
+  /// Message handler (Passed in)
+  CoinMessageHandler * handler_;
+  /// Messages 
+  CoinMessages messages_;
+  
+  /** Print level.
+      I could have gone for full message handling but this should normally
+      be silent and lightweight.
+      -1 - use passed in message handler
+      0 - no output
+      1 - on errors
+      2 - more detailed
+  */
+  int logLevel_;
+   //@}
+  /// data
+
+};
+
+/** 
+    This is a simple minded model which is stored in a format which makes
+    it easier to construct and modify but not efficient for algorithms.  It has
+    to be passed across to ClpModel or OsiSolverInterface by addRows, addCol(umn)s
+    or loadProblem.
+
+    It may have up to four parts -
+    1) A matrix of doubles (or strings - see note A)
+    2) Column information including integer information and names
+    3) Row information including names
+    4) Quadratic objective (not implemented - but see A)
+
+    This class is meant to make it more efficient to build a model.  It is at
+    its most efficient when all additions are done as addRow or as addCol but
+    not mixed.  If only 1 and 2 exist then solver.addColumns may be used to pass to solver,
+    if only 1 and 3 exist then solver.addRows may be used.  Otherwise solver.loadProblem
+    must be used.
+
+    If addRows and addColumns are mixed or if individual elements are set then the
+    speed will drop to some extent and more memory will be used.
+
+    It is also possible to iterate over existing elements and to access columns and rows
+    by name.  Again each of these use memory and cpu time.  However memory is unlikely
+    to be critical as most algorithms will use much more.
+
+    Notes:
+    A)  Although this could be used to pass nonlinear information around the
+        only use at present is to have named values e.g. value1 which can then be
+        set to a value after model is created.  I have no idea whether that could
+        be useful but I thought it might be fun.
+	Quadratic terms are allowed in strings!  A solver could try and use this
+	if so - the convention is that 0.5* quadratic is stored
+	
+    B)  This class could be useful for modeling.
+*/
+
+class CoinModel : public CoinBaseModel {
+  
+public:
+  /**@name Useful methods for building model */
+   //@{
+   /** add a row -  numberInRow may be zero */
+   void addRow(int numberInRow, const int * columns,
+	       const double * elements, double rowLower=-COIN_DBL_MAX, 
+              double rowUpper=COIN_DBL_MAX, const char * name=NULL);
+  /// add a column - numberInColumn may be zero */
+   void addColumn(int numberInColumn, const int * rows,
+                  const double * elements, 
+                  double columnLower=0.0, 
+                  double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0,
+                  const char * name=NULL, bool isInteger=false);
+  /// add a column - numberInColumn may be zero */
+  inline void addCol(int numberInColumn, const int * rows,
+                     const double * elements, 
+                     double columnLower=0.0, 
+                     double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0,
+                     const char * name=NULL, bool isInteger=false)
+  { addColumn(numberInColumn, rows, elements, columnLower, columnUpper, objectiveValue,
+              name,isInteger);}
+  /// Sets value for row i and column j 
+  inline void operator() (int i,int j,double value) 
+  { setElement(i,j,value);}
+  /// Sets value for row i and column j 
+  void setElement(int i,int j,double value) ;
+  /** Gets sorted row - user must provide enough space 
+      (easiest is allocate number of columns).
+      If column or element NULL then just returns number
+      Returns number of elements
+  */
+  int getRow(int whichRow, int * column, double * element);
+  /** Gets sorted column - user must provide enough space 
+      (easiest is allocate number of rows).
+      If row or element NULL then just returns number
+      Returns number of elements
+  */
+  int getColumn(int whichColumn, int * column, double * element);
+  /// Sets quadratic value for column i and j 
+  void setQuadraticElement(int i,int j,double value) ;
+  /// Sets value for row i and column j as string
+  inline void operator() (int i,int j,const char * value) 
+  { setElement(i,j,value);}
+  /// Sets value for row i and column j as string
+  void setElement(int i,int j,const char * value) ;
+  /// Associates a string with a value.  Returns string id (or -1 if does not exist)
+  int associateElement(const char * stringValue, double value);
+  /** Sets rowLower (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowLower(int whichRow,double rowLower); 
+  /** Sets rowUpper (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowUpper(int whichRow,double rowUpper); 
+  /** Sets rowLower and rowUpper (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowBounds(int whichRow,double rowLower,double rowUpper); 
+  /** Sets name (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowName(int whichRow,const char * rowName); 
+  /** Sets columnLower (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnLower(int whichColumn,double columnLower); 
+  /** Sets columnUpper (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnUpper(int whichColumn,double columnUpper); 
+  /** Sets columnLower and columnUpper (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnBounds(int whichColumn,double columnLower,double columnUpper); 
+  /** Sets columnObjective (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnObjective(int whichColumn,double columnObjective); 
+  /** Sets name (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnName(int whichColumn,const char * columnName); 
+  /** Sets integer state (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnIsInteger(int whichColumn,bool columnIsInteger); 
+  /** Sets columnObjective (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setObjective(int whichColumn,double columnObjective) 
+  { setColumnObjective( whichColumn, columnObjective);} 
+  /** Sets integer state (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setIsInteger(int whichColumn,bool columnIsInteger) 
+  { setColumnIsInteger( whichColumn, columnIsInteger);} 
+  /** Sets integer (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setInteger(int whichColumn) 
+  { setColumnIsInteger( whichColumn, true);} 
+  /** Sets continuous (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setContinuous(int whichColumn) 
+  { setColumnIsInteger( whichColumn, false);} 
+  /** Sets columnLower (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColLower(int whichColumn,double columnLower) 
+  { setColumnLower( whichColumn, columnLower);} 
+  /** Sets columnUpper (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColUpper(int whichColumn,double columnUpper) 
+  { setColumnUpper( whichColumn, columnUpper);} 
+  /** Sets columnLower and columnUpper (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColBounds(int whichColumn,double columnLower,double columnUpper) 
+  { setColumnBounds( whichColumn, columnLower, columnUpper);} 
+  /** Sets columnObjective (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColObjective(int whichColumn,double columnObjective) 
+  { setColumnObjective( whichColumn, columnObjective);} 
+  /** Sets name (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColName(int whichColumn,const char * columnName) 
+  { setColumnName( whichColumn, columnName);} 
+  /** Sets integer (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setColIsInteger(int whichColumn,bool columnIsInteger) 
+  { setColumnIsInteger( whichColumn, columnIsInteger);} 
+  /** Sets rowLower (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowLower(int whichRow,const char * rowLower); 
+  /** Sets rowUpper (if row does not exist then
+      all rows up to this are defined with default values and no elements)
+  */
+  void setRowUpper(int whichRow,const char * rowUpper); 
+  /** Sets columnLower (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnLower(int whichColumn,const char * columnLower); 
+  /** Sets columnUpper (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnUpper(int whichColumn,const char * columnUpper); 
+  /** Sets columnObjective (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnObjective(int whichColumn,const char * columnObjective); 
+  /** Sets integer (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  void setColumnIsInteger(int whichColumn,const char * columnIsInteger); 
+  /** Sets columnObjective (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setObjective(int whichColumn,const char * columnObjective) 
+  { setColumnObjective( whichColumn, columnObjective);} 
+  /** Sets integer (if column does not exist then
+      all columns up to this are defined with default values and no elements)
+  */
+  inline void setIsInteger(int whichColumn,const char * columnIsInteger) 
+  { setColumnIsInteger( whichColumn, columnIsInteger);} 
+  /** Deletes all entries in row and bounds.  Will be ignored by
+      writeMps etc and will be packed down if asked for. */
+  void deleteRow(int whichRow);
+  /** Deletes all entries in column and bounds and objective.  Will be ignored by
+      writeMps etc and will be packed down if asked for. */
+  void deleteColumn(int whichColumn);
+  /** Deletes all entries in column and bounds.  If last column the number of columns
+      will be decremented and true returned.  */
+  inline void deleteCol(int whichColumn)
+  { deleteColumn(whichColumn);}
+  /// Takes element out of matrix - returning position (<0 if not there);
+  int deleteElement(int row, int column);
+  /// Takes element out of matrix when position known
+  void deleteThisElement(int row, int column,int position);
+  /** Packs down all rows i.e. removes empty rows permanently.  Empty rows
+      have no elements and feasible bounds. returns number of rows deleted. */
+  int packRows();
+  /** Packs down all columns i.e. removes empty columns permanently.  Empty columns
+      have no elements and no objective. returns number of columns deleted. */
+  int packColumns();
+  /** Packs down all columns i.e. removes empty columns permanently.  Empty columns
+      have no elements and no objective. returns number of columns deleted. */
+  inline int packCols()
+  { return packColumns();}
+  /** Packs down all rows and columns.  i.e. removes empty rows and columns permanently.
+      Empty rows have no elements and feasible bounds.
+      Empty columns have no elements and no objective.
+      returns number of rows+columns deleted. */
+  int pack();
+
+  /** Sets columnObjective array
+  */
+  void setObjective(int numberColumns,const double * objective) ;
+  /** Sets columnLower array
+  */
+  void setColumnLower(int numberColumns,const double * columnLower);
+  /** Sets columnLower array
+  */
+  inline void setColLower(int numberColumns,const double * columnLower)
+  { setColumnLower( numberColumns, columnLower);} 
+  /** Sets columnUpper array
+  */
+  void setColumnUpper(int numberColumns,const double * columnUpper);
+  /** Sets columnUpper array
+  */
+  inline void setColUpper(int numberColumns,const double * columnUpper)
+  { setColumnUpper( numberColumns, columnUpper);} 
+  /** Sets rowLower array
+  */
+  void setRowLower(int numberRows,const double * rowLower);
+  /** Sets rowUpper array
+  */
+  void setRowUpper(int numberRows,const double * rowUpper);
+
+  /** 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.
+  
+  not const as may change model e.g. fill in default bounds
+  */
+  int writeMps(const char *filename, int compression = 0,
+               int formatType = 0, int numberAcross = 2, bool keepStrings=false) ;
+  
+  /** Check two models against each other.  Return nonzero if different.
+      Ignore names if that set.
+      May modify both models by cleaning up
+  */
+  int differentModel(CoinModel & other, bool ignoreNames);
+   //@}
+
+
+  /**@name For structured models */
+   //@{
+  /// Pass in CoinPackedMatrix (and switch off element updates)
+  void passInMatrix(const CoinPackedMatrix & matrix);
+  /** Convert elements to CoinPackedMatrix (and switch off element updates).
+      Returns number of errors */
+  int convertMatrix();
+  /// Return a pointer to CoinPackedMatrix (or NULL)
+  inline const CoinPackedMatrix * packedMatrix() const
+  { return packedMatrix_;}
+  /// Return pointers to original rows (for decomposition)
+  inline const int * originalRows() const
+  { return rowType_;}
+  /// Return pointers to original columns (for decomposition)
+  inline const int * originalColumns() const
+  { return columnType_;}
+   //@}
+
+
+  /**@name For getting information */
+   //@{
+   /// Return number of elements
+  inline CoinBigIndex numberElements() const
+  { return numberElements_;}
+   /// Return  elements as triples
+  inline const CoinModelTriple * elements() const
+  { return elements_;}
+  /// Returns value for row i and column j
+  inline double operator() (int i,int j) const
+  { return getElement(i,j);}
+  /// Returns value for row i and column j
+  double getElement(int i,int j) const;
+  /// Returns value for row rowName and column columnName
+  inline double operator() (const char * rowName,const char * columnName) const
+  { return getElement(rowName,columnName);}
+  /// Returns value for row rowName and column columnName
+  double getElement(const char * rowName,const char * columnName) const;
+  /// Returns quadratic value for columns i and j
+  double getQuadraticElement(int i,int j) const;
+  /** Returns value for row i and column j as string.
+      Returns NULL if does not exist.
+      Returns "Numeric" if not a string
+  */
+  const char * getElementAsString(int i,int j) const;
+  /** Returns pointer to element for row i column j.
+      Only valid until next modification. 
+      NULL if element does not exist */
+  double * pointer (int i,int j) const;
+  /** Returns position in elements for row i column j.
+      Only valid until next modification. 
+      -1 if element does not exist */
+  int position (int i,int j) const;
+  
+  
+  /** Returns first element in given row - index is -1 if none.
+      Index is given by .index and value by .value
+  */
+  CoinModelLink firstInRow(int whichRow) const ;
+  /** Returns last element in given row - index is -1 if none.
+      Index is given by .index and value by .value
+  */
+  CoinModelLink lastInRow(int whichRow) const ;
+  /** Returns first element in given column - index is -1 if none.
+      Index is given by .index and value by .value
+  */
+  CoinModelLink firstInColumn(int whichColumn) const ;
+  /** Returns last element in given column - index is -1 if none.
+      Index is given by .index and value by .value
+  */
+  CoinModelLink lastInColumn(int whichColumn) const ;
+  /** Returns next element in current row or column - index is -1 if none.
+      Index is given by .index and value by .value.
+      User could also tell because input.next would be NULL
+  */
+  CoinModelLink next(CoinModelLink & current) const ;
+  /** Returns previous element in current row or column - index is -1 if none.
+      Index is given by .index and value by .value.
+      User could also tell because input.previous would be NULL
+      May not be correct if matrix updated.
+  */
+  CoinModelLink previous(CoinModelLink & current) const ;
+  /** Returns first element in given quadratic column - index is -1 if none.
+      Index is given by .index and value by .value
+      May not be correct if matrix updated.
+  */
+  CoinModelLink firstInQuadraticColumn(int whichColumn) const ;
+  /** Returns last element in given quadratic column - index is -1 if none.
+      Index is given by .index and value by .value
+  */
+  CoinModelLink lastInQuadraticColumn(int whichColumn) const ;
+  /** Gets rowLower (if row does not exist then -COIN_DBL_MAX)
+  */
+  double  getRowLower(int whichRow) const ; 
+  /** Gets rowUpper (if row does not exist then +COIN_DBL_MAX)
+  */
+  double  getRowUpper(int whichRow) const ; 
+  /** Gets name (if row does not exist then NULL)
+  */
+  const char * getRowName(int whichRow) const ; 
+  inline double  rowLower(int whichRow) const
+  { return getRowLower(whichRow);}
+  /** Gets rowUpper (if row does not exist then COIN_DBL_MAX)
+  */
+  inline double  rowUpper(int whichRow) const
+  { return getRowUpper(whichRow) ;}
+  /** Gets name (if row does not exist then NULL)
+  */
+  inline const char * rowName(int whichRow) const
+  { return getRowName(whichRow);}
+  /** Gets columnLower (if column does not exist then 0.0)
+  */
+  double  getColumnLower(int whichColumn) const ; 
+  /** Gets columnUpper (if column does not exist then COIN_DBL_MAX)
+  */
+  double  getColumnUpper(int whichColumn) const ; 
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  double  getColumnObjective(int whichColumn) const ; 
+  /** Gets name (if column does not exist then NULL)
+  */
+  const char * getColumnName(int whichColumn) const ; 
+  /** Gets if integer (if column does not exist then false)
+  */
+  bool getColumnIsInteger(int whichColumn) const ; 
+  /** Gets columnLower (if column does not exist then 0.0)
+  */
+  inline double  columnLower(int whichColumn) const
+  { return getColumnLower(whichColumn);}
+  /** Gets columnUpper (if column does not exist then COIN_DBL_MAX)
+  */
+  inline double  columnUpper(int whichColumn) const
+  { return getColumnUpper(whichColumn) ;}
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  inline double  columnObjective(int whichColumn) const
+  { return getColumnObjective(whichColumn);}
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  inline double  objective(int whichColumn) const
+  { return getColumnObjective(whichColumn);}
+  /** Gets name (if column does not exist then NULL)
+  */
+  inline const char * columnName(int whichColumn) const
+  { return getColumnName(whichColumn);}
+  /** Gets if integer (if column does not exist then false)
+  */
+  inline bool columnIsInteger(int whichColumn) const
+  { return getColumnIsInteger(whichColumn);}
+  /** Gets if integer (if column does not exist then false)
+  */
+  inline bool isInteger(int whichColumn) const
+  { return getColumnIsInteger(whichColumn);}
+  /** Gets columnLower (if column does not exist then 0.0)
+  */
+  inline double  getColLower(int whichColumn) const
+  { return getColumnLower(whichColumn);}
+  /** Gets columnUpper (if column does not exist then COIN_DBL_MAX)
+  */
+  inline double  getColUpper(int whichColumn) const
+  { return getColumnUpper(whichColumn) ;}
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  inline double  getColObjective(int whichColumn) const
+  { return getColumnObjective(whichColumn);}
+  /** Gets name (if column does not exist then NULL)
+  */
+  inline const char * getColName(int whichColumn) const
+  { return getColumnName(whichColumn);}
+  /** Gets if integer (if column does not exist then false)
+  */
+  inline bool getColIsInteger(int whichColumn) const
+  { return getColumnIsInteger(whichColumn);}
+  /** Gets rowLower (if row does not exist then -COIN_DBL_MAX)
+  */
+  const char *  getRowLowerAsString(int whichRow) const ; 
+  /** Gets rowUpper (if row does not exist then +COIN_DBL_MAX)
+  */
+  const char *  getRowUpperAsString(int whichRow) const ; 
+  inline const char *  rowLowerAsString(int whichRow) const
+  { return getRowLowerAsString(whichRow);}
+  /** Gets rowUpper (if row does not exist then COIN_DBL_MAX)
+  */
+  inline const char *  rowUpperAsString(int whichRow) const
+  { return getRowUpperAsString(whichRow) ;}
+  /** Gets columnLower (if column does not exist then 0.0)
+  */
+  const char *  getColumnLowerAsString(int whichColumn) const ; 
+  /** Gets columnUpper (if column does not exist then COIN_DBL_MAX)
+  */
+  const char *  getColumnUpperAsString(int whichColumn) const ; 
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  const char *  getColumnObjectiveAsString(int whichColumn) const ; 
+  /** Gets if integer (if column does not exist then false)
+  */
+  const char * getColumnIsIntegerAsString(int whichColumn) const ; 
+  /** Gets columnLower (if column does not exist then 0.0)
+  */
+  inline const char *  columnLowerAsString(int whichColumn) const
+  { return getColumnLowerAsString(whichColumn);}
+  /** Gets columnUpper (if column does not exist then COIN_DBL_MAX)
+  */
+  inline const char *  columnUpperAsString(int whichColumn) const
+  { return getColumnUpperAsString(whichColumn) ;}
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  inline const char *  columnObjectiveAsString(int whichColumn) const
+  { return getColumnObjectiveAsString(whichColumn);}
+  /** Gets columnObjective (if column does not exist then 0.0)
+  */
+  inline const char *  objectiveAsString(int whichColumn) const
+  { return getColumnObjectiveAsString(whichColumn);}
+  /** Gets if integer (if column does not exist then false)
+  */
+  inline const char * columnIsIntegerAsString(int whichColumn) const
+  { return getColumnIsIntegerAsString(whichColumn);}
+  /** Gets if integer (if column does not exist then false)
+  */
+  inline const char * isIntegerAsString(int whichColumn) const
+  { return getColumnIsIntegerAsString(whichColumn);}
+  /// Row index from row name (-1 if no names or no match)
+  int row(const char * rowName) const;
+  /// Column index from column name (-1 if no names or no match)
+  int column(const char * columnName) const;
+  /// Returns type
+  inline int type() const
+  { return type_;}
+  /// returns unset value
+  inline double unsetValue() const
+  { return -1.23456787654321e-97;}
+  /// Creates a packed matrix - return number of errors
+  int createPackedMatrix(CoinPackedMatrix & matrix, 
+			 const double * associated);
+  /** Fills in startPositive and startNegative with counts for +-1 matrix.
+      If not +-1 then startPositive[0]==-1 otherwise counts and
+      startPositive[numberColumns]== size
+      - return number of errors
+  */
+  int countPlusMinusOne(CoinBigIndex * startPositive, CoinBigIndex * startNegative,
+                        const double * associated);
+  /** Creates +-1 matrix given startPositive and startNegative counts for +-1 matrix.
+  */
+  void createPlusMinusOne(CoinBigIndex * startPositive, CoinBigIndex * startNegative,
+                         int * indices,
+                         const double * associated);
+  /// Creates copies of various arrays - return number of errors
+  int createArrays(double * & rowLower, double * &  rowUpper,
+                   double * & columnLower, double * & columnUpper,
+                   double * & objective, int * & integerType,
+                   double * & associated);
+  /// Says if strings exist
+  inline bool stringsExist() const
+  { return string_.numberItems()!=0;}
+  /// Return string array
+  inline const CoinModelHash * stringArray() const
+  { return &string_;}
+  /// Returns associated array
+  inline double * associatedArray() const
+  { return associated_;}
+  /// Return rowLower array
+  inline double * rowLowerArray() const
+  { return rowLower_;}
+  /// Return rowUpper array
+  inline double * rowUpperArray() const
+  { return rowUpper_;}
+  /// Return columnLower array
+  inline double * columnLowerArray() const
+  { return columnLower_;}
+  /// Return columnUpper array
+  inline double * columnUpperArray() const
+  { return columnUpper_;}
+  /// Return objective array
+  inline double * objectiveArray() const
+  { return objective_;}
+  /// Return integerType array
+  inline int * integerTypeArray() const
+  { return integerType_;}
+  /// Return row names array
+  inline const CoinModelHash * rowNames() const
+  { return &rowName_;}
+  /// Return column names array
+  inline const CoinModelHash * columnNames() const
+  { return &columnName_;}
+  /// Reset row names
+  inline void zapRowNames()
+  { rowName_=CoinModelHash();}
+  /// Reset column names
+  inline void zapColumnNames()
+  { columnName_=CoinModelHash();}
+  /// Returns array of 0 or nonzero if can be a cut (or returns NULL)
+  inline const int * cutMarker() const
+  { return cut_;}
+  /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline double optimizationDirection() const {
+    return  optimizationDirection_;
+  }
+  /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+  inline void setOptimizationDirection(double value)
+  { optimizationDirection_=value;}
+  /// Return pointer to more information
+  inline void * moreInfo() const
+  { return moreInfo_;}
+  /// Set pointer to more information
+  inline void setMoreInfo(void * info)
+  { moreInfo_ = info;}
+  /** Returns which parts of model are set
+      1 - matrix
+      2 - rhs
+      4 - row names
+      8 - column bounds and/or objective
+      16 - column names
+      32 - integer types
+  */
+  int whatIsSet() const;
+   //@}
+
+  /**@name for block models - matrix will be CoinPackedMatrix */
+   //@{
+  /*! \brief Load in a problem by copying the arguments. The constraints on
+    the rows are given by lower and upper bounds.
+    
+    If a pointer is 0 then the following values are the default:
+    <ul>
+    <li> <code>colub</code>: all columns have upper bound infinity
+    <li> <code>collb</code>: all columns have lower bound 0 
+    <li> <code>rowub</code>: all rows have upper bound infinity
+    <li> <code>rowlb</code>: all rows have lower bound -infinity
+    <li> <code>obj</code>: all variables have 0 objective coefficient
+    </ul>
+    
+    Note that the default values for rowub and rowlb produce the
+    constraint -infty <= ax <= infty. This is probably not what you want.
+  */
+  void loadBlock (const CoinPackedMatrix& matrix,
+		  const double* collb, const double* colub,   
+		  const double* obj,
+		  const double* rowlb, const double* rowub) ;
+  /*! \brief Load in a problem by copying the arguments.
+    The constraints on the rows are given by sense/rhs/range triplets.
+    
+    If a pointer is 0 then the following values are the default:
+    <ul>
+    <li> <code>colub</code>: all columns have upper bound infinity
+    <li> <code>collb</code>: all columns have lower bound 0 
+    <li> <code>obj</code>: all variables have 0 objective coefficient
+    <li> <code>rowsen</code>: all rows are >=
+    <li> <code>rowrhs</code>: all right hand sides are 0
+    <li> <code>rowrng</code>: 0 for the ranged rows
+    </ul>
+    
+    Note that the default values for rowsen, rowrhs, and rowrng produce the
+    constraint ax >= 0.
+  */
+  void loadBlock (const CoinPackedMatrix& matrix,
+		  const double* collb, const double* colub,
+		  const double* obj,
+		  const char* rowsen, const double* rowrhs,   
+		  const double* rowrng) ;
+  
+  /*! \brief Load in a problem by copying the arguments. The constraint
+    matrix is is specified with standard column-major
+    column starts / row indices / coefficients vectors. 
+    The constraints on the rows are given by lower and upper bounds.
+    
+    The matrix vectors must be gap-free. Note that <code>start</code> must
+    have <code>numcols+1</code> entries so that the length of the last column
+    can be calculated as <code>start[numcols]-start[numcols-1]</code>.
+    
+    See the previous loadBlock method using rowlb and rowub for default
+    argument values.
+  */
+  void loadBlock (const int numcols, const int numrows,
+		  const CoinBigIndex * start, const int* index,
+		  const double* value,
+		  const double* collb, const double* colub,   
+		  const double* obj,
+		  const double* rowlb, const double* rowub) ;
+  
+  /*! \brief Load in a problem by copying the arguments. The constraint
+    matrix is is specified with standard column-major
+    column starts / row indices / coefficients vectors. 
+    The constraints on the rows are given by sense/rhs/range triplets.
+    
+    The matrix vectors must be gap-free. Note that <code>start</code> must
+    have <code>numcols+1</code> entries so that the length of the last column
+    can be calculated as <code>start[numcols]-start[numcols-1]</code>.
+    
+    See the previous loadBlock method using sense/rhs/range for default
+    argument values.
+  */
+  void loadBlock (const int numcols, const int numrows,
+		  const CoinBigIndex * start, const int* index,
+		  const double* value,
+		  const double* collb, const double* colub,   
+		  const double* obj,
+		  const char* rowsen, const double* rowrhs,   
+		  const double* rowrng) ;
+
+   //@}
+
+  /**@name Constructors, destructor */
+   //@{
+   /** Default constructor. */
+   CoinModel();
+   /** Constructor with sizes. */
+   CoinModel(int firstRows, int firstColumns, int firstElements,bool noNames=false);
+   /** Read a problem in MPS or GAMS format from the given filename.
+   */
+   CoinModel(const char *fileName, int allowStrings=0);
+   /** Read a problem from AMPL nl file
+       NOTE - as I can't work out configure etc the source code is in Cbc_ampl.cpp!
+   */
+   CoinModel( int nonLinear, const char * fileName,const void * info);
+  /// From arrays
+  CoinModel(int numberRows, int numberColumns,
+	    const CoinPackedMatrix * matrix,
+	    const double * rowLower, const double * rowUpper,
+	    const double * columnLower, const double * columnUpper,
+	    const double * objective);
+  /// Clone
+  virtual CoinBaseModel * clone() const;
+
+   /** Destructor */
+   virtual ~CoinModel();
+   //@}
+
+   /**@name Copy method */
+   //@{
+   /** The copy constructor. */
+   CoinModel(const CoinModel&);
+  /// =
+   CoinModel& operator=(const CoinModel&);
+   //@}
+
+   /**@name For debug */
+   //@{
+  /// Checks that links are consistent
+  void validateLinks() const;
+   //@}
+private:
+  /// Resize
+  void resize(int maximumRows, int maximumColumns, int maximumElements);
+  /// Fill in default row information
+  void fillRows(int which,bool forceCreation,bool fromAddRow=false);
+  /// Fill in default column information
+  void fillColumns(int which,bool forceCreation,bool fromAddColumn=false);
+  /** Fill in default linked list information (1= row, 2 = column)
+      Marked as const as list is mutable */
+  void fillList(int which, CoinModelLinkedList & list,int type) const ;
+  /** Create a linked list and synchronize free 
+      type 1 for row 2 for column
+      Marked as const as list is mutable */
+  void createList(int type) const;
+  /// Adds one string, returns index
+  int addString(const char * string);
+  /** Gets a double from a string possibly containing named strings,
+      returns unset if not found
+  */
+  double getDoubleFromString(CoinYacc & info, const char * string);
+  /// Frees value memory
+  void freeStringMemory(CoinYacc & info);
+public:
+  /// Fills in all associated - returning number of errors
+  int computeAssociated(double * associated);
+  /** Gets correct form for a quadratic row - user to delete
+      If row is not quadratic then returns which other variables are involved
+      with tiny (1.0e-100) elements and count of total number of variables which could not
+      be put in quadratic form
+  */
+  CoinPackedMatrix * quadraticRow(int rowNumber,double * linear,
+				  int & numberBad) const;
+  /// Replaces a quadratic row
+  void replaceQuadraticRow(int rowNumber,const double * linear, const CoinPackedMatrix * quadraticPart);
+  /** If possible return a model where if all variables marked nonzero are fixed
+      the problem will be linear.  At present may only work if quadratic.
+      Returns NULL if not possible
+  */
+  CoinModel * reorder(const char * mark) const;
+  /** Expands out all possible combinations for a knapsack
+      If buildObj NULL then just computes space needed - returns number elements
+      On entry numberOutput is maximum allowed, on exit it is number needed or
+      -1 (as will be number elements) if maximum exceeded.  numberOutput will have at
+      least space to return values which reconstruct input.
+      Rows returned will be original rows but no entries will be returned for
+      any rows all of whose entries are in knapsack.  So up to user to allow for this.
+      If reConstruct >=0 then returns number of entrie which make up item "reConstruct"
+      in expanded knapsack.  Values in buildRow and buildElement;
+  */
+  int expandKnapsack(int knapsackRow, int & numberOutput,double * buildObj, CoinBigIndex * buildStart,
+		     int * buildRow, double * buildElement,int reConstruct=-1) const;
+  /// Sets cut marker array
+  void setCutMarker(int size,const int * marker);
+  /// Sets priority array
+  void setPriorities(int size,const int * priorities);
+  /// priorities (given for all columns (-1 if not integer)
+  inline const int * priorities() const
+  { return priority_;}
+  /// For decomposition set original row and column indices
+  void setOriginalIndices(const int * row, const int * column);
+  
+private:
+  /** Read a problem from AMPL nl file
+      so not constructor so gdb will work
+   */
+  void gdb( int nonLinear, const char * fileName, const void * info);
+  /// returns jColumn (-2 if linear term, -1 if unknown) and coefficient
+  int decodeBit(char * phrase, char * & nextPhrase, double & coefficient, bool ifFirst) const;
+  /// Aborts with message about packedMatrix
+  void badType() const;
+  /**@name Data members */
+   //@{
+  /// Maximum number of rows
+  int maximumRows_;
+  /// Maximum number of columns
+  int maximumColumns_;
+  /// Current number of elements
+  int numberElements_;
+  /// Maximum number of elements
+  int maximumElements_;
+  /// Current number of quadratic elements
+  int numberQuadraticElements_;
+  /// Maximum number of quadratic elements
+  int maximumQuadraticElements_;
+  /// Row lower 
+  double * rowLower_;
+  /// Row upper 
+  double * rowUpper_;
+  /// Row names
+  CoinModelHash rowName_;
+  /** Row types.
+      Has information - at present
+      bit 0 - rowLower is a string
+      bit 1 - rowUpper is a string
+      NOTE - if converted to CoinPackedMatrix - may be indices of 
+      original rows (i.e. when decomposed)
+  */
+  int * rowType_;
+  /// Objective
+  double * objective_;
+  /// Column Lower
+  double * columnLower_;
+  /// Column Upper
+  double * columnUpper_;
+  /// Column names
+  CoinModelHash columnName_;
+  /// Integer information
+  int * integerType_;
+  /// Strings
+  CoinModelHash string_;
+  /** Column types.
+      Has information - at present
+      bit 0 - columnLower is a string
+      bit 1 - columnUpper is a string
+      bit 2 - objective is a string
+      bit 3 - integer setting is a string
+      NOTE - if converted to CoinPackedMatrix - may be indices of 
+      original columns (i.e. when decomposed)
+  */
+  int * columnType_;
+  /// If simple then start of each row/column
+  int * start_;
+  /// Actual elements
+  CoinModelTriple * elements_;
+  /// Actual elements as CoinPackedMatrix
+  CoinPackedMatrix * packedMatrix_;
+  /// Hash for elements
+  mutable CoinModelHash2 hashElements_;
+  /// Linked list for rows
+  mutable CoinModelLinkedList rowList_;
+  /// Linked list for columns
+  mutable CoinModelLinkedList columnList_;
+  /// Actual quadratic elements (always linked lists)
+  CoinModelTriple * quadraticElements_;
+  /// Hash for quadratic elements
+  mutable CoinModelHash2 hashQuadraticElements_;
+  /// Array for sorting indices
+  int * sortIndices_;
+  /// Array for sorting elements
+  double * sortElements_;
+  /// Size of sort arrays
+  int sortSize_;
+  /// Linked list for quadratic rows
+  mutable CoinModelLinkedList quadraticRowList_;
+  /// Linked list for quadratic columns
+  mutable CoinModelLinkedList quadraticColumnList_;
+  /// Size of associated values
+  int sizeAssociated_;
+  /// Associated values
+  double * associated_;
+  /// Number of SOS - all these are done in one go e.g. from ampl
+  int numberSOS_;
+  /// SOS starts
+  int * startSOS_;
+  /// SOS members
+  int * memberSOS_;
+  /// SOS type
+  int * typeSOS_;
+  /// SOS priority
+  int * prioritySOS_;
+  /// SOS reference
+  double * referenceSOS_;
+  /// priorities (given for all columns (-1 if not integer)
+  int * priority_;
+  /// Nonzero if row is cut - done in one go e.g. from ampl
+  int * cut_;
+  /// Pointer to more information
+  void * moreInfo_;
+  /** Type of build -
+      -1 unset,
+      0 for row, 
+      1 for column,
+      2 linked.
+      3 matrix is CoinPackedMatrix (and at present can't be modified);
+  */
+  mutable int type_;
+  /// True if no names EVER being used (for users who know what they are doing)
+  bool noNames_;
+  /** Links present (could be tested by sizes of objects)
+      0 - none,
+      1 - row links,
+      2 - column links,
+      3 - both
+  */
+  mutable int links_;
+   //@}
+};
+/// Just function of single variable x
+double getFunctionValueFromString(const char * string, const char * x, double xValue);
+/// faster version
+double getDoubleFromString(CoinYacc & info, const char * string, const char * x, double xValue);
+#endif