Doxygen/CHiPPS-Alps/_coin_model_8hpp_source.html

 /* $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:


   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);}

   int deleteElement(int row, int column);

   void deleteThisElement(int row, int column,int 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;

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

   int numberElements_;

   int maximumElements_;

   int numberQuadraticElements_;

   int maximumQuadraticElements_;

   double * rowLower_;

   double * rowUpper_;

   CoinModelHash rowName_;

   int * rowType_;

   double * objective_;

   double * columnLower_;

   double * columnUpper_;

   CoinModelHash columnName_;

   int * integerType_;

   CoinModelHash string_;

   int * columnType_;

   int * 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

CoinModel::maximumQuadraticElements_
int maximumQuadraticElements_
Maximum number of quadratic elements.
Definition: CoinModel.hpp:946

CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:105

CoinModelHash
Definition: CoinModelUseful.hpp:180

CoinModel::getColLower
double getColLower(int whichColumn) const
Gets columnLower (if column does not exist then 0.0)
Definition: CoinModel.hpp:578

CoinPackedMatrix.hpp

CoinModel::getRowName
const char * getRowName(int whichRow) const
Gets name (if row does not exist then NULL)

CoinModel::objectiveAsString
const char * objectiveAsString(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)
Definition: CoinModel.hpp:634

CoinModel::rowType_
int * rowType_
Row types.
Definition: CoinModel.hpp:960

CoinModel::associateElement
int associateElement(const char *stringValue, double value)
Associates a string with a value. Returns string id (or -1 if does not exist)

CoinModel
This is a simple minded model which is stored in a format which makes it easier to construct and modi...
Definition: CoinModel.hpp:161

CoinModel::objective
double objective(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)
Definition: CoinModel.hpp:562

CoinModel::addColumn
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 */

CoinModel::moreInfo
void * moreInfo() const
Return pointer to more information.
Definition: CoinModel.hpp:724

CoinModel::getRowLowerAsString
const char * getRowLowerAsString(int whichRow) const
Gets rowLower (if row does not exist then -COIN_DBL_MAX)

CoinModelLink
This is for various structures/classes needed by CoinModel.
Definition: CoinModelUseful.hpp:30

CoinModel::sortIndices_
int * sortIndices_
Array for sorting indices.
Definition: CoinModel.hpp:1000

