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

- File List
- File Members

# /home/coin/SVN-release/Cgl-0.55.0/Osi/src/OsiClp/OsiClpSolverInterface.hpp

Go to the documentation of this file.

    00001 // Copyright (C) 2000, International Business Machines
    00002 // Corporation and others.  All Rights Reserved.
    00003
    00004 #ifndef OsiClpSolverInterface_H
    00005 #define OsiClpSolverInterface_H
    00006
    00007 #include <string>
    00008 #include <cfloat>
    00009 #include <map>
    00010
    00011 #include "ClpSimplex.hpp"
    00012 #include "ClpLinearObjective.hpp"
    00013 #include "CoinPackedMatrix.hpp"
    00014 #include "OsiSolverInterface.hpp"
    00015 #include "CoinWarmStartBasis.hpp"
    00016 #include "ClpEventHandler.hpp"
    00017 #include "ClpNode.hpp"
    00018 #include "CoinIndexedVector.hpp"
    00019
    00020 class OsiRowCut;
    00021 class OsiClpUserSolver;
    00022 class OsiClpDisasterHandler;
    00023 class CoinSet;
    00024 #ifndef COIN_DBL_MAX
    00025 static const double OsiClpInfinity = DBL_MAX;
    00026 #else
    00027 static const double OsiClpInfinity = COIN_DBL_MAX;
    00028 #endif
    00029
    00030 //#############################################################################
    00031
    00038 class OsiClpSolverInterface :
    00039   virtual public OsiSolverInterface {
    00040   friend int OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
    00041
    00042 public:
    00043   //---------------------------------------------------------------------------
    00046
    00047   virtual void initialSolve();
    00048
    00050   virtual void resolve();
    00051
    00053   virtual void branchAndBound();
    00054
    00062   void crossover(int options,int basis);
    00064
    00066
    00067
    00073   virtual void enableSimplexInterface(bool doingPrimal);
    00074
    00076   virtual void disableSimplexInterface();
    00080   virtual int canDoSimplexInterface() const;
    00087   virtual void enableFactorization() const;
    00089   virtual void disableFactorization() const;
    00090
    00106   void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
    00108   virtual void synchronizeModel();
    00109   // Sleazy methods to fool const requirements (no less safe as modelPtr_ mutable)
    00110   void setSpecialOptionsMutable(unsigned int value) const;
    00111
    00116   virtual bool basisIsAvailable() const;
    00117
    00133   virtual void getBasisStatus(int* cstat, int* rstat) const;
    00134
    00145   virtual int setBasisStatus(const int* cstat, const int* rstat);
    00146
    00154   virtual int pivot(int colIn, int colOut, int outStatus);
    00155
    00167   virtual int primalPivotResult(int colIn, int sign,
    00168                                 int& colOut, int& outStatus,
    00169                                 double& t, CoinPackedVector* dx);
    00170
    00177   virtual int dualPivotResult(int& colIn, int& sign,
    00178                               int colOut, int outStatus,
    00179                               double& t, CoinPackedVector* dx);
    00180
    00182   virtual void getReducedGradient(double* columnReducedCosts,
    00183                                   double * duals,
    00184                                   const double * c);
    00185
    00188   virtual void setObjectiveAndRefresh(double* c);
    00189
    00191   virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
    00192
    00197   virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
    00198                            bool keepScaled=false) const;
    00199
    00201   virtual void getBInvRow(int row, double* z) const;
    00202
    00204   virtual void getBInvACol(int col, double* vec) const ;
    00205
    00207   virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
    00208
    00213   virtual void getBInvACol(CoinIndexedVector * vec) const ;
    00214
    00216   virtual void getBInvCol(int col, double* vec) const ;
    00217
    00222   virtual void getBasics(int* index) const;
    00223
    00225   //---------------------------------------------------------------------------
    00241   // Set an integer parameter
    00242   bool setIntParam(OsiIntParam key, int value);
    00243   // Set an double parameter
    00244   bool setDblParam(OsiDblParam key, double value);
    00245   // Set a string parameter
    00246   bool setStrParam(OsiStrParam key, const std::string & value);
    00247   // Get an integer parameter
    00248   bool getIntParam(OsiIntParam key, int& value) const;
    00249   // Get an double parameter
    00250   bool getDblParam(OsiDblParam key, double& value) const;
    00251   // Get a string parameter
    00252   bool getStrParam(OsiStrParam key, std::string& value) const;
    00253   // Set a hint parameter - overrides OsiSolverInterface
    00254   virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
    00255                             OsiHintStrength strength=OsiHintTry,
    00256                             void * otherInformation=NULL);
    00258
    00259   //---------------------------------------------------------------------------
    00261
    00262
    00263   virtual bool isAbandoned() const;
    00265   virtual bool isProvenOptimal() const;
    00267   virtual bool isProvenPrimalInfeasible() const;
    00269   virtual bool isProvenDualInfeasible() const;
    00271   virtual bool isPrimalObjectiveLimitReached() const;
    00273   virtual bool isDualObjectiveLimitReached() const;
    00275   virtual bool isIterationLimitReached() const;
    00277
    00278   //---------------------------------------------------------------------------
    00281
    00289   virtual CoinWarmStart *getEmptyWarmStart () const;
    00290
    00292   virtual CoinWarmStart* getWarmStart() const;
    00294   inline CoinWarmStartBasis* getPointerToWarmStart()
    00295   { return &basis_;}
    00297   inline const CoinWarmStartBasis* getConstPointerToWarmStart() const
    00298   { return &basis_;}
    00301   virtual bool setWarmStart(const CoinWarmStart* warmstart);
    00311   virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
    00312
    00314
    00315   //---------------------------------------------------------------------------
    00322
    00323   virtual void markHotStart();
    00325   virtual void solveFromHotStart();
    00327   virtual void unmarkHotStart();
    00336   int startFastDual(int options);
    00338   void stopFastDual();
    00340   void setStuff(double tolerance,double increment);
    00342
    00343   //---------------------------------------------------------------------------
    00358
    00359   virtual int getNumCols() const {
    00360     return modelPtr_->numberColumns(); }
    00361
    00363   virtual int getNumRows() const {
    00364     return modelPtr_->numberRows(); }
    00365
    00367   virtual int getNumElements() const {
    00368     int retVal = 0;
    00369     const CoinPackedMatrix * matrix =modelPtr_->matrix();
    00370     if ( matrix != NULL ) retVal=matrix->getNumElements();
    00371     return retVal; }
    00372
    00375     virtual std::string getRowName(int rowIndex,
    00376                                    unsigned maxLen = std::string::npos) const;
    00377
    00380     virtual std::string getColName(int colIndex,
    00381                                    unsigned maxLen = std::string::npos) const;
    00382
    00383
    00385   virtual const double * getColLower() const { return modelPtr_->columnLower(); }
    00386
    00388   virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
    00389
    00399   virtual const char * getRowSense() const;
    00400
    00409   virtual const double * getRightHandSide() const ;
    00410
    00419   virtual const double * getRowRange() const ;
    00420
    00422   virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
    00423
    00425   virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
    00426
    00428   virtual const double * getObjCoefficients() const
    00429   { return modelPtr_->objective(); }
    00430
    00432   virtual double getObjSense() const
    00433   { return modelPtr_->optimizationDirection(); }
    00434
    00436   virtual bool isContinuous(int colNumber) const;
    00438   virtual bool isBinary(int colIndex) const;
    00439
    00444   virtual bool isInteger(int colIndex) const;
    00445
    00447   virtual bool isIntegerNonBinary(int colIndex) const;
    00448
    00450   virtual bool isFreeBinary(int colIndex) const;
    00456   virtual const char * getColType(bool refresh=false) const;
    00457
    00463   bool isOptionalInteger(int colIndex) const;
    00465   void setOptionalInteger(int index);
    00466
    00468   virtual const CoinPackedMatrix * getMatrixByRow() const;
    00469
    00471   virtual const CoinPackedMatrix * getMatrixByCol() const;
    00472
    00474   virtual CoinPackedMatrix * getMutableMatrixByCol() const;
    00475
    00477   virtual double getInfinity() const { return OsiClpInfinity; }
    00479
    00482
    00483   virtual const double * getColSolution() const;
    00484
    00486   virtual const double * getRowPrice() const;
    00487
    00489   virtual const double * getReducedCost() const;
    00490
    00493   virtual const double * getRowActivity() const;
    00494
    00496   virtual double getObjValue() const;
    00497
    00500   virtual int getIterationCount() const
    00501   { return modelPtr_->numberIterations(); }
    00502
    00514   virtual std::vector<double*> getDualRays(int maxNumRays) const;
    00526   virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
    00527
    00529
    00530
    00531   //---------------------------------------------------------------------------
    00532
    00535   //-------------------------------------------------------------------------
    00539   virtual void setObjCoeff( int elementIndex, double elementValue );
    00540
    00543   virtual void setColLower( int elementIndex, double elementValue );
    00544
    00547   virtual void setColUpper( int elementIndex, double elementValue );
    00548
    00550   virtual void setColBounds( int elementIndex,
    00551                              double lower, double upper );
    00552
    00561   virtual void setColSetBounds(const int* indexFirst,
    00562                                const int* indexLast,
    00563                                const double* boundList);
    00564
    00567   virtual void setRowLower( int elementIndex, double elementValue );
    00568
    00571   virtual void setRowUpper( int elementIndex, double elementValue ) ;
    00572
    00574   virtual void setRowBounds( int elementIndex,
    00575                              double lower, double upper ) ;
    00576
    00578   virtual void setRowType(int index, char sense, double rightHandSide,
    00579                           double range);
    00580
    00589   virtual void setRowSetBounds(const int* indexFirst,
    00590                                const int* indexLast,
    00591                                const double* boundList);
    00592
    00603   virtual void setRowSetTypes(const int* indexFirst,
    00604                               const int* indexLast,
    00605                               const char* senseList,
    00606                               const double* rhsList,
    00607                               const double* rangeList);
    00612     virtual void setObjective(const double * array);
    00613
    00618     virtual void setColLower(const double * array);
    00619
    00624     virtual void setColUpper(const double * array);
    00625
    00626 //    using OsiSolverInterface::setRowName ;
    00628 //    virtual void setRowName(int rowIndex, std::string & name) ;
    00629     virtual void setRowName(int rowIndex, std::string  name) ;
    00630
    00631 //    using OsiSolverInterface::setColName ;
    00633 //    virtual void setColName(int colIndex, std::string & name) ;
    00634     virtual void setColName(int colIndex, std::string  name) ;
    00635
    00637
    00638   //-------------------------------------------------------------------------
    00642   virtual void setContinuous(int index);
    00644   virtual void setInteger(int index);
    00647   virtual void setContinuous(const int* indices, int len);
    00650   virtual void setInteger(const int* indices, int len);
    00652   inline int numberSOS() const
    00653   { return numberSOS_;}
    00655   inline const CoinSet * setInfo() const
    00656   { return setInfo_;}
    00666   virtual int findIntegersAndSOS(bool justCount);
    00668
    00669   //-------------------------------------------------------------------------
    00671   virtual void setObjSense(double s )
    00672   { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
    00673
    00684   virtual void setColSolution(const double * colsol);
    00685
    00696   virtual void setRowPrice(const double * rowprice);
    00697
    00698   //-------------------------------------------------------------------------
    00703
    00704   //using OsiSolverInterface::addCol ;
    00706   virtual void addCol(const CoinPackedVectorBase& vec,
    00707                       const double collb, const double colub,
    00708                       const double obj);
    00711   virtual void addCol(const CoinPackedVectorBase& vec,
    00712                       const double collb, const double colub,
    00713                       const double obj, std::string name) ;
    00715   virtual void addCol(int numberElements, const int * rows, const double * elements,
    00716                       const double collb, const double colub,
    00717                       const double obj) ;
    00720   virtual void addCol(int numberElements,
    00721                       const int* rows, const double* elements,
    00722                       const double collb, const double colub,
    00723                       const double obj, std::string name) ;
    00725   virtual void addCols(const int numcols,
    00726                        const CoinPackedVectorBase * const * cols,
    00727                        const double* collb, const double* colub,
    00728                        const double* obj);
    00730   virtual void addCols(const int numcols,
    00731                        const int * columnStarts, const int * rows, const double * elements,
    00732                        const double* collb, const double* colub,
    00733                        const double* obj);
    00735   virtual void deleteCols(const int num, const int * colIndices);
    00736
    00738   virtual void addRow(const CoinPackedVectorBase& vec,
    00739                       const double rowlb, const double rowub);
    00746     virtual void addRow(const CoinPackedVectorBase& vec,
    00747                         const double rowlb, const double rowub,
    00748                         std::string name) ;
    00749   virtual void addRow(const CoinPackedVectorBase& vec,
    00750                       const char rowsen, const double rowrhs,
    00751                       const double rowrng);
    00753   virtual void addRow(int numberElements, const int * columns, const double * element,
    00754                       const double rowlb, const double rowub) ;
    00757     virtual void addRow(const CoinPackedVectorBase& vec,
    00758                         const char rowsen, const double rowrhs,
    00759                         const double rowrng, std::string name) ;
    00761   virtual void addRows(const int numrows,
    00762                        const CoinPackedVectorBase * const * rows,
    00763                        const double* rowlb, const double* rowub);
    00765   virtual void addRows(const int numrows,
    00766                        const CoinPackedVectorBase * const * rows,
    00767                        const char* rowsen, const double* rowrhs,
    00768                        const double* rowrng);
    00769
    00771   virtual void addRows(const int numrows,
    00772                        const int * rowStarts, const int * columns, const double * element,
    00773                        const double* rowlb, const double* rowub);
    00775   void modifyCoefficient(int row, int column, double newElement,
    00776                         bool keepZero=false)
    00777         {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
    00778
    00780   virtual void deleteRows(const int num, const int * rowIndices);
    00783   virtual void saveBaseModel() ;
    00787   virtual void restoreBaseModel(int numberRows);
    00788
    00789   //-----------------------------------------------------------------------
    00793   virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
    00798   virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
    00821     virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
    00822                                           double effectivenessLb = 0.0);
    00823
    00825
    00826
    00827   //---------------------------------------------------------------------------
    00828
    00829 public:
    00830
    00844   virtual void loadProblem(const CoinPackedMatrix& matrix,
    00845                            const double* collb, const double* colub,
    00846                            const double* obj,
    00847                            const double* rowlb, const double* rowub);
    00848
    00856   virtual void assignProblem(CoinPackedMatrix*& matrix,
    00857                              double*& collb, double*& colub, double*& obj,
    00858                              double*& rowlb, double*& rowub);
    00859
    00872   virtual void loadProblem(const CoinPackedMatrix& matrix,
    00873                            const double* collb, const double* colub,
    00874                            const double* obj,
    00875                            const char* rowsen, const double* rowrhs,
    00876                            const double* rowrng);
    00877
    00885   virtual void assignProblem(CoinPackedMatrix*& matrix,
    00886                              double*& collb, double*& colub, double*& obj,
    00887                              char*& rowsen, double*& rowrhs,
    00888                              double*& rowrng);
    00889
    00892   virtual void loadProblem(const int numcols, const int numrows,
    00893                            const CoinBigIndex * start, const int* index,
    00894                            const double* value,
    00895                            const double* collb, const double* colub,
    00896                            const double* obj,
    00897                            const double* rowlb, const double* rowub);
    00898
    00901   virtual void loadProblem(const int numcols, const int numrows,
    00902                            const CoinBigIndex * start, const int* index,
    00903                            const double* value,
    00904                            const double* collb, const double* colub,
    00905                            const double* obj,
    00906                            const char* rowsen, const double* rowrhs,
    00907                            const double* rowrng);
    00909   virtual int loadFromCoinModel (  CoinModel & modelObject, bool keepSolution=false);
    00910
    00911   using OsiSolverInterface::readMps ;
    00914   virtual int readMps(const char *filename,
    00915                       const char *extension = "mps") ;
    00918   int readMps(const char *filename,bool keepNames,bool allowErrors);
    00920   virtual int readMps (const char *filename, const char*extension,
    00921                         int & numberSets, CoinSet ** & sets);
    00922
    00927   virtual void writeMps(const char *filename,
    00928                         const char *extension = "mps",
    00929                         double objSense=0.0) const;
    00938   virtual int writeMpsNative(const char *filename,
    00939                              const char ** rowNames, const char ** columnNames,
    00940                              int formatType=0,int numberAcross=2,
    00941                              double objSense=0.0) const ;
    00943   virtual int readLp(const char *filename, const double epsilon = 1e-5);
    00949   virtual void writeLp(const char *filename,
    00950                        const char *extension = "lp",
    00951                        double epsilon = 1e-5,
    00952                        int numberAcross = 10,
    00953                        int decimals = 5,
    00954                        double objSense = 0.0,
    00955                        bool useRowNames = true) const;
    00960   virtual void writeLp(FILE *fp,
    00961                double epsilon = 1e-5,
    00962                int numberAcross = 10,
    00963                int decimals = 5,
    00964                double objSense = 0.0,
    00965                bool useRowNames = true) const;
    00971   virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
    00973   virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
    00975
    00986   virtual void passInMessageHandler(CoinMessageHandler * handler);
    00988   void newLanguage(CoinMessages::Language language);
    00989   void setLanguage(CoinMessages::Language language)
    00990   {newLanguage(language);}
    00992   void setLogLevel(int value);
    00994   void generateCpp( FILE * fp);
    00996   //---------------------------------------------------------------------------
    00997
    01000
    01001   ClpSimplex * getModelPtr() const ;
    01003   inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
    01004   { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
    01006   inline unsigned int specialOptions() const
    01007   { return specialOptions_;}
    01008   void setSpecialOptions(unsigned int value);
    01010   inline int lastAlgorithm() const
    01011   { return lastAlgorithm_;}
    01013   inline int cleanupScaling() const
    01014   { return cleanupScaling_;}
    01027   inline void setCleanupScaling(int value)
    01028   { cleanupScaling_=value;}
    01031   inline double smallestElementInCut() const
    01032   { return smallestElementInCut_;}
    01035   inline void setSmallestElementInCut(double value)
    01036   { smallestElementInCut_=value;}
    01043   inline double smallestChangeInCut() const
    01044   { return smallestChangeInCut_;}
    01051   inline void setSmallestChangeInCut(double value)
    01052   { smallestChangeInCut_=value;}
    01054   inline void setSolveOptions(const ClpSolve & options)
    01055   { solveOptions_ = options;}
    01059   virtual int tightenBounds(int lightweight=0);
    01061   virtual CoinBigIndex getSizeL() const;
    01063   virtual CoinBigIndex getSizeU() const;
    01065   const OsiClpDisasterHandler * disasterHandler() const
    01066   { return disasterHandler_;}
    01068   void passInDisasterHandler(OsiClpDisasterHandler * handler);
    01070   ClpLinearObjective * fakeObjective() const
    01071   { return fakeObjective_;}
    01073   void setFakeObjective(ClpLinearObjective * fakeObjective);
    01075   void setFakeObjective(double * fakeObjective);
    01077
    01078   //---------------------------------------------------------------------------
    01079
    01082
    01083   OsiClpSolverInterface ();
    01084
    01086   virtual OsiSolverInterface * clone(bool copyData = true) const;
    01087
    01089   OsiClpSolverInterface (const OsiClpSolverInterface &);
    01090
    01092   OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
    01093
    01095   void releaseClp();
    01096
    01098   OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs);
    01099
    01101   virtual ~OsiClpSolverInterface ();
    01102
    01104   virtual void reset();
    01106
    01107   //---------------------------------------------------------------------------
    01108
    01109 protected:
    01111
    01112
    01113   virtual void applyRowCut(const OsiRowCut& rc);
    01114
    01116   virtual void applyColCut(const OsiColCut& cc);
    01118
    01119   //---------------------------------------------------------------------------
    01120
    01121 protected:
    01124
    01125   void gutsOfDestructor();
    01126
    01128   void freeCachedResults() const;
    01129
    01131   void freeCachedResults0() const;
    01132
    01134   void freeCachedResults1() const;
    01135
    01137   void extractSenseRhsRange() const;
    01138
    01140   void fillParamMaps();
    01149   CoinWarmStartBasis getBasis(ClpSimplex * model) const;
    01158   void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
    01160   void crunch();
    01162   void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
    01163                         const int * indices, const double * elements);
    01164 public:
    01167   void setBasis( const CoinWarmStartBasis & basis);
    01169   inline void setBasis( )
    01170   { setBasis(basis_,modelPtr_);}
    01172   CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
    01174   CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
    01176   void deleteScaleFactors();
    01178   inline const double * upRange() const
    01179   { return rowActivity_;}
    01180   inline const double * downRange() const
    01181   { return columnActivity_;}
    01183   inline void passInRanges(int * array)
    01184   { whichRange_=array;}
    01186   void setSOSData(int numberSOS,const char * type,
    01187                   const int * start,const int * indices, const double * weights=NULL);
    01189   void computeLargestAway();
    01191   inline double largestAway() const
    01192   { return largestAway_;}
    01194   inline void setLargestAway(double value)
    01195   { largestAway_ = value;}
    01197   void lexSolve();
    01198 protected:
    01200
    01203
    01204   mutable ClpSimplex * modelPtr_;
    01206   double * linearObjective_;
    01209
    01210   mutable char    *rowsense_;
    01211
    01213   mutable double  *rhs_;
    01214
    01218   mutable double  *rowrange_;
    01219
    01222   mutable CoinWarmStartBasis* ws_;
    01225   mutable double * rowActivity_;
    01226   mutable double * columnActivity_;
    01228   ClpNodeStuff stuff_;
    01230   int numberSOS_;
    01232   CoinSet * setInfo_;
    01234   ClpSimplex * smallModel_;
    01236   ClpFactorization * factorization_;
    01239   double smallestElementInCut_;
    01243   double smallestChangeInCut_;
    01245   double largestAway_;
    01247   char * spareArrays_;
    01249   CoinWarmStartBasis basis_;
    01251   int itlimOrig_;
    01252
    01254   mutable int lastAlgorithm_;
    01255
    01257   bool notOwned_;
    01258
    01260   mutable CoinPackedMatrix *matrixByRow_;
    01261
    01263   CoinPackedMatrix *matrixByRowAtContinuous_;
    01264
    01266   char * integerInformation_;
    01267
    01272   int * whichRange_;
    01273
    01274   //std::map<OsiIntParam, ClpIntParam> intParamMap_;
    01275   //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
    01276   //std::map<OsiStrParam, ClpStrParam> strParamMap_;
    01277
    01279   mutable ClpDataSave saveData_;
    01281   ClpSolve solveOptions_;
    01294   int cleanupScaling_;
    01318   mutable unsigned int specialOptions_;
    01320   ClpSimplex * baseModel_;
    01322   int lastNumberRows_;
    01324   ClpSimplex * continuousModel_;
    01326   OsiClpDisasterHandler * disasterHandler_ ;
    01328   ClpLinearObjective * fakeObjective_;
    01330   CoinDoubleArrayWithLength rowScale_;
    01332   CoinDoubleArrayWithLength columnScale_;
    01334 };
    01335
    01336 class OsiClpDisasterHandler : public ClpDisasterHandler {
    01337 public:
    01341
    01342   virtual void intoSimplex();
    01344   virtual bool check() const ;
    01346   virtual void saveInfo();
    01348   virtual int typeOfDisaster();
    01350
    01351
    01356   OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);
    01358   virtual ~OsiClpDisasterHandler();
    01359   // Copy
    01360   OsiClpDisasterHandler(const OsiClpDisasterHandler&);
    01361   // Assignment
    01362   OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);
    01364   virtual ClpDisasterHandler * clone() const;
    01365
    01367
    01372   void setOsiModel(OsiClpSolverInterface * model);
    01374   inline OsiClpSolverInterface * osiModel() const
    01375   { return osiModel_;}
    01377   inline void setWhereFrom(int value)
    01378   { whereFrom_=value;}
    01380   inline int whereFrom() const
    01381   { return whereFrom_;}
    01383   inline void setPhase(int value)
    01384   { phase_=value;}
    01386   inline int phase() const
    01387   { return phase_;}
    01389   inline bool inTrouble() const
    01390   { return inTrouble_;}
    01391
    01393
    01394
    01395 protected:
    01399
    01400   OsiClpSolverInterface * osiModel_;
    01408   int whereFrom_;
    01416   int phase_;
    01418   bool inTrouble_;
    01419
    01421 };
    01422 // So unit test can find out if NDEBUG set
    01423 bool OsiClpHasNDEBUG();
    01424 //#############################################################################
    01432 int
    01433 OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
    01434 #endif