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

- File List
- File Members

# /home/coin/SVN-release/Cgl-0.55.0/Clp/src/ClpModel.hpp

Go to the documentation of this file.

    00001 /* $Id: ClpModel.hpp 1461 2009-11-06 19:06:43Z stefan $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    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 //#ifndef COIN_USE_CLP
    00015 //#define COIN_USE_CLP
    00016 //#endif
    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
    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
    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
    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
    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
    00796     bool setStrParam(ClpStrParam key, const std::string & value);
    00797 #endif
    00798     // Get an integer parameter
    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     // Get an double parameter
    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     // Get a string parameter
    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
    00828     void generateCpp( FILE * fp);
    00829
    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
    01029   std::vector<std::string> rowNames_;
    01031   std::vector<std::string> columnNames_;
    01032 #endif
    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
    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