/home/coin/SVN-release/Bcp-1.2.2/Clp/src/ClpModel.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2002, International Business Machines
00002 // Corporation and others.  All Rights Reserved.
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 //#ifndef COIN_USE_CLP
00014 //#define COIN_USE_CLP
00015 //#endif
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 // Plus infinity
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     // Get an integer parameter
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     // Get an double parameter
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     // Get a string parameter
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

Generated on Tue Jun 16 03:03:02 2009 for coin-Bcp by  doxygen 1.4.7