• Main Page
  • Classes
  • Files
  • File List
  • File Members

/build/buildd/clp-1.11.1/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
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     // 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
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

Generated on Fri Aug 20 2010 06:29:28 by  doxygen 1.7.1