CoinModel::setObjective
void setObjective(int whichColumn, double columnObjective)
Sets columnObjective (if column does not exist then all columns up to this are defined with default v...
Definition: CoinModel.hpp:253

CoinBaseModel::setMessageHandler
void setMessageHandler(CoinMessageHandler *handler)
Pass in message handler.

CoinModel::startSOS_
int * startSOS_
SOS starts.
Definition: CoinModel.hpp:1016

CoinModel::getElementAsString
const char * getElementAsString(int i, int j) const
Returns value for row i and column j as string.

CoinMessageHandler
Base class for message handling.
Definition: CoinMessageHandler.hpp:327

CoinModel::priorities
const int * priorities() const
priorities (given for all columns (-1 if not integer)
Definition: CoinModel.hpp:919

CoinModel::setRowUpper
void setRowUpper(int whichRow, double rowUpper)
Sets rowUpper (if row does not exist then all rows up to this are defined with default values and no ...

CoinModel::type
int type() const
Returns type.
Definition: CoinModel.hpp:649

CoinModel::moreInfo_
void * moreInfo_
Pointer to more information.
Definition: CoinModel.hpp:1030

CoinModel::getQuadraticElement
double getQuadraticElement(int i, int j) const
Returns quadratic value for columns i and j.

CoinModel::unsetValue
double unsetValue() const
returns unset value
Definition: CoinModel.hpp:652

CoinModel::priority_
int * priority_
priorities (given for all columns (-1 if not integer)
Definition: CoinModel.hpp:1026

CoinModel::quadraticRow
CoinPackedMatrix * quadraticRow(int rowNumber, double *linear, int &numberBad) const
Gets correct form for a quadratic row - user to delete If row is not quadratic then returns which oth...

CoinModel::getColumnUpper
double getColumnUpper(int whichColumn) const
Gets columnUpper (if column does not exist then COIN_DBL_MAX)

CoinModel::CoinModel
CoinModel()
Default constructor.

CoinModel::rowName_
CoinModelHash rowName_
Row names.
Definition: CoinModel.hpp:952

CoinModel::integerType_
int * integerType_
Integer information.
Definition: CoinModel.hpp:970

CoinModel::quadraticColumnList_
CoinModelLinkedList quadraticColumnList_
Linked list for quadratic columns.
Definition: CoinModel.hpp:1008

CoinModel::firstInQuadraticColumn
CoinModelLink firstInQuadraticColumn(int whichColumn) const
Returns first element in given quadratic column - index is -1 if none.

CoinModelHash::numberItems
int numberItems() const
Number of items i.e. rows if just row names.
Definition: CoinModelUseful.hpp:204

CoinModel::packedMatrix_
CoinPackedMatrix * packedMatrix_
Actual elements as CoinPackedMatrix.
Definition: CoinModel.hpp:988

CoinModel::integerTypeArray
int * integerTypeArray() const
Return integerType array.
Definition: CoinModel.hpp:699

CoinModel::originalRows
const int * originalRows() const
Return pointers to original rows (for decomposition)
Definition: CoinModel.hpp:435

CoinBaseModel::rowBlockName_
std::string rowBlockName_
Rowblock name.
Definition: CoinModel.hpp:103

CoinBaseModel::optimizationDirection
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: CoinModel.hpp:55

CoinModel::columnLowerArray
double * columnLowerArray() const
Return columnLower array.
Definition: CoinModel.hpp:690

CoinModel::setColObjective
void setColObjective(int whichColumn, double columnObjective)
Sets columnObjective (if column does not exist then all columns up to this are defined with default v...
Definition: CoinModel.hpp:288

CoinModel::columnNames
const CoinModelHash * columnNames() const
Return column names array.
Definition: CoinModel.hpp:705

CoinModel::columnLower_
double * columnLower_
Column Lower.
Definition: CoinModel.hpp:964

CoinModel::columnType_
int * columnType_
Column types.
Definition: CoinModel.hpp:982

CoinBaseModel::problemName_
std::string problemName_
Problem name.
Definition: CoinModel.hpp:101

CoinModel::addString
int addString(const char *string)
Adds one string, returns index.

CoinModel::originalColumns
const int * originalColumns() const
Return pointers to original columns (for decomposition)
Definition: CoinModel.hpp:438

CoinModel::rowLower_
double * rowLower_
Row lower.
Definition: CoinModel.hpp:948

CoinModel::stringArray
const CoinModelHash * stringArray() const
Return string array.
Definition: CoinModel.hpp:678

CoinModel::columnList_
CoinModelLinkedList columnList_
Linked list for columns.
Definition: CoinModel.hpp:994

CoinFinite.hpp

CoinModel::setColumnName
void setColumnName(int whichColumn, const char *columnName)
Sets name (if column does not exist then all columns up to this are defined with default values and n...

CoinModel::maximumColumns_
int maximumColumns_
Maximum number of columns.
Definition: CoinModel.hpp:938

CoinModel::columnLowerAsString
const char * columnLowerAsString(int whichColumn) const
Gets columnLower (if column does not exist then 0.0)
Definition: CoinModel.hpp:622

CoinModel::getColumnIsInteger
bool getColumnIsInteger(int whichColumn) const
Gets if integer (if column does not exist then false)

CoinModel::getColUpper
double getColUpper(int whichColumn) const
Gets columnUpper (if column does not exist then COIN_DBL_MAX)
Definition: CoinModel.hpp:582

CoinModel::differentModel
int differentModel(CoinModel &other, bool ignoreNames)
Check two models against each other.

CoinModel::firstInColumn
CoinModelLink firstInColumn(int whichColumn) const
Returns first element in given column - index is -1 if none.

CoinModel::setContinuous
void setContinuous(int whichColumn)
Sets continuous (if column does not exist then all columns up to this are defined with default values...
Definition: CoinModel.hpp:268

CoinModel::string_
CoinModelHash string_
Strings.
Definition: CoinModel.hpp:972

CoinModel::whatIsSet
int whatIsSet() const
Returns which parts of model are set 1 - matrix 2 - rhs 4 - row names 8 - column bounds and/or object...

CoinModel::rowUpper
double rowUpper(int whichRow) const
Gets rowUpper (if row does not exist then COIN_DBL_MAX)
Definition: CoinModel.hpp:527

CoinModel::createPlusMinusOne
void createPlusMinusOne(CoinBigIndex *startPositive, CoinBigIndex *startNegative, int *indices, const double *associated)
Creates +-1 matrix given startPositive and startNegative counts for +-1 matrix.

CoinBaseModel::setOptimizationDirection
void setOptimizationDirection(double value)
Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: CoinModel.hpp:59

CoinModel::fillColumns
void fillColumns(int which, bool forceCreation, bool fromAddColumn=false)
Fill in default column information.

CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79

CoinModel::numberSOS_
int numberSOS_
Number of SOS - all these are done in one go e.g. from ampl.
Definition: CoinModel.hpp:1014

CoinModel::badType
void badType() const
Aborts with message about packedMatrix.

CoinModel::getRow
int getRow(int whichRow, int *column, double *element)
Gets sorted row - user must provide enough space (easiest is allocate number of columns).

getFunctionValueFromString
double getFunctionValueFromString(const char *string, const char *x, double xValue)
Just function of single variable x.

CoinModel::getColumnObjectiveAsString
const char * getColumnObjectiveAsString(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)

CoinModel::elements_
CoinModelTriple * elements_
Actual elements.
Definition: CoinModel.hpp:986

CoinModel::numberQuadraticElements_
int numberQuadraticElements_
Current number of quadratic elements.
Definition: CoinModel.hpp:944

CoinModel::columnIsInteger
bool columnIsInteger(int whichColumn) const
Gets if integer (if column does not exist then false)
Definition: CoinModel.hpp:570

CoinModel::getColumnLowerAsString
const char * getColumnLowerAsString(int whichColumn) const
Gets columnLower (if column does not exist then 0.0)

CoinModel::deleteElement
int deleteElement(int row, int column)
Takes element out of matrix - returning position (&lt;0 if not there);.

CoinModel::createArrays
int createArrays(double *&rowLower, double *&rowUpper, double *&columnLower, double *&columnUpper, double *&objective, int *&integerType, double *&associated)
Creates copies of various arrays - return number of errors.

CoinModel::deleteThisElement
void deleteThisElement(int row, int column, int position)
Takes element out of matrix when position known.

CoinBaseModel::handler_
CoinMessageHandler * handler_
Message handler (Passed in)
Definition: CoinModel.hpp:107

CoinModel::setRowLower
void setRowLower(int whichRow, double rowLower)
Sets rowLower (if row does not exist then all rows up to this are defined with default values and no ...

CoinModel::setOriginalIndices
void setOriginalIndices(const int *row, const int *column)
For decomposition set original row and column indices.

CoinModel::objective_
double * objective_
Objective.
Definition: CoinModel.hpp:962

CoinBaseModel::operator=
CoinBaseModel & operator=(const CoinBaseModel &rhs)
Assignment operator.

CoinModel::getColName
const char * getColName(int whichColumn) const
Gets name (if column does not exist then NULL)
Definition: CoinModel.hpp:590

CoinModel::rowUpper_
double * rowUpper_
Row upper.
Definition: CoinModel.hpp:950

CoinBaseModel::messages_
CoinMessages messages_
Messages.
Definition: CoinModel.hpp:109

CoinModel::referenceSOS_
double * referenceSOS_
SOS reference.
Definition: CoinModel.hpp:1024

CoinModel::setElement
void setElement(int i, int j, double value)
Sets value for row i and column j.

CoinModel::columnName_
CoinModelHash columnName_
Column names.
Definition: CoinModel.hpp:968

CoinModel::rowUpperAsString
const char * rowUpperAsString(int whichRow) const
Gets rowUpper (if row does not exist then COIN_DBL_MAX)
Definition: CoinModel.hpp:606

CoinModel::setColumnIsInteger
void setColumnIsInteger(int whichColumn, bool columnIsInteger)
Sets integer state (if column does not exist then all columns up to this are defined with default val...

CoinModel::setRowBounds
void setRowBounds(int whichRow, double rowLower, double rowUpper)
Sets rowLower and rowUpper (if row does not exist then all rows up to this are defined with default v...

CoinModel::previous
CoinModelLink previous(CoinModelLink &current) const
Returns previous element in current row or column - index is -1 if none.

CoinModel::fillRows
void fillRows(int which, bool forceCreation, bool fromAddRow=false)
Fill in default row information.

CoinBaseModel::setLogLevel
void setLogLevel(int value)
Set print level 0 - off, 1 - errors, 2 - more.

CoinModel::setColumnBounds
void setColumnBounds(int whichColumn, double columnLower, double columnUpper)
Sets columnLower and columnUpper (if column does not exist then all columns up to this are defined wi...

CoinModel::operator=
CoinModel & operator=(const CoinModel &)
=

CoinModel::validateLinks
void validateLinks() const
Checks that links are consistent.

CoinModel::setColBounds
void setColBounds(int whichColumn, double columnLower, double columnUpper)
Sets columnLower and columnUpper (if column does not exist then all columns up to this are defined wi...
Definition: CoinModel.hpp:283

CoinBaseModel::~CoinBaseModel
virtual ~CoinBaseModel()
Destructor.

CoinBaseModel::numberColumns
int numberColumns() const
Return number of columns.
Definition: CoinModel.hpp:42

CoinModel::setOptimizationDirection
void setOptimizationDirection(double value)
Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: CoinModel.hpp:721

CoinModel::cut_
int * cut_
Nonzero if row is cut - done in one go e.g. from ampl.
Definition: CoinModel.hpp:1028

CoinModel::sizeAssociated_
int sizeAssociated_
Size of associated values.
Definition: CoinModel.hpp:1010

CoinBaseModel::setRowBlock
void setRowBlock(const std::string &name)
Set row block name.
Definition: CoinModel.hpp:77

CoinModel::hashElements_
CoinModelHash2 hashElements_
Hash for elements.
Definition: CoinModel.hpp:990

CoinModel::rowLowerArray
double * rowLowerArray() const
Return rowLower array.
Definition: CoinModel.hpp:684

CoinBaseModel
Definition: CoinModel.hpp:13

CoinBaseModel::logLevel_
int logLevel_
Print level.
Definition: CoinModel.hpp:119

CoinModel::setColLower
void setColLower(int numberColumns, const double *columnLower)
Sets columnLower array.
Definition: CoinModel.hpp:372

CoinModel::sortSize_
int sortSize_
Size of sort arrays.
Definition: CoinModel.hpp:1004

CoinModel::getColumn
int getColumn(int whichColumn, int *column, double *element)
Gets sorted column - user must provide enough space (easiest is allocate number of rows)...

CoinModel::lastInRow
CoinModelLink lastInRow(int whichRow) const
Returns last element in given row - index is -1 if none.

CoinModel::getColumnObjective
double getColumnObjective(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)

CoinModel::setColUpper
void setColUpper(int whichColumn, double columnUpper)
Sets columnUpper (if column does not exist then all columns up to this are defined with default value...
Definition: CoinModel.hpp:278

CoinModel::columnName
const char * columnName(int whichColumn) const
Gets name (if column does not exist then NULL)
Definition: CoinModel.hpp:566

CoinModel::addCol
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)
add a column - numberInColumn may be zero */
Definition: CoinModel.hpp:177

CoinModel::columnUpperAsString
const char * columnUpperAsString(int whichColumn) const
Gets columnUpper (if column does not exist then COIN_DBL_MAX)
Definition: CoinModel.hpp:626

CoinModel::pointer
double * pointer(int i, int j) const
Returns pointer to element for row i column j.

CoinModel::setQuadraticElement
void setQuadraticElement(int i, int j, double value)
Sets quadratic value for column i and j.

CoinBaseModel::getRowBlock
const std::string & getRowBlock() const
Return the row block name.
Definition: CoinModel.hpp:74

CoinModel::setRowName
void setRowName(int whichRow, const char *rowName)
Sets name (if row does not exist then all rows up to this are defined with default values and no elem...

CoinModel::noNames_
bool noNames_
True if no names EVER being used (for users who know what they are doing)
Definition: CoinModel.hpp:1040

CoinModel::objectiveArray
double * objectiveArray() const
Return objective array.
Definition: CoinModel.hpp:696

CoinModel::setColLower
void setColLower(int whichColumn, double columnLower)
Sets columnLower (if column does not exist then all columns up to this are defined with default value...
Definition: CoinModel.hpp:273

CoinModel::isIntegerAsString
const char * isIntegerAsString(int whichColumn) const
Gets if integer (if column does not exist then false)
Definition: CoinModel.hpp:642

CoinModel::writeMps
int writeMps(const char *filename, int compression=0, int formatType=0, int numberAcross=2, bool keepStrings=false)
Write the problem in MPS format to a file with the given filename.

CoinModel::zapRowNames
void zapRowNames()
Reset row names.
Definition: CoinModel.hpp:708

CoinModel::setColumnObjective
void setColumnObjective(int whichColumn, double columnObjective)
Sets columnObjective (if column does not exist then all columns up to this are defined with default v...

CoinBaseModel::CoinBaseModel
CoinBaseModel()
Default Constructor.

CoinModel::rowUpperArray
double * rowUpperArray() const
Return rowUpper array.
Definition: CoinModel.hpp:687

CoinBaseModel::numberElements
virtual CoinBigIndex numberElements() const =0
Return number of elements.

CoinModel::rowNames
const CoinModelHash * rowNames() const
Return row names array.
Definition: CoinModel.hpp:702

CoinBaseModel::logLevel
int logLevel() const
Get print level 0 - off, 1 - errors, 2 - more.
Definition: CoinModel.hpp:62

CoinModel::lastInQuadraticColumn
CoinModelLink lastInQuadraticColumn(int whichColumn) const
Returns last element in given quadratic column - index is -1 if none.

CoinModel::start_
int * start_
If simple then start of each row/column.
Definition: CoinModel.hpp:984

CoinMessageHandler.hpp
This is a first attempt at a message handler.

CoinModel::packedMatrix
const CoinPackedMatrix * packedMatrix() const
Return a pointer to CoinPackedMatrix (or NULL)
Definition: CoinModel.hpp:432

CoinModelLinkedList
Definition: CoinModelUseful.hpp:312

CoinModel::packCols
int packCols()
Packs down all columns i.e.
Definition: CoinModel.hpp:356

CoinModel::columnLower
double columnLower(int whichColumn) const
Gets columnLower (if column does not exist then 0.0)
Definition: CoinModel.hpp:550

CoinModel::fillList
void fillList(int which, CoinModelLinkedList &list, int type) const
Fill in default linked list information (1= row, 2 = column) Marked as const as list is mutable...

CoinModel::getColumnLower
double getColumnLower(int whichColumn) const
Gets columnLower (if column does not exist then 0.0)

CoinModel::lastInColumn
CoinModelLink lastInColumn(int whichColumn) const
Returns last element in given column - index is -1 if none.

CoinModel::stringsExist
bool stringsExist() const
Says if strings exist.
Definition: CoinModel.hpp:675

CoinBaseModel::numberRows_
int numberRows_
Current number of rows.
Definition: CoinModel.hpp:93

CoinModel::passInMatrix
void passInMatrix(const CoinPackedMatrix &matrix)
Pass in CoinPackedMatrix (and switch off element updates)

CoinModel::clone
virtual CoinBaseModel * clone() const
Clone.

CoinModel::createList
void createList(int type) const
Create a linked list and synchronize free type 1 for row 2 for column Marked as const as list is muta...

CoinBaseModel::columnBlockName_
std::string columnBlockName_
Columnblock name.
Definition: CoinModel.hpp:105

CoinModel::associatedArray
double * associatedArray() const
Returns associated array.
Definition: CoinModel.hpp:681

CoinModel::columnObjectiveAsString
const char * columnObjectiveAsString(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)
Definition: CoinModel.hpp:630

CoinModel::getColIsInteger
bool getColIsInteger(int whichColumn) const
Gets if integer (if column does not exist then false)
Definition: CoinModel.hpp:594

CoinModel::memberSOS_
int * memberSOS_
SOS members.
Definition: CoinModel.hpp:1018

CoinModel::column
int column(const char *columnName) const
Column index from column name (-1 if no names or no match)

COIN_DBL_MAX
const double COIN_DBL_MAX
Definition: CoinFinite.hpp:18

CoinModel::getColumnName
const char * getColumnName(int whichColumn) const
Gets name (if column does not exist then NULL)

CoinModel::decodeBit
int decodeBit(char *phrase, char *&nextPhrase, double &coefficient, bool ifFirst) const
returns jColumn (-2 if linear term, -1 if unknown) and coefficient

CoinModel::addRow
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 row - numberInRow may be zero

CoinModel::cutMarker
const int * cutMarker() const
Returns array of 0 or nonzero if can be a cut (or returns NULL)
Definition: CoinModel.hpp:714

CoinBaseModel::getProblemName
const char * getProblemName() const
Return the problem name.
Definition: CoinModel.hpp:67

CoinModel::getColumnIsIntegerAsString
const char * getColumnIsIntegerAsString(int whichColumn) const
Gets if integer (if column does not exist then false)

CoinBaseModel::objectiveOffset
double objectiveOffset() const
Returns the (constant) objective offset This is the RHS entry for the objective row.
Definition: CoinModel.hpp:49

CoinModel::setPriorities
void setPriorities(int size, const int *priorities)
Sets priority array.

CoinModel::columnObjective
double columnObjective(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)
Definition: CoinModel.hpp:558

CoinModel::typeSOS_
int * typeSOS_
SOS type.
Definition: CoinModel.hpp:1020

CoinModel::sortElements_
double * sortElements_
Array for sorting elements.
Definition: CoinModel.hpp:1002

CoinModel::deleteCol
void deleteCol(int whichColumn)
Deletes all entries in column and bounds.
Definition: CoinModel.hpp:342

CoinModel::quadraticRowList_
CoinModelLinkedList quadraticRowList_
Linked list for quadratic rows.
Definition: CoinModel.hpp:1006

CoinModel::getRowUpperAsString
const char * getRowUpperAsString(int whichRow) const
Gets rowUpper (if row does not exist then +COIN_DBL_MAX)

CoinMessages
Class to hold and manipulate an array of massaged messages.
Definition: CoinMessageHandler.hpp:128

CoinModel::setCutMarker
void setCutMarker(int size, const int *marker)
Sets cut marker array.

CoinModel::setIsInteger
void setIsInteger(int whichColumn, bool columnIsInteger)
Sets integer state (if column does not exist then all columns up to this are defined with default val...
Definition: CoinModel.hpp:258

CoinModel::~CoinModel
virtual ~CoinModel()
Destructor.

CoinModel::gdb
void gdb(int nonLinear, const char *fileName, const void *info)
Read a problem from AMPL nl file so not constructor so gdb will work.

CoinModel::getDoubleFromString
double getDoubleFromString(CoinYacc &info, const char *string)
Gets a double from a string possibly containing named strings, returns unset if not found...

getDoubleFromString
double getDoubleFromString(CoinYacc &info, const char *string, const char *x, double xValue)
faster version

CoinModel::columnUpper
double columnUpper(int whichColumn) const
Gets columnUpper (if column does not exist then COIN_DBL_MAX)
Definition: CoinModel.hpp:554

CoinModel::associated_
double * associated_
Associated values.
Definition: CoinModel.hpp:1012

CoinBaseModel::objectiveOffset_
double objectiveOffset_
Objective offset to be passed on.
Definition: CoinModel.hpp:99

CoinModel::hashQuadraticElements_
CoinModelHash2 hashQuadraticElements_
Hash for quadratic elements.
Definition: CoinModel.hpp:998

CoinBaseModel::optimizationDirection_
double optimizationDirection_
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: CoinModel.hpp:97

CoinModel::type_
int type_
Type of build - -1 unset, 0 for row, 1 for column, 2 linked.
Definition: CoinModel.hpp:1038

CoinModel::convertMatrix
int convertMatrix()
Convert elements to CoinPackedMatrix (and switch off element updates).

CoinModel::getRowUpper
double getRowUpper(int whichRow) const
Gets rowUpper (if row does not exist then +COIN_DBL_MAX)

CoinModel::setInteger
void setInteger(int whichColumn)
Sets integer (if column does not exist then all columns up to this are defined with default values an...
Definition: CoinModel.hpp:263

CoinModel::computeAssociated
int computeAssociated(double *associated)
Fills in all associated - returning number of errors.

CoinBaseModel::getColumnBlock
const std::string & getColumnBlock() const
Return the column block name.
Definition: CoinModel.hpp:80

CoinModel::isInteger
bool isInteger(int whichColumn) const
Gets if integer (if column does not exist then false)
Definition: CoinModel.hpp:574

CoinModel::getRowLower
double getRowLower(int whichRow) const
Gets rowLower (if row does not exist then -COIN_DBL_MAX)

CoinModel::setColumnLower
void setColumnLower(int whichColumn, double columnLower)
Sets columnLower (if column does not exist then all columns up to this are defined with default value...

CoinModel::packColumns
int packColumns()
Packs down all columns i.e.

CoinBaseModel::setColumnBlock
void setColumnBlock(const std::string &name)
Set column block name.
Definition: CoinModel.hpp:83

CoinModel::zapColumnNames
void zapColumnNames()
Reset column names.
Definition: CoinModel.hpp:711

CoinModelUseful.hpp

CoinModel::getColObjective
double getColObjective(int whichColumn) const
Gets columnObjective (if column does not exist then 0.0)
Definition: CoinModel.hpp:586

CoinModel::optimizationDirection
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: CoinModel.hpp:717

CoinModel::loadBlock
void loadBlock(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Load in a problem by copying the arguments. The constraints on the rows are given by lower and upper ...

CoinModel::quadraticElements_
CoinModelTriple * quadraticElements_
Actual quadratic elements (always linked lists)
Definition: CoinModel.hpp:996

CoinModel::reorder
CoinModel * reorder(const char *mark) const
If possible return a model where if all variables marked nonzero are fixed the problem will be linear...

CoinModel::elements
const CoinModelTriple * elements() const
Return elements as triples.
Definition: CoinModel.hpp:449

CoinModel::setColName
void setColName(int whichColumn, const char *columnName)
Sets name (if column does not exist then all columns up to this are defined with default values and n...
Definition: CoinModel.hpp:293

CoinModel::columnUpper_
double * columnUpper_
Column Upper.
Definition: CoinModel.hpp:966

CoinModel::setColumnUpper
void setColumnUpper(int whichColumn, double columnUpper)
Sets columnUpper (if column does not exist then all columns up to this are defined with default value...

CoinModel::setColUpper
void setColUpper(int numberColumns, const double *columnUpper)
Sets columnUpper array.
Definition: CoinModel.hpp:379

CoinModel::prioritySOS_
int * prioritySOS_
SOS priority.
Definition: CoinModel.hpp:1022

CoinBaseModel::setObjectiveOffset
void setObjectiveOffset(double value)
Set objective offset.
Definition: CoinModel.hpp:52

CoinModel::resize
void resize(int maximumRows, int maximumColumns, int maximumElements)
Resize.

CoinBaseModel::clone
virtual CoinBaseModel * clone() const =0
Clone.

CoinModel::setColIsInteger
void setColIsInteger(int whichColumn, bool columnIsInteger)
Sets integer (if column does not exist then all columns up to this are defined with default values an...
Definition: CoinModel.hpp:298

CoinModel::links_
int links_
Links present (could be tested by sizes of objects) 0 - none, 1 - row links, 2 - column links...
Definition: CoinModel.hpp:1047

CoinModel::rowList_
CoinModelLinkedList rowList_
Linked list for rows.
Definition: CoinModel.hpp:992

CoinYacc
Definition: CoinModelUseful.hpp:151

CoinModel::rowLower
double rowLower(int whichRow) const
Return number of elements.
Definition: CoinModel.hpp:523

CoinModel::firstInRow
CoinModelLink firstInRow(int whichRow) const
Returns first element in given row - index is -1 if none.

CoinModelHash2
For int,int hashing.
Definition: CoinModelUseful.hpp:253

CoinModel::columnUpperArray
double * columnUpperArray() const
Return columnUpper array.
Definition: CoinModel.hpp:693

CoinModel::setIsInteger
void setIsInteger(int whichColumn, const char *columnIsInteger)
Sets integer (if column does not exist then all columns up to this are defined with default values an...
Definition: CoinModel.hpp:332

CoinModel::setObjective
void setObjective(int whichColumn, const char *columnObjective)
Sets columnObjective (if column does not exist then all columns up to this are defined with default v...
Definition: CoinModel.hpp:327

CoinModel::setMoreInfo
void setMoreInfo(void *info)
Set pointer to more information.
Definition: CoinModel.hpp:727

CoinModel::numberElements_
int numberElements_
Current number of elements.
Definition: CoinModel.hpp:940

CoinModel::freeStringMemory
void freeStringMemory(CoinYacc &info)
Frees value memory.

CoinBaseModel::numberColumns_
int numberColumns_
Current number of columns.
Definition: CoinModel.hpp:95

CoinModel::operator()
void operator()(int i, int j, double value)
Sets value for row i and column j.
Definition: CoinModel.hpp:185

CoinModel::expandKnapsack
int expandKnapsack(int knapsackRow, int &numberOutput, double *buildObj, CoinBigIndex *buildStart, int *buildRow, double *buildElement, int reConstruct=-1) const
Expands out all possible combinations for a knapsack If buildObj NULL then just computes space needed...

CoinModelTriple
for linked lists
Definition: CoinModelUseful.hpp:107

CoinModel::columnIsIntegerAsString
const char * columnIsIntegerAsString(int whichColumn) const
Gets if integer (if column does not exist then false)
Definition: CoinModel.hpp:638

CoinModel::getElement
double getElement(int i, int j) const
Returns value for row i and column j.

CoinModel::maximumElements_
int maximumElements_
Maximum number of elements.
Definition: CoinModel.hpp:942

CoinModel::maximumRows_
int maximumRows_
Maximum number of rows.
Definition: CoinModel.hpp:936

CoinModel::createPackedMatrix
int createPackedMatrix(CoinPackedMatrix &matrix, const double *associated)
Creates a packed matrix - return number of errors.

CoinModel::packRows
int packRows()
Packs down all rows i.e.

CoinModel::rowName
const char * rowName(int whichRow) const
Gets name (if row does not exist then NULL)
Definition: CoinModel.hpp:531

CoinModel::next
CoinModelLink next(CoinModelLink &current) const
Returns next element in current row or column - index is -1 if none.

CoinModel::rowLowerAsString
const char * rowLowerAsString(int whichRow) const
Return number of elements.
Definition: CoinModel.hpp:602

CoinBaseModel::numberRows
int numberRows() const
Return number of rows.
Definition: CoinModel.hpp:39

CoinModel::deleteColumn
void deleteColumn(int whichColumn)
Deletes all entries in column and bounds and objective.

CoinModel::getColumnUpperAsString
const char * getColumnUpperAsString(int whichColumn) const
Gets columnUpper (if column does not exist then COIN_DBL_MAX)

CoinModel::deleteRow
void deleteRow(int whichRow)
Deletes all entries in row and bounds.

CoinModel::numberElements
CoinBigIndex numberElements() const
Return number of elements.
Definition: CoinModel.hpp:446

CoinModel::position
int position(int i, int j) const
Returns position in elements for row i column j.

CoinModel::pack
int pack()
Packs down all rows and columns.

CoinModel::replaceQuadraticRow
void replaceQuadraticRow(int rowNumber, const double *linear, const CoinPackedMatrix *quadraticPart)
Replaces a quadratic row.

CoinModel::countPlusMinusOne
int countPlusMinusOne(CoinBigIndex *startPositive, CoinBigIndex *startNegative, const double *associated)
Fills in startPositive and startNegative with counts for +-1 matrix.

CoinBaseModel::setProblemName
void setProblemName(const char *name)
Set problem name.

CoinModel::row
int row(const char *rowName) const
Row index from row name (-1 if no names or no match)