00001
00002
00003 #ifndef ClpModel_H
00004 #define ClpModel_H
00005
00006 #include "ClpConfig.h"
00007
00008 #include <iostream>
00009 #include <cassert>
00010 #include <cmath>
00011 #include <vector>
00012 #include <string>
00013
00014
00015
00016 #include "ClpPackedMatrix.hpp"
00017 #include "CoinMessageHandler.hpp"
00018 #include "CoinHelperFunctions.hpp"
00019 #include "ClpParameters.hpp"
00020 #include "ClpObjective.hpp"
00021 class ClpEventHandler;
00022
00023
00024 #ifndef COIN_DBL_MAX
00025 #define COIN_DBL_MAX DBL_MAX
00026 #endif
00027
00037 class CoinBuild;
00038 class CoinModel;
00039 class ClpModel {
00040
00041 public:
00042
00048
00049 ClpModel (bool emptyMessages=false );
00050
00055 ClpModel(const ClpModel & rhs, int scalingMode=-1);
00057 ClpModel & operator=(const ClpModel & rhs);
00062 ClpModel (const ClpModel * wholeModel,
00063 int numberRows, const int * whichRows,
00064 int numberColumns, const int * whichColumns,
00065 bool dropNames=true, bool dropIntegers=true);
00067 ~ClpModel ( );
00069
00083 void loadProblem ( const ClpMatrixBase& matrix,
00084 const double* collb, const double* colub,
00085 const double* obj,
00086 const double* rowlb, const double* rowub,
00087 const double * rowObjective=NULL);
00088 void loadProblem ( const CoinPackedMatrix& matrix,
00089 const double* collb, const double* colub,
00090 const double* obj,
00091 const double* rowlb, const double* rowub,
00092 const double * rowObjective=NULL);
00093
00096 void loadProblem ( const int numcols, const int numrows,
00097 const CoinBigIndex* start, const int* index,
00098 const double* value,
00099 const double* collb, const double* colub,
00100 const double* obj,
00101 const double* rowlb, const double* rowub,
00102 const double * rowObjective=NULL);
00108 int loadProblem ( CoinModel & modelObject,bool tryPlusMinusOne=false);
00110 void loadProblem ( const int numcols, const int numrows,
00111 const CoinBigIndex* start, const int* index,
00112 const double* value,const int * length,
00113 const double* collb, const double* colub,
00114 const double* obj,
00115 const double* rowlb, const double* rowub,
00116 const double * rowObjective=NULL);
00118 void loadQuadraticObjective(const int numberColumns,
00119 const CoinBigIndex * start,
00120 const int * column, const double * element);
00121 void loadQuadraticObjective ( const CoinPackedMatrix& matrix);
00123 void deleteQuadraticObjective();
00125 void setRowObjective(const double * rowObjective);
00127 int readMps(const char *filename,
00128 bool keepNames=false,
00129 bool ignoreErrors = false);
00131 int readGMPL(const char *filename,const char * dataName,
00132 bool keepNames=false);
00134 void copyInIntegerInformation(const char * information);
00136 void deleteIntegerInformation();
00138 void setContinuous(int index);
00140 void setInteger(int index);
00142 bool isInteger(int index) const;
00144 void resize (int newNumberRows, int newNumberColumns);
00146 void deleteRows(int number, const int * which);
00148 void addRow(int numberInRow, const int * columns,
00149 const double * elements, double rowLower=-COIN_DBL_MAX,
00150 double rowUpper=COIN_DBL_MAX);
00152 void addRows(int number, const double * rowLower,
00153 const double * rowUpper,
00154 const CoinBigIndex * rowStarts, const int * columns,
00155 const double * elements);
00157 void addRows(int number, const double * rowLower,
00158 const double * rowUpper,
00159 const CoinBigIndex * rowStarts, const int * rowLengths,
00160 const int * columns,
00161 const double * elements);
00162 #ifndef CLP_NO_VECTOR
00163 void addRows(int number, const double * rowLower,
00164 const double * rowUpper,
00165 const CoinPackedVectorBase * const * rows);
00166 #endif
00167
00172 int addRows(const CoinBuild & buildObject,bool tryPlusMinusOne=false,
00173 bool checkDuplicates=true);
00182 int addRows(CoinModel & modelObject,bool tryPlusMinusOne=false,
00183 bool checkDuplicates=true);
00184
00186 void deleteColumns(int number, const int * which);
00188 void addColumn(int numberInColumn,
00189 const int * rows,
00190 const double * elements,
00191 double columnLower=0.0,
00192 double columnUpper=COIN_DBL_MAX,
00193 double objective=0.0);
00195 void addColumns(int number, const double * columnLower,
00196 const double * columnUpper,
00197 const double * objective,
00198 const CoinBigIndex * columnStarts, const int * rows,
00199 const double * elements);
00200 void addColumns(int number, const double * columnLower,
00201 const double * columnUpper,
00202 const double * objective,
00203 const CoinBigIndex * columnStarts, const int * columnLengths,
00204 const int * rows,
00205 const double * elements);
00206 #ifndef CLP_NO_VECTOR
00207 void addColumns(int number, const double * columnLower,
00208 const double * columnUpper,
00209 const double * objective,
00210 const CoinPackedVectorBase * const * columns);
00211 #endif
00212
00217 int addColumns(const CoinBuild & buildObject,bool tryPlusMinusOne=false,
00218 bool checkDuplicates=true);
00226 int addColumns(CoinModel & modelObject,bool tryPlusMinusOne=false,
00227 bool checkDuplicates=true);
00229 inline void modifyCoefficient(int row, int column, double newElement,
00230 bool keepZero=false)
00231 {matrix_->modifyCoefficient(row,column,newElement,keepZero);}
00233 void chgRowLower(const double * rowLower);
00235 void chgRowUpper(const double * rowUpper);
00237 void chgColumnLower(const double * columnLower);
00239 void chgColumnUpper(const double * columnUpper);
00241 void chgObjCoefficients(const double * objIn);
00245 void borrowModel(ClpModel & otherModel);
00248 void returnModel(ClpModel & otherModel);
00249
00251 void createEmptyMatrix();
00259 int cleanMatrix(double threshold=1.0e-20);
00261 void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
00262 #ifndef CLP_NO_STD
00264 void dropNames();
00266 void copyNames(std::vector<std::string> & rowNames,
00267 std::vector<std::string> & columnNames);
00269 void copyRowNames(const std::vector<std::string> & rowNames,int first, int last);
00271 void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
00273 void copyRowNames(const char * const * rowNames,int first, int last);
00275 void copyColumnNames(const char * const * columnNames, int first, int last);
00277 void setRowName(int rowIndex, std::string & name) ;
00279 void setColumnName(int colIndex, std::string & name) ;
00280 #endif
00281
00288 int findNetwork(char * rotate, double fractionNeeded=0.75);
00291 CoinModel * createCoinModel() const;
00292
00305 int writeMps(const char *filename,
00306 int formatType=0,int numberAcross=2,
00307 double objSense=0.0) const ;
00309
00311
00312 inline int numberRows() const {
00313 return numberRows_;
00314 }
00315 inline int getNumRows() const {
00316 return numberRows_;
00317 }
00319 inline int getNumCols() const {
00320 return numberColumns_;
00321 }
00322 inline int numberColumns() const {
00323 return numberColumns_;
00324 }
00326 inline double primalTolerance() const {
00327 return dblParam_[ClpPrimalTolerance];
00328 }
00329 void setPrimalTolerance( double value) ;
00331 inline double dualTolerance() const { return dblParam_[ClpDualTolerance]; }
00332 void setDualTolerance( double value) ;
00334 inline double primalObjectiveLimit() const { return dblParam_[ClpPrimalObjectiveLimit];}
00335 void setPrimalObjectiveLimit(double value);
00337 inline double dualObjectiveLimit() const { return dblParam_[ClpDualObjectiveLimit];}
00338 void setDualObjectiveLimit(double value);
00340 inline double objectiveOffset() const { return dblParam_[ClpObjOffset];}
00341 void setObjectiveOffset(double value);
00343 inline double presolveTolerance() const
00344 { return dblParam_[ClpPresolveTolerance];}
00345 #ifndef CLP_NO_STD
00346 inline std::string problemName() const { return strParam_[ClpProbName]; }
00347 #endif
00349 inline int numberIterations() const { return numberIterations_; }
00350 inline int getIterationCount() const { return numberIterations_; }
00351 inline void setNumberIterations(int numberIterations)
00352 { numberIterations_ = numberIterations;}
00354 inline int solveType() const
00355 { return solveType_;}
00356 inline void setSolveType(int type)
00357 { solveType_=type;}
00359 inline int maximumIterations() const { return intParam_[ClpMaxNumIteration]; }
00360 void setMaximumIterations(int value);
00362 inline double maximumSeconds() const { return dblParam_[ClpMaxSeconds]; }
00363 void setMaximumSeconds(double value);
00365 bool hitMaximumIterations() const;
00375 inline int status() const { return problemStatus_; }
00376 inline int problemStatus() const { return problemStatus_; }
00378 inline void setProblemStatus(int problemStatus)
00379 { problemStatus_ = problemStatus;}
00394 inline int secondaryStatus() const { return secondaryStatus_; }
00395 inline void setSecondaryStatus(int status)
00396 { secondaryStatus_ = status;}
00398 inline bool isAbandoned() const { return problemStatus_==4; }
00400 inline bool isProvenOptimal() const { return problemStatus_==0; }
00402 inline bool isProvenPrimalInfeasible() const { return problemStatus_==1; }
00404 inline bool isProvenDualInfeasible() const { return problemStatus_==2; }
00406 bool isPrimalObjectiveLimitReached() const ;
00408 bool isDualObjectiveLimitReached() const ;
00410 inline bool isIterationLimitReached() const { return problemStatus_==3; }
00412 inline double optimizationDirection() const {
00413 return optimizationDirection_;
00414 }
00415 inline double getObjSense() const { return optimizationDirection_; }
00416 void setOptimizationDirection(double value);
00418 inline double * primalRowSolution() const { return rowActivity_; }
00419 inline const double * getRowActivity() const { return rowActivity_; }
00421 inline double * primalColumnSolution() const { return columnActivity_; }
00422 inline const double * getColSolution() const { return columnActivity_; }
00423 inline void setColSolution(const double * input)
00424 { memcpy(columnActivity_,input,numberColumns_*sizeof(double));}
00426 inline double * dualRowSolution() const { return dual_; }
00427 inline const double * getRowPrice() const { return dual_; }
00429 inline double * dualColumnSolution() const { return reducedCost_; }
00430 inline const double * getReducedCost() const { return reducedCost_; }
00432 inline double* rowLower() const { return rowLower_; }
00433 inline const double* getRowLower() const { return rowLower_; }
00435 inline double* rowUpper() const { return rowUpper_; }
00436 inline const double* getRowUpper() const { return rowUpper_; }
00437
00441 void setObjectiveCoefficient( int elementIndex, double elementValue );
00443 inline void setObjCoeff( int elementIndex, double elementValue )
00444 { setObjectiveCoefficient( elementIndex, elementValue);}
00445
00448 void setColumnLower( int elementIndex, double elementValue );
00449
00452 void setColumnUpper( int elementIndex, double elementValue );
00453
00455 void setColumnBounds( int elementIndex,
00456 double lower, double upper );
00457
00466 void setColumnSetBounds(const int* indexFirst,
00467 const int* indexLast,
00468 const double* boundList);
00469
00472 inline void setColLower( int elementIndex, double elementValue )
00473 { setColumnLower(elementIndex, elementValue);}
00476 inline void setColUpper( int elementIndex, double elementValue )
00477 { setColumnUpper(elementIndex, elementValue);}
00478
00480 inline void setColBounds( int elementIndex,
00481 double lower, double upper )
00482 { setColumnBounds(elementIndex, lower, upper);}
00483
00490 inline void setColSetBounds(const int* indexFirst,
00491 const int* indexLast,
00492 const double* boundList)
00493 { setColumnSetBounds(indexFirst, indexLast, boundList);}
00494
00497 void setRowLower( int elementIndex, double elementValue );
00498
00501 void setRowUpper( int elementIndex, double elementValue ) ;
00502
00504 void setRowBounds( int elementIndex,
00505 double lower, double upper ) ;
00506
00513 void setRowSetBounds(const int* indexFirst,
00514 const int* indexLast,
00515 const double* boundList);
00516
00518
00519 inline const double * rowScale() const {return rowScale_;}
00520 inline const double * columnScale() const {return columnScale_;}
00521 inline const double * inverseRowScale() const {return inverseRowScale_;}
00522 inline const double * inverseColumnScale() const {return inverseColumnScale_;}
00523 inline double * mutableRowScale() const {return rowScale_;}
00524 inline double * mutableColumnScale() const {return columnScale_;}
00525 inline double * mutableInverseRowScale() const {return inverseRowScale_;}
00526 inline double * mutableInverseColumnScale() const {return inverseColumnScale_;}
00527 void setRowScale(double * scale) ;
00528 void setColumnScale(double * scale);
00530 inline double objectiveScale() const
00531 { return objectiveScale_;}
00532 inline void setObjectiveScale(double value)
00533 { objectiveScale_ = value;}
00535 inline double rhsScale() const
00536 { return rhsScale_;}
00537 inline void setRhsScale(double value)
00538 { rhsScale_ = value;}
00540 void scaling(int mode=1);
00543 void unscale();
00545 inline int scalingFlag() const {return scalingFlag_;}
00547 inline double * objective() const
00548 {
00549 if (objective_) {
00550 double offset;
00551 return objective_->gradient(NULL,NULL,offset,false);
00552 } else {
00553 return NULL;
00554 }
00555 }
00556 inline double * objective(const double * solution, double & offset,bool refresh=true) const
00557 {
00558 offset=0.0;
00559 if (objective_) {
00560 return objective_->gradient(NULL,solution,offset,refresh);
00561 } else {
00562 return NULL;
00563 }
00564 }
00565 inline const double * getObjCoefficients() const
00566 {
00567 if (objective_) {
00568 double offset;
00569 return objective_->gradient(NULL,NULL,offset,false);
00570 } else {
00571 return NULL;
00572 }
00573 }
00575 inline double * rowObjective() const { return rowObjective_; }
00576 inline const double * getRowObjCoefficients() const {
00577 return rowObjective_;
00578 }
00580 inline double * columnLower() const { return columnLower_; }
00581 inline const double * getColLower() const { return columnLower_; }
00583 inline double * columnUpper() const { return columnUpper_; }
00584 inline const double * getColUpper() const { return columnUpper_; }
00586 inline CoinPackedMatrix * matrix() const {
00587 if ( matrix_ == NULL ) return NULL;
00588 else return matrix_->getPackedMatrix();
00589 }
00591 inline int getNumElements() const
00592 { return matrix_->getNumElements();}
00595 inline double getSmallElementValue() const
00596 { return smallElement_;}
00597 inline void setSmallElementValue(double value)
00598 { smallElement_=value;}
00600 inline ClpMatrixBase * rowCopy() const { return rowCopy_; }
00602 void setNewRowCopy(ClpMatrixBase * newCopy);
00604 inline ClpMatrixBase * clpMatrix() const { return matrix_; }
00606 inline ClpPackedMatrix * clpScaledMatrix() const { return scaledMatrix_; }
00608 inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix)
00609 { delete scaledMatrix_; scaledMatrix_=scaledMatrix; }
00615 void replaceMatrix(ClpMatrixBase * matrix,bool deleteCurrent=false);
00621 inline void replaceMatrix(CoinPackedMatrix * matrix,
00622 bool deleteCurrent=false)
00623 { replaceMatrix(new ClpPackedMatrix(matrix),deleteCurrent);}
00625 inline double objectiveValue() const {
00626 return objectiveValue_*optimizationDirection_ - dblParam_[ClpObjOffset];
00627 }
00628 inline void setObjectiveValue(double value) {
00629 objectiveValue_ = (value+ dblParam_[ClpObjOffset])/optimizationDirection_;
00630 }
00631 inline double getObjValue() const {
00632 return objectiveValue_*optimizationDirection_ - dblParam_[ClpObjOffset];
00633 }
00635 inline char * integerInformation() const { return integerType_; }
00638 double * infeasibilityRay() const;
00639 double * unboundedRay() const;
00641 inline bool statusExists() const
00642 { return (status_!=NULL);}
00644 inline unsigned char * statusArray() const
00645 { return status_;}
00648 unsigned char * statusCopy() const;
00650 void copyinStatus(const unsigned char * statusArray);
00651
00653 inline void setUserPointer (void * pointer)
00654 { userPointer_=pointer;}
00655 inline void * getUserPointer () const
00656 { return userPointer_;}
00658 inline void setTrustedUserPointer (ClpTrustedData * pointer)
00659 { trustedUserPointer_=pointer;}
00660 inline ClpTrustedData * getTrustedUserPointer () const
00661 { return trustedUserPointer_;}
00663 inline int whatsChanged() const
00664 { return whatsChanged_;}
00665 inline void setWhatsChanged(int value)
00666 { whatsChanged_ = value;}
00668 inline int numberThreads() const
00669 { return numberThreads_;}
00670 inline void setNumberThreads(int value)
00671 { numberThreads_ = value;}
00673
00675
00676 void passInMessageHandler(CoinMessageHandler * handler);
00678 CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
00679 bool & oldDefault);
00681 void popMessageHandler(CoinMessageHandler * oldHandler,bool oldDefault);
00683 void newLanguage(CoinMessages::Language language);
00684 inline void setLanguage(CoinMessages::Language language) { newLanguage(language); }
00686 inline CoinMessageHandler * messageHandler() const { return handler_; }
00688 inline CoinMessages messages() const { return messages_; }
00690 inline CoinMessages * messagesPointer() { return & messages_; }
00692 inline CoinMessages coinMessages() const { return coinMessages_; }
00694 inline CoinMessages * coinMessagesPointer() { return & coinMessages_; }
00703 inline void setLogLevel(int value) { handler_->setLogLevel(value); }
00704 inline int logLevel() const { return handler_->logLevel(); }
00706 inline bool defaultHandler() const
00707 { return defaultHandler_;}
00709 void passInEventHandler(const ClpEventHandler * eventHandler);
00711 inline ClpEventHandler * eventHandler() const
00712 { return eventHandler_;}
00714 inline CoinThreadRandom * randomNumberGenerator()
00715 { return &randomNumberGenerator_;}
00717 inline CoinThreadRandom & mutableRandomNumberGenerator()
00718 { return randomNumberGenerator_;}
00720 inline void setRandomSeed(int value)
00721 { randomNumberGenerator_.setSeed(value);}
00723 inline int lengthNames() const { return lengthNames_; }
00724 #ifndef CLP_NO_STD
00726 inline void setLengthNames(int value) { lengthNames_=value; }
00728 inline const std::vector<std::string> * rowNames() const {
00729 return &rowNames_;
00730 }
00731 inline const std::string& rowName(int iRow) const {
00732 return rowNames_[iRow];
00733 }
00735 std::string getRowName(int iRow) const;
00737 inline const std::vector<std::string> * columnNames() const {
00738 return &columnNames_;
00739 }
00740 inline const std::string& columnName(int iColumn) const {
00741 return columnNames_[iColumn];
00742 }
00744 std::string getColumnName(int iColumn) const;
00745 #endif
00747 inline ClpObjective * objectiveAsObject() const
00748 { return objective_;}
00749 void setObjective(ClpObjective * objective);
00750 inline void setObjectivePointer(ClpObjective * objective)
00751 { objective_ = objective;}
00754 int emptyProblem(int * infeasNumber=NULL, double * infeasSum=NULL,bool printMessage=true);
00755
00757
00766 void times(double scalar,
00767 const double * x, double * y) const;
00771 void transposeTimes(double scalar,
00772 const double * x, double * y) const ;
00774
00775
00776
00794
00795 bool setIntParam(ClpIntParam key, int value) ;
00797 bool setDblParam(ClpDblParam key, double value) ;
00798 #ifndef CLP_NO_STD
00800 bool setStrParam(ClpStrParam key, const std::string & value);
00801 #endif
00802
00803 inline bool getIntParam(ClpIntParam key, int& value) const {
00804 if (key<ClpLastIntParam) {
00805 value = intParam_[key];
00806 return true;
00807 } else {
00808 return false;
00809 }
00810 }
00811
00812 inline bool getDblParam(ClpDblParam key, double& value) const {
00813 if (key<ClpLastDblParam) {
00814 value = dblParam_[key];
00815 return true;
00816 } else {
00817 return false;
00818 }
00819 }
00820 #ifndef CLP_NO_STD
00821
00822 inline bool getStrParam(ClpStrParam key, std::string& value) const {
00823 if (key<ClpLastStrParam) {
00824 value = strParam_[key];
00825 return true;
00826 } else {
00827 return false;
00828 }
00829 }
00830 #endif
00832 void generateCpp( FILE * fp);
00833
00865 #define COIN_CBC_USING_CLP 0x01000000
00866 inline unsigned int specialOptions() const
00867 { return specialOptions_;}
00868 void setSpecialOptions(unsigned int value);
00869 inline bool inCbcBranchAndBound() const
00870 { return (specialOptions_&COIN_CBC_USING_CLP)!=0;}
00872
00875 protected:
00877 void gutsOfDelete(int type);
00881 void gutsOfCopy(const ClpModel & rhs, int trueCopy=1);
00883 void getRowBound(int iRow, double& lower, double& upper) const;
00885 void gutsOfLoadModel ( int numberRows, int numberColumns,
00886 const double* collb, const double* colub,
00887 const double* obj,
00888 const double* rowlb, const double* rowub,
00889 const double * rowObjective=NULL);
00891 void gutsOfScaling();
00893 inline double rawObjectiveValue() const {
00894 return objectiveValue_;
00895 }
00897 inline bool permanentArrays() const
00898 { return (specialOptions_&65536)!=0;}
00900 void startPermanentArrays();
00902 void stopPermanentArrays();
00904 const char * const * rowNamesAsChar() const;
00906 const char * const * columnNamesAsChar() const;
00908 void deleteNamesAsChar(const char * const * names,int number) const;
00910 void onStopped();
00912
00913
00915 protected:
00916
00919
00920 double optimizationDirection_;
00922 double dblParam_[ClpLastDblParam];
00924 double objectiveValue_;
00926 double smallElement_;
00928 double objectiveScale_;
00930 double rhsScale_;
00932 int numberRows_;
00934 int numberColumns_;
00936 double * rowActivity_;
00938 double * columnActivity_;
00940 double * dual_;
00942 double * reducedCost_;
00944 double* rowLower_;
00946 double* rowUpper_;
00948 ClpObjective * objective_;
00950 double * rowObjective_;
00952 double * columnLower_;
00954 double * columnUpper_;
00956 ClpMatrixBase * matrix_;
00958 ClpMatrixBase * rowCopy_;
00960 ClpPackedMatrix * scaledMatrix_;
00962 double * ray_;
00964 double * rowScale_;
00966 double * columnScale_;
00968 double * inverseRowScale_;
00970 double * inverseColumnScale_;
00972 int scalingFlag_;
00980 unsigned char * status_;
00982 char * integerType_;
00984 void * userPointer_;
00986 ClpTrustedData * trustedUserPointer_;
00988 int intParam_[ClpLastIntParam];
00990 int numberIterations_;
00992 int solveType_;
01009 unsigned int whatsChanged_;
01011 int problemStatus_;
01013 int secondaryStatus_;
01015 int lengthNames_;
01017 int numberThreads_;
01021 unsigned int specialOptions_;
01023 CoinMessageHandler * handler_;
01025 bool defaultHandler_;
01027 CoinThreadRandom randomNumberGenerator_;
01029 ClpEventHandler * eventHandler_;
01030 #ifndef CLP_NO_STD
01032 std::vector<std::string> rowNames_;
01034 std::vector<std::string> columnNames_;
01035 #endif
01037 CoinMessages messages_;
01039 CoinMessages coinMessages_;
01041 int maximumColumns_;
01043 int maximumRows_;
01045 int maximumInternalColumns_;
01047 int maximumInternalRows_;
01049 CoinPackedMatrix baseMatrix_;
01051 CoinPackedMatrix baseRowCopy_;
01053 double * savedRowScale_;
01055 double * savedColumnScale_;
01056 #ifndef CLP_NO_STD
01058 std::string strParam_[ClpLastStrParam];
01059 #endif
01060
01061 };
01064 class ClpDataSave {
01065
01066 public:
01070
01071 ClpDataSave ( );
01072
01074 ClpDataSave(const ClpDataSave &);
01076 ClpDataSave & operator=(const ClpDataSave & rhs);
01078 ~ClpDataSave ( );
01079
01081
01083 public:
01084
01087 double dualBound_;
01088 double infeasibilityCost_;
01089 double pivotTolerance_;
01090 double zeroFactorizationTolerance_;
01091 double zeroSimplexTolerance_;
01092 double acceptablePivot_;
01093 double objectiveScale_;
01094 int sparseThreshold_;
01095 int perturbation_;
01096 int forceFactorization_;
01097 int scalingFlag_;
01098 unsigned int specialOptions_;
01100 };
01101
01102 #endif