CoinModel.hpp

Go to the documentation of this file.

/* $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:
  CoinBaseModel();
 
  CoinBaseModel(const CoinBaseModel &rhs);
 
  CoinBaseModel &operator=(const CoinBaseModel &rhs);
 
  virtual CoinBaseModel *clone() const = 0;
 
  virtual ~CoinBaseModel();
 
  inline int numberRows() const
  {
    return numberRows_;
  }
  inline int numberColumns() const
  {
    return numberColumns_;
  }
  virtual CoinBigIndex numberElements() const = 0;
  inline double objectiveOffset() const
  {
    return objectiveOffset_;
  }
  inline void setObjectiveOffset(double value)
  {
    objectiveOffset_ = value;
  }
  inline double optimizationDirection() const
  {
    return optimizationDirection_;
  }
  inline void setOptimizationDirection(double value)
  {
    optimizationDirection_ = value;
  }
  inline int logLevel() const
  {
    return logLevel_;
  }
  void setLogLevel(int value);
  inline const char *getProblemName() const
  {
    return problemName_.c_str();
  }
  void setProblemName(const char *name);
  void setProblemName(const std::string &name);
  inline const std::string &getRowBlock() const
  {
    return rowBlockName_;
  }
  inline void setRowBlock(const std::string &name)
  {
    rowBlockName_ = name;
  }
  inline const std::string &getColumnBlock() const
  {
    return columnBlockName_;
  }
  inline void setColumnBlock(const std::string &name)
  {
    columnBlockName_ = name;
  }
  void setMessageHandler(CoinMessageHandler *handler);
 
protected:
  int numberRows_;
  int numberColumns_;
  double optimizationDirection_;
  double objectiveOffset_;
  std::string problemName_;
  std::string rowBlockName_;
  std::string columnBlockName_;
  CoinMessageHandler *handler_;
  CoinMessages messages_;
 
  int logLevel_;
};
 
class CoinModel : public CoinBaseModel {
 
public:
  void addRow(int numberInRow, const int *columns,
    const double *elements, double rowLower = -COIN_DBL_MAX,
    double rowUpper = COIN_DBL_MAX, const char *name = NULL);
  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);
  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);
  }
  inline void operator()(int i, int j, double value)
  {
    setElement(i, j, value);
  }
  void setElement(int i, int j, double value);
  int getRow(int whichRow, int *column, double *element);
  int getColumn(int whichColumn, int *column, double *element);
  void setQuadraticElement(int i, int j, double value);
  inline void operator()(int i, int j, const char *value)
  {
    setElement(i, j, value);
  }
  void setElement(int i, int j, const char *value);
  int associateElement(const char *stringValue, double value);
  void setRowLower(int whichRow, double rowLower);
  void setRowUpper(int whichRow, double rowUpper);
  void setRowBounds(int whichRow, double rowLower, double rowUpper);
  void setRowName(int whichRow, const char *rowName);
  void setColumnLower(int whichColumn, double columnLower);
  void setColumnUpper(int whichColumn, double columnUpper);
  void setColumnBounds(int whichColumn, double columnLower, double columnUpper);
  void setColumnObjective(int whichColumn, double columnObjective);
  void setColumnName(int whichColumn, const char *columnName);
  void setColumnIsInteger(int whichColumn, bool columnIsInteger);
  inline void setObjective(int whichColumn, double columnObjective)
  {
    setColumnObjective(whichColumn, columnObjective);
  }
  inline void setIsInteger(int whichColumn, bool columnIsInteger)
  {
    setColumnIsInteger(whichColumn, columnIsInteger);
  }
  inline void setInteger(int whichColumn)
  {
    setColumnIsInteger(whichColumn, true);
  }
  inline void setContinuous(int whichColumn)
  {
    setColumnIsInteger(whichColumn, false);
  }
  inline void setColLower(int whichColumn, double columnLower)
  {
    setColumnLower(whichColumn, columnLower);
  }
  inline void setColUpper(int whichColumn, double columnUpper)
  {
    setColumnUpper(whichColumn, columnUpper);
  }
  inline void setColBounds(int whichColumn, double columnLower, double columnUpper)
  {
    setColumnBounds(whichColumn, columnLower, columnUpper);
  }
  inline void setColObjective(int whichColumn, double columnObjective)
  {
    setColumnObjective(whichColumn, columnObjective);
  }
  inline void setColName(int whichColumn, const char *columnName)
  {
    setColumnName(whichColumn, columnName);
  }
  inline void setColIsInteger(int whichColumn, bool columnIsInteger)
  {
    setColumnIsInteger(whichColumn, columnIsInteger);
  }
  void setRowLower(int whichRow, const char *rowLower);
  void setRowUpper(int whichRow, const char *rowUpper);
  void setColumnLower(int whichColumn, const char *columnLower);
  void setColumnUpper(int whichColumn, const char *columnUpper);
  void setColumnObjective(int whichColumn, const char *columnObjective);
  void setColumnIsInteger(int whichColumn, const char *columnIsInteger);
  inline void setObjective(int whichColumn, const char *columnObjective)
  {
    setColumnObjective(whichColumn, columnObjective);
  }
  inline void setIsInteger(int whichColumn, const char *columnIsInteger)
  {
    setColumnIsInteger(whichColumn, columnIsInteger);
  }
  void deleteRow(int whichRow);
  void deleteColumn(int whichColumn);
  inline void deleteCol(int whichColumn)
  {
    deleteColumn(whichColumn);
  }
  CoinBigIndex deleteElement(int row, int column);
  void deleteThisElement(int row, int column, CoinBigIndex position);
  int packRows();
  int packColumns();
  inline int packCols()
  {
    return packColumns();
  }
  int pack();
 
  void setObjective(int numberColumns, const double *objective);
  void setColumnLower(int numberColumns, const double *columnLower);
  inline void setColLower(int numberColumns, const double *columnLower)
  {
    setColumnLower(numberColumns, columnLower);
  }
  void setColumnUpper(int numberColumns, const double *columnUpper);
  inline void setColUpper(int numberColumns, const double *columnUpper)
  {
    setColumnUpper(numberColumns, columnUpper);
  }
  void setRowLower(int numberRows, const double *rowLower);
  void setRowUpper(int numberRows, const double *rowUpper);
 
  int writeMps(const char *filename, int compression = 0,
    int formatType = 0, int numberAcross = 2, bool keepStrings = false);
 
  int differentModel(CoinModel &other, bool ignoreNames);
 
  void passInMatrix(const CoinPackedMatrix &matrix);
  int convertMatrix();
  inline const CoinPackedMatrix *packedMatrix() const
  {
    return packedMatrix_;
  }
  inline const int *originalRows() const
  {
    return rowType_;
  }
  inline const int *originalColumns() const
  {
    return columnType_;
  }
 
  inline CoinBigIndex numberElements() const
  {
    return numberElements_;
  }
  inline const CoinModelTriple *elements() const
  {
    return elements_;
  }
  inline double operator()(int i, int j) const
  {
    return getElement(i, j);
  }
  double getElement(int i, int j) const;
  inline double operator()(const char *rowName, const char *columnName) const
  {
    return getElement(rowName, columnName);
  }
  double getElement(const char *rowName, const char *columnName) const;
  double getQuadraticElement(int i, int j) const;
  const char *getElementAsString(int i, int j) const;
  double *pointer(int i, int j) const;
  CoinBigIndex position(int i, int j) const;
 
  CoinModelLink firstInRow(int whichRow) const;
  CoinModelLink lastInRow(int whichRow) const;
  CoinModelLink firstInColumn(int whichColumn) const;
  CoinModelLink lastInColumn(int whichColumn) const;
  CoinModelLink next(CoinModelLink &current) const;
  CoinModelLink previous(CoinModelLink &current) const;
  CoinModelLink firstInQuadraticColumn(int whichColumn) const;
  CoinModelLink lastInQuadraticColumn(int whichColumn) const;
  double getRowLower(int whichRow) const;
  double getRowUpper(int whichRow) const;
  const char *getRowName(int whichRow) const;
  inline double rowLower(int whichRow) const
  {
    return getRowLower(whichRow);
  }
  inline double rowUpper(int whichRow) const
  {
    return getRowUpper(whichRow);
  }
  inline const char *rowName(int whichRow) const
  {
    return getRowName(whichRow);
  }
  double getColumnLower(int whichColumn) const;
  double getColumnUpper(int whichColumn) const;
  double getColumnObjective(int whichColumn) const;
  const char *getColumnName(int whichColumn) const;
  bool getColumnIsInteger(int whichColumn) const;
  inline double columnLower(int whichColumn) const
  {
    return getColumnLower(whichColumn);
  }
  inline double columnUpper(int whichColumn) const
  {
    return getColumnUpper(whichColumn);
  }
  inline double columnObjective(int whichColumn) const
  {
    return getColumnObjective(whichColumn);
  }
  inline double objective(int whichColumn) const
  {
    return getColumnObjective(whichColumn);
  }
  inline const char *columnName(int whichColumn) const
  {
    return getColumnName(whichColumn);
  }
  inline bool columnIsInteger(int whichColumn) const
  {
    return getColumnIsInteger(whichColumn);
  }
  inline bool isInteger(int whichColumn) const
  {
    return getColumnIsInteger(whichColumn);
  }
  inline double getColLower(int whichColumn) const
  {
    return getColumnLower(whichColumn);
  }
  inline double getColUpper(int whichColumn) const
  {
    return getColumnUpper(whichColumn);
  }
  inline double getColObjective(int whichColumn) const
  {
    return getColumnObjective(whichColumn);
  }
  inline const char *getColName(int whichColumn) const
  {
    return getColumnName(whichColumn);
  }
  inline bool getColIsInteger(int whichColumn) const
  {
    return getColumnIsInteger(whichColumn);
  }
  const char *getRowLowerAsString(int whichRow) const;
  const char *getRowUpperAsString(int whichRow) const;
  inline const char *rowLowerAsString(int whichRow) const
  {
    return getRowLowerAsString(whichRow);
  }
  inline const char *rowUpperAsString(int whichRow) const
  {
    return getRowUpperAsString(whichRow);
  }
  const char *getColumnLowerAsString(int whichColumn) const;
  const char *getColumnUpperAsString(int whichColumn) const;
  const char *getColumnObjectiveAsString(int whichColumn) const;
  const char *getColumnIsIntegerAsString(int whichColumn) const;
  inline const char *columnLowerAsString(int whichColumn) const
  {
    return getColumnLowerAsString(whichColumn);
  }
  inline const char *columnUpperAsString(int whichColumn) const
  {
    return getColumnUpperAsString(whichColumn);
  }
  inline const char *columnObjectiveAsString(int whichColumn) const
  {
    return getColumnObjectiveAsString(whichColumn);
  }
  inline const char *objectiveAsString(int whichColumn) const
  {
    return getColumnObjectiveAsString(whichColumn);
  }
  inline const char *columnIsIntegerAsString(int whichColumn) const
  {
    return getColumnIsIntegerAsString(whichColumn);
  }
  inline const char *isIntegerAsString(int whichColumn) const
  {
    return getColumnIsIntegerAsString(whichColumn);
  }
  int row(const char *rowName) const;
  int column(const char *columnName) const;
  inline int type() const
  {
    return type_;
  }
  inline double unsetValue() const
  {
    return -1.23456787654321e-97;
  }
  int createPackedMatrix(CoinPackedMatrix &matrix,
    const double *associated);
  int countPlusMinusOne(CoinBigIndex *startPositive, CoinBigIndex *startNegative,
    const double *associated);
  void createPlusMinusOne(CoinBigIndex *startPositive, CoinBigIndex *startNegative,
    int *indices,
    const double *associated);
  int createArrays(double *&rowLower, double *&rowUpper,
    double *&columnLower, double *&columnUpper,
    double *&objective, int *&integerType,
    double *&associated);
  inline bool stringsExist() const
  {
    return string_.numberItems() != 0;
  }
  inline const CoinModelHash *stringArray() const
  {
    return &string_;
  }
  inline double *associatedArray() const
  {
    return associated_;
  }
  inline double *rowLowerArray() const
  {
    return rowLower_;
  }
  inline double *rowUpperArray() const
  {
    return rowUpper_;
  }
  inline double *columnLowerArray() const
  {
    return columnLower_;
  }
  inline double *columnUpperArray() const
  {
    return columnUpper_;
  }
  inline double *objectiveArray() const
  {
    return objective_;
  }
  inline int *integerTypeArray() const
  {
    return integerType_;
  }
  inline const CoinModelHash *rowNames() const
  {
    return &rowName_;
  }
  inline const CoinModelHash *columnNames() const
  {
    return &columnName_;
  }
  inline void zapRowNames()
  {
    rowName_ = CoinModelHash();
  }
  inline void zapColumnNames()
  {
    columnName_ = CoinModelHash();
  }
  inline const int *cutMarker() const
  {
    return cut_;
  }
  inline double optimizationDirection() const
  {
    return optimizationDirection_;
  }
  inline void setOptimizationDirection(double value)
  {
    optimizationDirection_ = value;
  }
  inline void *moreInfo() const
  {
    return moreInfo_;
  }
  inline void setMoreInfo(void *info)
  {
    moreInfo_ = info;
  }
  int whatIsSet() const;
 
  void loadBlock(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const double *rowlb, const double *rowub);
  void loadBlock(const CoinPackedMatrix &matrix,
    const double *collb, const double *colub,
    const double *obj,
    const char *rowsen, const double *rowrhs,
    const double *rowrng);
 
  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);
 
  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);
 
 
  CoinModel();
  CoinModel(int firstRows, int firstColumns, CoinBigIndex firstElements, bool noNames = false);
  CoinModel(const char *fileName, int allowStrings = 0);
  CoinModel(int nonLinear, const char *fileName, const void *info);
  CoinModel(int numberRows, int numberColumns,
    const CoinPackedMatrix *matrix,
    const double *rowLower, const double *rowUpper,
    const double *columnLower, const double *columnUpper,
    const double *objective);
  virtual CoinBaseModel *clone() const;
 
  virtual ~CoinModel();
 
  CoinModel(const CoinModel &);
  CoinModel &operator=(const CoinModel &);
 
  void validateLinks() const;
private:
  void resize(int maximumRows, int maximumColumns, CoinBigIndex maximumElements);
  void fillRows(int which, bool forceCreation, bool fromAddRow = false);
  void fillColumns(int which, bool forceCreation, bool fromAddColumn = false);
  void fillList(int which, CoinModelLinkedList &list, int type) const;
  void createList(int type) const;
  int addString(const char *string);
  double getDoubleFromString(CoinYacc &info, const char *string);
  void freeStringMemory(CoinYacc &info);
 
public:
  int computeAssociated(double *associated);
  CoinPackedMatrix *quadraticRow(int rowNumber, double *linear,
    int &numberBad) const;
  void replaceQuadraticRow(int rowNumber, const double *linear, const CoinPackedMatrix *quadraticPart);
  CoinModel *reorder(const char *mark) const;
  int expandKnapsack(int knapsackRow, int &numberOutput, double *buildObj, CoinBigIndex *buildStart,
    int *buildRow, double *buildElement, int reConstruct = -1) const;
  void setCutMarker(int size, const int *marker);
  void setPriorities(int size, const int *priorities);
  inline const int *priorities() const
  {
    return priority_;
  }
  void setOriginalIndices(const int *row, const int *column);
 
private:
  void gdb(int nonLinear, const char *fileName, const void *info);
  int decodeBit(char *phrase, char *&nextPhrase, double &coefficient, bool ifFirst) const;
  void badType() const;
  int maximumRows_;
  int maximumColumns_;
  CoinBigIndex numberElements_;
  CoinBigIndex maximumElements_;
  CoinBigIndex numberQuadraticElements_;
  CoinBigIndex maximumQuadraticElements_;
  double *rowLower_;
  double *rowUpper_;
  CoinModelHash rowName_;
  int *rowType_;
  double *objective_;
  double *columnLower_;
  double *columnUpper_;
  CoinModelHash columnName_;
  int *integerType_;
  CoinModelHash string_;
  int *columnType_;
  CoinBigIndex *start_;
  CoinModelTriple *elements_;
  CoinPackedMatrix *packedMatrix_;
  mutable CoinModelHash2 hashElements_;
  mutable CoinModelLinkedList rowList_;
  mutable CoinModelLinkedList columnList_;
  CoinModelTriple *quadraticElements_;
  mutable CoinModelHash2 hashQuadraticElements_;
  int *sortIndices_;
  double *sortElements_;
  int sortSize_;
  mutable CoinModelLinkedList quadraticRowList_;
  mutable CoinModelLinkedList quadraticColumnList_;
  int sizeAssociated_;
  double *associated_;
  int numberSOS_;
  int *startSOS_;
  int *memberSOS_;
  int *typeSOS_;
  int *prioritySOS_;
  double *referenceSOS_;
  int *priority_;
  int *cut_;
  void *moreInfo_;
  mutable int type_;
  bool noNames_;
  mutable int links_;
};
double getFunctionValueFromString(const char *string, const char *x, double xValue);
double getDoubleFromString(CoinYacc &info, const char *string, const char *x, double xValue);
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/