casadi 3.7.2__cp314-none-manylinux2014_x86_64.whl

casadi/include/coin/CoinModel.hpp

@@ -0,0 +1,1214 @@
+/* $Id$ */
+// 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);
+  CoinBigIndex deleteElement(int row, int column);
+  /// Takes element out of matrix when position known
+  void deleteThisElement(int row, int column, CoinBigIndex 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 */
+  CoinBigIndex 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, CoinBigIndex 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, CoinBigIndex 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
+  CoinBigIndex numberElements_;
+  /// Maximum number of elements
+  CoinBigIndex maximumElements_;
+  /// Current number of quadratic elements
+  CoinBigIndex numberQuadraticElements_;
+  /// Maximum number of quadratic elements
+  CoinBigIndex 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
+  CoinBigIndex *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
+
+/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
+*/