/home/coin/SVN-release/Osi-0.102.2/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_;
01319   mutable unsigned int specialOptions_;
01321   ClpSimplex * baseModel_;
01323   int lastNumberRows_;
01325   ClpSimplex * continuousModel_;
01327   OsiClpDisasterHandler * disasterHandler_ ;
01329   ClpLinearObjective * fakeObjective_;
01331   CoinDoubleArrayWithLength rowScale_; 
01333   CoinDoubleArrayWithLength columnScale_; 
01335 };
01336   
01337 class OsiClpDisasterHandler : public ClpDisasterHandler {
01338 public:
01342 
01343   virtual void intoSimplex();
01345   virtual bool check() const ;
01347   virtual void saveInfo();
01349   virtual int typeOfDisaster();
01351   
01352   
01357   OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);
01359   virtual ~OsiClpDisasterHandler();
01360   // Copy
01361   OsiClpDisasterHandler(const OsiClpDisasterHandler&);
01362   // Assignment
01363   OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);
01365   virtual ClpDisasterHandler * clone() const;
01366 
01368   
01373   void setOsiModel(OsiClpSolverInterface * model);
01375   inline OsiClpSolverInterface * osiModel() const
01376   { return osiModel_;}
01378   inline void setWhereFrom(int value)
01379   { whereFrom_=value;}
01381   inline int whereFrom() const
01382   { return whereFrom_;}
01384   inline void setPhase(int value)
01385   { phase_=value;}
01387   inline int phase() const
01388   { return phase_;}
01390   inline bool inTrouble() const
01391   { return inTrouble_;}
01392   
01394   
01395   
01396 protected:
01400 
01401   OsiClpSolverInterface * osiModel_;
01409   int whereFrom_;
01417   int phase_;
01419   bool inTrouble_;
01420       
01422 };
01423 // So unit test can find out if NDEBUG set
01424 bool OsiClpHasNDEBUG();
01425 //#############################################################################
01433 int
01434 OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
01435 #endif

Generated on Wed Apr 7 03:06:53 2010 by  doxygen 1.4.7