00001
00002
00003
00004 #ifndef ClpModel_H
00005 #define ClpModel_H
00006
00007 #include "ClpConfig.h"
00008
00009 #include <iostream>
00010 #include <cassert>
00011 #include <cmath>
00012 #include <vector>
00013 #include <string>
00014
00015
00016
00017 #include "ClpPackedMatrix.hpp"
00018 #include "CoinMessageHandler.hpp"
00019 #include "CoinHelperFunctions.hpp"
00020 #include "CoinFinite.hpp"
00021 #include "ClpParameters.hpp"
00022 #include "ClpObjective.hpp"
00023 class ClpEventHandler;
00033 class CoinBuild;
00034 class CoinModel;
00035 class ClpModel {
00036
00037 public:
00038
00044
00045 ClpModel (bool emptyMessages=false );
00046
00051 ClpModel(const ClpModel & rhs, int scalingMode=-1);
00053 ClpModel & operator=(const ClpModel & rhs);
00058 ClpModel (const ClpModel * wholeModel,
00059 int numberRows, const int * whichRows,
00060 int numberColumns, const int * whichColumns,
00061 bool dropNames=true, bool dropIntegers=true);
00063 ~ClpModel ( );
00065
00079 void loadProblem ( const ClpMatrixBase& matrix,
00080 const double* collb, const double* colub,
00081 const double* obj,
00082 const double* rowlb, const double* rowub,
00083 const double * rowObjective=NULL);
00084 void loadProblem ( const CoinPackedMatrix& matrix,
00085 const double* collb, const double* colub,
00086 const double* obj,
00087 const double* rowlb, const double* rowub,
00088 const double * rowObjective=NULL);
00089
00092 void loadProblem ( const int numcols, const int numrows,
00093 const CoinBigIndex* start, const int* index,
00094 const double* value,
00095 const double* collb, const double* colub,
00096 const double* obj,
00097 const double* rowlb, const double* rowub,
00098 const double * rowObjective=NULL);
00104 int loadProblem ( CoinModel & modelObject,bool tryPlusMinusOne=false);
00106 void loadProblem ( const int numcols, const int numrows,
00107 const CoinBigIndex* start, const int* index,
00108 const double* value,const int * length,
00109 const double* collb, const double* colub,
00110 const double* obj,
00111 const double* rowlb, const double* rowub,
00112 const double * rowObjective=NULL);
00114 void loadQuadraticObjective(const int numberColumns,
00115 const CoinBigIndex * start,
00116 const int * column, const double * element);
00117 void loadQuadraticObjective ( const CoinPackedMatrix& matrix);
00119 void deleteQuadraticObjective();
00121 void setRowObjective(const double * rowObjective);
00123 int readMps(const char *filename,
00124 bool keepNames=false,
00125 bool ignoreErrors = false);
00127 int readGMPL(const char *filename,const char * dataName,
00128 bool keepNames=false);
00130 void copyInIntegerInformation(const char * information);
00132 void deleteIntegerInformation();
00134 void setContinuous(int index);
00136 void setInteger(int index);
00138 bool isInteger(int index) const;
00140 void resize (int newNumberRows, int newNumberColumns);
00142 void deleteRows(int number, const int * which);
00144 void addRow(int numberInRow, const int * columns,
00145 const double * elements, double rowLower=-COIN_DBL_MAX,
00146 double rowUpper=COIN_DBL_MAX);
00148 void addRows(int number, const double * rowLower,
00149 const double * rowUpper,
00150 const CoinBigIndex * rowStarts, const int * columns,
00151 const double * elements);
00153 void addRows(int number, const double * rowLower,
00154 const double * rowUpper,
00155 const CoinBigIndex * rowStarts, const int * rowLengths,
00156 const int * columns,
00157 const double * elements);
00158 #ifndef CLP_NO_VECTOR
00159 void addRows(int number, const double * rowLower,
00160 const double * rowUpper,
00161 const CoinPackedVectorBase * const * rows);
00162 #endif
00163
00168 int addRows(const CoinBuild & buildObject,bool tryPlusMinusOne=false,
00169 bool checkDuplicates=true);
00178 int addRows(CoinModel & modelObject,bool tryPlusMinusOne=false,
00179 bool checkDuplicates=true);
00180
00182 void deleteColumns(int number, const int * which);
00184 void addColumn(int numberInColumn,
00185 const int * rows,
00186 const double * elements,
00187 double columnLower=0.0,
00188 double columnUpper=COIN_DBL_MAX,
00189 double objective=0.0);
00191 void addColumns(int number, const double * columnLower,
00192 const double * columnUpper,
00193 const double * objective,
00194 const CoinBigIndex * columnStarts, const int * rows,
00195 const double * elements);
00196 void addColumns(int number, const double * columnLower,
00197 const double * columnUpper,
00198 const double * objective,
00199 const CoinBigIndex * columnStarts, const int * columnLengths,
00200 const int * rows,
00201 const double * elements);
00202 #ifndef CLP_NO_VECTOR
00203 void addColumns(int number, const double * columnLower,
00204 const double * columnUpper,
00205 const double * objective,
00206 const CoinPackedVectorBase * const * columns);
00207 #endif
00208
00213 int addColumns(const CoinBuild & buildObject,bool tryPlusMinusOne=false,
00214 bool checkDuplicates=true);
00222 int addColumns(CoinModel & modelObject,bool tryPlusMinusOne=false,
00223 bool checkDuplicates=true);
00225 inline void modifyCoefficient(int row, int column, double newElement,
00226 bool keepZero=false)
00227 {matrix_->modifyCoefficient(row,column,newElement,keepZero);}
00229 void chgRowLower(const double * rowLower);
00231 void chgRowUpper(const double * rowUpper);
00233 void chgColumnLower(const double * columnLower);
00235 void chgColumnUpper(const double * columnUpper);
00237 void chgObjCoefficients(const double * objIn);
00241 void borrowModel(ClpModel & otherModel);
00244 void returnModel(ClpModel & otherModel);
00245
00247 void createEmptyMatrix();
00255 int cleanMatrix(double threshold=1.0e-20);
00257 void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
00258 #ifndef CLP_NO_STD
00259
00260 void dropNames();
00262 void copyNames(std::vector<std::string> & rowNames,
00263 std::vector<std::string> & columnNames);
00265 void copyRowNames(const std::vector<std::string> & rowNames,int first, int last);
00267 void copyColumnNames(const std::vector<std::string> & columnNames, int first, int last);
00269 void copyRowNames(const char * const * rowNames,int first, int last);
00271 void copyColumnNames(const char * const * columnNames, int first, int last);
00273 void setRowName(int rowIndex, std::string & name) ;
00275 void setColumnName(int colIndex, std::string & name) ;
00276 #endif
00277
00284 int findNetwork(char * rotate, double fractionNeeded=0.75);
00287 CoinModel * createCoinModel() const;
00288
00301 int writeMps(const char *filename,
00302 int formatType=0,int numberAcross=2,
00303 double objSense=0.0) const ;
00305
00307
00308 inline int numberRows() const {
00309 return numberRows_;
00310 }
00311 inline int getNumRows() const {
00312 return numberRows_;
00313 }
00315 inline int getNumCols() const {
00316 return numberColumns_;
00317 }
00318 inline int numberColumns() const {
00319 return numberColumns_;
00320 }
00322 inline double primalTolerance() const {
00323 return dblParam_[ClpPrimalTolerance];
00324 }
00325 void setPrimalTolerance( double value) ;
00327 inline double dualTolerance() const { return dblParam_[ClpDualTolerance]; }
00328 void setDualTolerance( double value) ;
00330 inline double primalObjectiveLimit() const { return dblParam_[ClpPrimalObjectiveLimit];}
00331 void setPrimalObjectiveLimit(double value);
00333 inline double dualObjectiveLimit() const { return dblParam_[ClpDualObjectiveLimit];}
00334 void setDualObjectiveLimit(double value);
00336 inline double objectiveOffset() const { return dblParam_[ClpObjOffset];}
00337 void setObjectiveOffset(double value);
00339 inline double presolveTolerance() const
00340 { return dblParam_[ClpPresolveTolerance];}
00341 #ifndef CLP_NO_STD
00342 inline std::string problemName() const { return strParam_[ClpProbName]; }
00343 #endif
00344
00345 inline int numberIterations() const { return numberIterations_; }
00346 inline int getIterationCount() const { return numberIterations_; }
00347 inline void setNumberIterations(int numberIterationsNew)
00348 { numberIterations_ = numberIterationsNew;}
00350 inline int solveType() const
00351 { return solveType_;}
00352 inline void setSolveType(int type)
00353 { solveType_=type;}
00355 inline int maximumIterations() const { return intParam_[ClpMaxNumIteration]; }
00356 void setMaximumIterations(int value);
00358 inline double maximumSeconds() const { return dblParam_[ClpMaxSeconds]; }
00359 void setMaximumSeconds(double value);
00361 bool hitMaximumIterations() const;
00371 inline int status() const { return problemStatus_; }
00372 inline int problemStatus() const { return problemStatus_; }
00374 inline void setProblemStatus(int problemStatusNew)
00375 { problemStatus_ = problemStatusNew;}
00390 inline int secondaryStatus() const { return secondaryStatus_; }
00391 inline void setSecondaryStatus(int newstatus)
00392 { secondaryStatus_ = newstatus;}
00394 inline bool isAbandoned() const { return problemStatus_==4; }
00396 inline bool isProvenOptimal() const { return problemStatus_==0; }
00398 inline bool isProvenPrimalInfeasible() const { return problemStatus_==1; }
00400 inline bool isProvenDualInfeasible() const { return problemStatus_==2; }
00402 bool isPrimalObjectiveLimitReached() const ;
00404 bool isDualObjectiveLimitReached() const ;
00406 inline bool isIterationLimitReached() const { return problemStatus_==3; }
00408 inline double optimizationDirection() const {
00409 return optimizationDirection_;
00410 }
00411 inline double getObjSense() const { return optimizationDirection_; }
00412 void setOptimizationDirection(double value);
00414 inline double * primalRowSolution() const { return rowActivity_; }
00415 inline const double * getRowActivity() const { return rowActivity_; }
00417 inline double * primalColumnSolution() const { return columnActivity_; }
00418 inline const double * getColSolution() const { return columnActivity_; }
00419 inline void setColSolution(const double * input)
00420 { memcpy(columnActivity_,input,numberColumns_*sizeof(double));}
00422 inline double * dualRowSolution() const { return dual_; }
00423 inline const double * getRowPrice() const { return dual_; }
00425 inline double * dualColumnSolution() const { return reducedCost_; }
00426 inline const double * getReducedCost() const { return reducedCost_; }
00428 inline double* rowLower() const { return rowLower_; }
00429 inline const double* getRowLower() const { return rowLower_; }
00431 inline double* rowUpper() const { return rowUpper_; }
00432 inline const double* getRowUpper() const { return rowUpper_; }
00433
00437 void setObjectiveCoefficient( int elementIndex, double elementValue );
00439 inline void setObjCoeff( int elementIndex, double elementValue )
00440 { setObjectiveCoefficient( elementIndex, elementValue);}
00441
00444 void setColumnLower( int elementIndex, double elementValue );
00445
00448 void setColumnUpper( int elementIndex, double elementValue );
00449
00451 void setColumnBounds( int elementIndex,
00452 double lower, double upper );
00453
00462 void setColumnSetBounds(const int* indexFirst,
00463 const int* indexLast,
00464 const double* boundList);
00465
00468 inline void setColLower( int elementIndex, double elementValue )
00469 { setColumnLower(elementIndex, elementValue);}
00472 inline void setColUpper( int elementIndex, double elementValue )
00473 { setColumnUpper(elementIndex, elementValue);}
00474
00476 inline void setColBounds( int elementIndex,
00477 double lower, double upper )
00478 { setColumnBounds(elementIndex, lower, upper);}
00479
00486 inline void setColSetBounds(const int* indexFirst,
00487 const int* indexLast,
00488 const double* boundList)
00489 { setColumnSetBounds(indexFirst, indexLast, boundList);}
00490
00493 void setRowLower( int elementIndex, double elementValue );
00494
00497 void setRowUpper( int elementIndex, double elementValue ) ;
00498
00500 void setRowBounds( int elementIndex,
00501 double lower, double upper ) ;
00502
00509 void setRowSetBounds(const int* indexFirst,
00510 const int* indexLast,
00511 const double* boundList);
00512
00514
00515 inline const double * rowScale() const {return rowScale_;}
00516 inline const double * columnScale() const {return columnScale_;}
00517 inline const double * inverseRowScale() const {return inverseRowScale_;}
00518 inline const double * inverseColumnScale() const {return inverseColumnScale_;}
00519 inline double * mutableRowScale() const {return rowScale_;}
00520 inline double * mutableColumnScale() const {return columnScale_;}
00521 inline double * mutableInverseRowScale() const {return inverseRowScale_;}
00522 inline double * mutableInverseColumnScale() const {return inverseColumnScale_;}
00523 void setRowScale(double * scale) ;
00524 void setColumnScale(double * scale);
00526 inline double objectiveScale() const
00527 { return objectiveScale_;}
00528 inline void setObjectiveScale(double value)
00529 { objectiveScale_ = value;}
00531 inline double rhsScale() const
00532 { return rhsScale_;}
00533 inline void setRhsScale(double value)
00534 { rhsScale_ = value;}
00536 void scaling(int mode=1);
00539 void unscale();
00541 inline int scalingFlag() const {return scalingFlag_;}
00543 inline double * objective() const
00544 {
00545 if (objective_) {
00546 double offset;
00547 return objective_->gradient(NULL,NULL,offset,false);
00548 } else {
00549 return NULL;
00550 }
00551 }
00552 inline double * objective(const double * solution, double & offset,bool refresh=true) const
00553 {
00554 offset=0.0;
00555 if (objective_) {
00556 return objective_->gradient(NULL,solution,offset,refresh);
00557 } else {
00558 return NULL;
00559 }
00560 }
00561 inline const double * getObjCoefficients() const
00562 {
00563 if (objective_) {
00564 double offset;
00565 return objective_->gradient(NULL,NULL,offset,false);
00566 } else {
00567 return NULL;
00568 }
00569 }
00571 inline double * rowObjective() const { return rowObjective_; }
00572 inline const double * getRowObjCoefficients() const {
00573 return rowObjective_;
00574 }
00576 inline double * columnLower() const { return columnLower_; }
00577 inline const double * getColLower() const { return columnLower_; }
00579 inline double * columnUpper() const { return columnUpper_; }
00580 inline const double * getColUpper() const { return columnUpper_; }
00582 inline CoinPackedMatrix * matrix() const {
00583 if ( matrix_ == NULL ) return NULL;
00584 else return matrix_->getPackedMatrix();
00585 }
00587 inline int getNumElements() const
00588 { return matrix_->getNumElements();}
00591 inline double getSmallElementValue() const
00592 { return smallElement_;}
00593 inline void setSmallElementValue(double value)
00594 { smallElement_=value;}
00596 inline ClpMatrixBase * rowCopy() const { return rowCopy_; }
00598 void setNewRowCopy(ClpMatrixBase * newCopy);
00600 inline ClpMatrixBase * clpMatrix() const { return matrix_; }
00602 inline ClpPackedMatrix * clpScaledMatrix() const { return scaledMatrix_; }
00604 inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix)
00605 { delete scaledMatrix_; scaledMatrix_=scaledMatrix; }
00611 void replaceMatrix(ClpMatrixBase * matrix,bool deleteCurrent=false);
00617 inline void replaceMatrix(CoinPackedMatrix * newmatrix,
00618 bool deleteCurrent=false)
00619 { replaceMatrix(new ClpPackedMatrix(newmatrix),deleteCurrent);}
00621 inline double objectiveValue() const {
00622 return objectiveValue_*optimizationDirection_ - dblParam_[ClpObjOffset];
00623 }
00624 inline void setObjectiveValue(double value) {
00625 objectiveValue_ = (value+ dblParam_[ClpObjOffset])/optimizationDirection_;
00626 }
00627 inline double getObjValue() const {
00628 return objectiveValue_*optimizationDirection_ - dblParam_[ClpObjOffset];
00629 }
00631 inline char * integerInformation() const { return integerType_; }
00634 double * infeasibilityRay() const;
00635 double * unboundedRay() const;
00637 inline bool statusExists() const
00638 { return (status_!=NULL);}
00640 inline unsigned char * statusArray() const
00641 { return status_;}
00644 unsigned char * statusCopy() const;
00646 void copyinStatus(const unsigned char * statusArray);
00647
00649 inline void setUserPointer (void * pointer)
00650 { userPointer_=pointer;}
00651 inline void * getUserPointer () const
00652 { return userPointer_;}
00654 inline void setTrustedUserPointer (ClpTrustedData * pointer)
00655 { trustedUserPointer_=pointer;}
00656 inline ClpTrustedData * getTrustedUserPointer () const
00657 { return trustedUserPointer_;}
00659 inline int whatsChanged() const
00660 { return whatsChanged_;}
00661 inline void setWhatsChanged(int value)
00662 { whatsChanged_ = value;}
00664 inline int numberThreads() const
00665 { return numberThreads_;}
00666 inline void setNumberThreads(int value)
00667 { numberThreads_ = value;}
00669
00671
00672 void passInMessageHandler(CoinMessageHandler * handler);
00674 CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
00675 bool & oldDefault);
00677 void popMessageHandler(CoinMessageHandler * oldHandler,bool oldDefault);
00679 void newLanguage(CoinMessages::Language language);
00680 inline void setLanguage(CoinMessages::Language language) { newLanguage(language); }
00682 inline CoinMessageHandler * messageHandler() const { return handler_; }
00684 inline CoinMessages messages() const { return messages_; }
00686 inline CoinMessages * messagesPointer() { return & messages_; }
00688 inline CoinMessages coinMessages() const { return coinMessages_; }
00690 inline CoinMessages * coinMessagesPointer() { return & coinMessages_; }
00699 inline void setLogLevel(int value) { handler_->setLogLevel(value); }
00700 inline int logLevel() const { return handler_->logLevel(); }
00702 inline bool defaultHandler() const
00703 { return defaultHandler_;}
00705 void passInEventHandler(const ClpEventHandler * eventHandler);
00707 inline ClpEventHandler * eventHandler() const
00708 { return eventHandler_;}
00710 inline CoinThreadRandom * randomNumberGenerator()
00711 { return &randomNumberGenerator_;}
00713 inline CoinThreadRandom & mutableRandomNumberGenerator()
00714 { return randomNumberGenerator_;}
00716 inline void setRandomSeed(int value)
00717 { randomNumberGenerator_.setSeed(value);}
00719 inline int lengthNames() const { return lengthNames_; }
00720 #ifndef CLP_NO_STD
00721
00722 inline void setLengthNames(int value) { lengthNames_=value; }
00724 inline const std::vector<std::string> * rowNames() const {
00725 return &rowNames_;
00726 }
00727 inline const std::string& rowName(int iRow) const {
00728 return rowNames_[iRow];
00729 }
00731 std::string getRowName(int iRow) const;
00733 inline const std::vector<std::string> * columnNames() const {
00734 return &columnNames_;
00735 }
00736 inline const std::string& columnName(int iColumn) const {
00737 return columnNames_[iColumn];
00738 }
00740 std::string getColumnName(int iColumn) const;
00741 #endif
00742
00743 inline ClpObjective * objectiveAsObject() const
00744 { return objective_;}
00745 void setObjective(ClpObjective * objective);
00746 inline void setObjectivePointer(ClpObjective * newobjective)
00747 { objective_ = newobjective;}
00750 int emptyProblem(int * infeasNumber=NULL, double * infeasSum=NULL,bool printMessage=true);
00751
00753
00762 void times(double scalar,
00763 const double * x, double * y) const;
00767 void transposeTimes(double scalar,
00768 const double * x, double * y) const ;
00770
00771
00772
00790
00791 bool setIntParam(ClpIntParam key, int value) ;
00793 bool setDblParam(ClpDblParam key, double value) ;
00794 #ifndef CLP_NO_STD
00795
00796 bool setStrParam(ClpStrParam key, const std::string & value);
00797 #endif
00798
00799 inline bool getIntParam(ClpIntParam key, int& value) const {
00800 if (key<ClpLastIntParam) {
00801 value = intParam_[key];
00802 return true;
00803 } else {
00804 return false;
00805 }
00806 }
00807
00808 inline bool getDblParam(ClpDblParam key, double& value) const {
00809 if (key<ClpLastDblParam) {
00810 value = dblParam_[key];
00811 return true;
00812 } else {
00813 return false;
00814 }
00815 }
00816 #ifndef CLP_NO_STD
00817
00818 inline bool getStrParam(ClpStrParam key, std::string& value) const {
00819 if (key<ClpLastStrParam) {
00820 value = strParam_[key];
00821 return true;
00822 } else {
00823 return false;
00824 }
00825 }
00826 #endif
00827
00828 void generateCpp( FILE * fp);
00861 inline unsigned int specialOptions() const
00862 { return specialOptions_;}
00863 void setSpecialOptions(unsigned int value);
00864 #define COIN_CBC_USING_CLP 0x01000000
00865 inline bool inCbcBranchAndBound() const
00866 { return (specialOptions_&COIN_CBC_USING_CLP)!=0;}
00868
00871 protected:
00873 void gutsOfDelete(int type);
00877 void gutsOfCopy(const ClpModel & rhs, int trueCopy=1);
00879 void getRowBound(int iRow, double& lower, double& upper) const;
00881 void gutsOfLoadModel ( int numberRows, int numberColumns,
00882 const double* collb, const double* colub,
00883 const double* obj,
00884 const double* rowlb, const double* rowub,
00885 const double * rowObjective=NULL);
00887 void gutsOfScaling();
00889 inline double rawObjectiveValue() const {
00890 return objectiveValue_;
00891 }
00893 inline bool permanentArrays() const
00894 { return (specialOptions_&65536)!=0;}
00896 void startPermanentArrays();
00898 void stopPermanentArrays();
00900 const char * const * rowNamesAsChar() const;
00902 const char * const * columnNamesAsChar() const;
00904 void deleteNamesAsChar(const char * const * names,int number) const;
00906 void onStopped();
00908
00909
00911 protected:
00912
00915
00916 double optimizationDirection_;
00918 double dblParam_[ClpLastDblParam];
00920 double objectiveValue_;
00922 double smallElement_;
00924 double objectiveScale_;
00926 double rhsScale_;
00928 int numberRows_;
00930 int numberColumns_;
00932 double * rowActivity_;
00934 double * columnActivity_;
00936 double * dual_;
00938 double * reducedCost_;
00940 double* rowLower_;
00942 double* rowUpper_;
00944 ClpObjective * objective_;
00946 double * rowObjective_;
00948 double * columnLower_;
00950 double * columnUpper_;
00952 ClpMatrixBase * matrix_;
00954 ClpMatrixBase * rowCopy_;
00956 ClpPackedMatrix * scaledMatrix_;
00958 double * ray_;
00960 double * rowScale_;
00962 double * columnScale_;
00964 double * inverseRowScale_;
00966 double * inverseColumnScale_;
00969 int scalingFlag_;
00977 unsigned char * status_;
00979 char * integerType_;
00981 void * userPointer_;
00983 ClpTrustedData * trustedUserPointer_;
00985 int intParam_[ClpLastIntParam];
00987 int numberIterations_;
00989 int solveType_;
01006 unsigned int whatsChanged_;
01008 int problemStatus_;
01010 int secondaryStatus_;
01012 int lengthNames_;
01014 int numberThreads_;
01018 unsigned int specialOptions_;
01020 CoinMessageHandler * handler_;
01022 bool defaultHandler_;
01024 CoinThreadRandom randomNumberGenerator_;
01026 ClpEventHandler * eventHandler_;
01027 #ifndef CLP_NO_STD
01028
01029 std::vector<std::string> rowNames_;
01031 std::vector<std::string> columnNames_;
01032 #endif
01033
01034 CoinMessages messages_;
01036 CoinMessages coinMessages_;
01038 int maximumColumns_;
01040 int maximumRows_;
01042 int maximumInternalColumns_;
01044 int maximumInternalRows_;
01046 CoinPackedMatrix baseMatrix_;
01048 CoinPackedMatrix baseRowCopy_;
01050 double * savedRowScale_;
01052 double * savedColumnScale_;
01053 #ifndef CLP_NO_STD
01054
01055 std::string strParam_[ClpLastStrParam];
01056 #endif
01057
01058 };
01061 class ClpDataSave {
01062
01063 public:
01067
01068 ClpDataSave ( );
01069
01071 ClpDataSave(const ClpDataSave &);
01073 ClpDataSave & operator=(const ClpDataSave & rhs);
01075 ~ClpDataSave ( );
01076
01078
01080 public:
01081
01084 double dualBound_;
01085 double infeasibilityCost_;
01086 double pivotTolerance_;
01087 double zeroFactorizationTolerance_;
01088 double zeroSimplexTolerance_;
01089 double acceptablePivot_;
01090 double objectiveScale_;
01091 int sparseThreshold_;
01092 int perturbation_;
01093 int forceFactorization_;
01094 int scalingFlag_;
01095 unsigned int specialOptions_;
01097 };
01098
01099 #endif