- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# /home/coin/SVN-release/Blis-0.91.0/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