Clp trunk
OsiClpSolverInterface.hpp
Go to the documentation of this file.
00001 // $Id$
00002 // Copyright (C) 2000, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
00005 
00006 
00007 #ifndef OsiClpSolverInterface_H
00008 #define OsiClpSolverInterface_H
00009 
00010 #include <string>
00011 #include <cfloat>
00012 #include <map>
00013 
00014 #include "ClpSimplex.hpp"
00015 #include "ClpLinearObjective.hpp"
00016 #include "CoinPackedMatrix.hpp"
00017 #include "OsiSolverInterface.hpp"
00018 #include "CoinWarmStartBasis.hpp"
00019 #include "ClpEventHandler.hpp"
00020 #include "ClpNode.hpp"
00021 #include "CoinIndexedVector.hpp"
00022 
00023 class OsiRowCut;
00024 class OsiClpUserSolver;
00025 class OsiClpDisasterHandler;
00026 class CoinSet;
00027 #ifndef COIN_DBL_MAX
00028 static const double OsiClpInfinity = DBL_MAX;
00029 #else
00030 static const double OsiClpInfinity = COIN_DBL_MAX;
00031 #endif
00032 
00033 //#############################################################################
00034 
00041 class OsiClpSolverInterface :
00042   virtual public OsiSolverInterface {
00043   friend int OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
00044   
00045 public:
00046   //---------------------------------------------------------------------------
00049 
00050   virtual void initialSolve();
00051   
00053   virtual void resolve();
00054   
00056   virtual void resolveGub(int needed);
00057   
00059   virtual void branchAndBound();
00060 
00068   void crossover(int options,int basis);
00070   
00086   virtual int canDoSimplexInterface() const;
00087 
00096   virtual void enableFactorization() const;
00097 
00099   virtual void disableFactorization() const;
00100   
00105   virtual bool basisIsAvailable() const;
00106   
00122   virtual void getBasisStatus(int* cstat, int* rstat) const;
00123   
00134   virtual int setBasisStatus(const int* cstat, const int* rstat);
00135   
00137   virtual void getReducedGradient(double* columnReducedCosts, 
00138                                   double * duals,
00139                                   const double * c) const ;
00140   
00142   virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
00143   
00148   virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
00149                            bool keepScaled=false) const;
00150   
00152   virtual void getBInvRow(int row, double* z) const;
00153   
00155   virtual void getBInvACol(int col, double* vec) const ;
00156   
00158   virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
00159   
00164   virtual void getBInvACol(CoinIndexedVector * vec) const ;
00165   
00167   virtual void getBInvCol(int col, double* vec) const ;
00168   
00173   virtual void getBasics(int* index) const;
00174 
00181   virtual void enableSimplexInterface(bool doingPrimal);
00182   
00184   virtual void disableSimplexInterface();
00185 
00193   virtual int pivot(int colIn, int colOut, int outStatus);
00194   
00206   virtual int primalPivotResult(int colIn, int sign, 
00207                                 int& colOut, int& outStatus, 
00208                                 double& t, CoinPackedVector* dx);
00209   
00216   virtual int dualPivotResult(int& colIn, int& sign, 
00217                               int colOut, int outStatus, 
00218                               double& t, CoinPackedVector* dx);
00219   
00220   
00222   //---------------------------------------------------------------------------
00238   // Set an integer parameter
00239   bool setIntParam(OsiIntParam key, int value);
00240   // Set an double parameter
00241   bool setDblParam(OsiDblParam key, double value);
00242   // Set a string parameter
00243   bool setStrParam(OsiStrParam key, const std::string & value);
00244   // Get an integer parameter
00245   bool getIntParam(OsiIntParam key, int& value) const;
00246   // Get an double parameter
00247   bool getDblParam(OsiDblParam key, double& value) const;
00248   // Get a string parameter
00249   bool getStrParam(OsiStrParam key, std::string& value) const;
00250   // Set a hint parameter - overrides OsiSolverInterface
00251   virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
00252                             OsiHintStrength strength=OsiHintTry,
00253                             void * otherInformation=NULL);
00255   
00256   //---------------------------------------------------------------------------
00258 
00259 
00260   virtual bool isAbandoned() const;
00262   virtual bool isProvenOptimal() const;
00264   virtual bool isProvenPrimalInfeasible() const;
00266   virtual bool isProvenDualInfeasible() const;
00268   virtual bool isPrimalObjectiveLimitReached() const;
00270   virtual bool isDualObjectiveLimitReached() const;
00272   virtual bool isIterationLimitReached() const;
00274   
00275   //---------------------------------------------------------------------------
00278   
00286   virtual CoinWarmStart *getEmptyWarmStart () const;
00287   
00289   virtual CoinWarmStart* getWarmStart() const;
00291   inline CoinWarmStartBasis* getPointerToWarmStart() 
00292   { return &basis_;}
00294   inline const CoinWarmStartBasis* getConstPointerToWarmStart() const 
00295   { return &basis_;}
00298   virtual bool setWarmStart(const CoinWarmStart* warmstart);
00308   virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
00309 
00311   
00312   //---------------------------------------------------------------------------
00319 
00320   virtual void markHotStart();
00322   virtual void solveFromHotStart();
00324   virtual void unmarkHotStart();
00333   int startFastDual(int options);
00335   void stopFastDual();
00337   void setStuff(double tolerance,double increment);
00339   
00340   //---------------------------------------------------------------------------
00355 
00356   virtual int getNumCols() const {
00357     return modelPtr_->numberColumns(); }
00358   
00360   virtual int getNumRows() const {
00361     return modelPtr_->numberRows(); }
00362   
00364   virtual int getNumElements() const {
00365     int retVal = 0;
00366     const CoinPackedMatrix * matrix =modelPtr_->matrix();
00367     if ( matrix != NULL ) retVal=matrix->getNumElements();
00368     return retVal; }
00369 
00372     virtual std::string getRowName(int rowIndex,
00373                                    unsigned maxLen = std::string::npos) const;
00374     
00377     virtual std::string getColName(int colIndex,
00378                                    unsigned maxLen = std::string::npos) const;
00379     
00380   
00382   virtual const double * getColLower() const { return modelPtr_->columnLower(); }
00383   
00385   virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
00386   
00396   virtual const char * getRowSense() const;
00397   
00406   virtual const double * getRightHandSide() const ;
00407   
00416   virtual const double * getRowRange() const ;
00417   
00419   virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
00420   
00422   virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
00423   
00425   virtual const double * getObjCoefficients() const 
00426   { if (fakeMinInSimplex_)
00427       return linearObjective_ ;
00428     else
00429       return modelPtr_->objective(); }
00430   
00432   virtual double getObjSense() const 
00433   { return ((fakeMinInSimplex_)?-modelPtr_->optimizationDirection():
00434                                  modelPtr_->optimizationDirection()); }
00435   
00437   virtual bool isContinuous(int colNumber) const;
00439   virtual bool isBinary(int colIndex) const;
00440   
00445   virtual bool isInteger(int colIndex) const;
00446   
00448   virtual bool isIntegerNonBinary(int colIndex) const;
00449   
00451   virtual bool isFreeBinary(int colIndex) const; 
00457   virtual const char * getColType(bool refresh=false) const;
00458   
00464   bool isOptionalInteger(int colIndex) const;
00466   void setOptionalInteger(int index);
00467   
00469   virtual const CoinPackedMatrix * getMatrixByRow() const;
00470   
00472   virtual const CoinPackedMatrix * getMatrixByCol() const;
00473   
00475   virtual CoinPackedMatrix * getMutableMatrixByCol() const;
00476   
00478   virtual double getInfinity() const { return OsiClpInfinity; }
00480   
00483 
00484   virtual const double * getColSolution() const; 
00485   
00487   virtual const double * getRowPrice() const;
00488   
00490   virtual const double * getReducedCost() const; 
00491   
00494   virtual const double * getRowActivity() const; 
00495   
00497   virtual double getObjValue() const;
00498   
00501   virtual int getIterationCount() const 
00502   { return modelPtr_->numberIterations(); }
00503   
00521   virtual std::vector<double*> getDualRays(int maxNumRays,
00522                                            bool fullRay = false) const;
00534   virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
00535   
00537 
00538   
00539   //---------------------------------------------------------------------------
00540   
00543   //-------------------------------------------------------------------------
00547   virtual void setObjCoeff( int elementIndex, double elementValue );
00548   
00551   virtual void setColLower( int elementIndex, double elementValue );
00552   
00555   virtual void setColUpper( int elementIndex, double elementValue );
00556   
00558   virtual void setColBounds( int elementIndex,
00559                              double lower, double upper );
00560   
00569   virtual void setColSetBounds(const int* indexFirst,
00570                                const int* indexLast,
00571                                const double* boundList);
00572   
00575   virtual void setRowLower( int elementIndex, double elementValue );
00576   
00579   virtual void setRowUpper( int elementIndex, double elementValue ) ;
00580   
00582   virtual void setRowBounds( int elementIndex,
00583                              double lower, double upper ) ;
00584   
00586   virtual void setRowType(int index, char sense, double rightHandSide,
00587                           double range);
00588   
00597   virtual void setRowSetBounds(const int* indexFirst,
00598                                const int* indexLast,
00599                                const double* boundList);
00600   
00611   virtual void setRowSetTypes(const int* indexFirst,
00612                               const int* indexLast,
00613                               const char* senseList,
00614                               const double* rhsList,
00615                               const double* rangeList);
00620     virtual void setObjective(const double * array);
00621 
00626     virtual void setColLower(const double * array);
00627 
00632     virtual void setColUpper(const double * array);
00633 
00634 //    using OsiSolverInterface::setRowName ;
00636 //    virtual void setRowName(int rowIndex, std::string & name) ;
00637     virtual void setRowName(int rowIndex, std::string  name) ;
00638     
00639 //    using OsiSolverInterface::setColName ;
00641 //    virtual void setColName(int colIndex, std::string & name) ;
00642     virtual void setColName(int colIndex, std::string  name) ;
00643     
00645   
00646   //-------------------------------------------------------------------------
00650   virtual void setContinuous(int index);
00652   virtual void setInteger(int index);
00655   virtual void setContinuous(const int* indices, int len);
00658   virtual void setInteger(const int* indices, int len);
00660   inline int numberSOS() const
00661   { return numberSOS_;}
00663   inline const CoinSet * setInfo() const
00664   { return setInfo_;}
00674   virtual int findIntegersAndSOS(bool justCount);
00676   
00677   //-------------------------------------------------------------------------
00679   virtual void setObjSense(double s ) 
00680   { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
00681   
00692   virtual void setColSolution(const double * colsol);
00693   
00704   virtual void setRowPrice(const double * rowprice);
00705   
00706   //-------------------------------------------------------------------------
00711 
00712   //using OsiSolverInterface::addCol ;
00714   virtual void addCol(const CoinPackedVectorBase& vec,
00715                       const double collb, const double colub,   
00716                       const double obj);
00719   virtual void addCol(const CoinPackedVectorBase& vec,
00720                       const double collb, const double colub,   
00721                       const double obj, std::string name) ;
00723   virtual void addCol(int numberElements, const int * rows, const double * elements,
00724                       const double collb, const double colub,   
00725                       const double obj) ;
00728   virtual void addCol(int numberElements,
00729                       const int* rows, const double* elements,
00730                       const double collb, const double colub,   
00731                       const double obj, std::string name) ;
00733   virtual void addCols(const int numcols,
00734                        const CoinPackedVectorBase * const * cols,
00735                        const double* collb, const double* colub,   
00736                        const double* obj);
00738   virtual void addCols(const int numcols,
00739                        const int * columnStarts, const int * rows, const double * elements,
00740                        const double* collb, const double* colub,   
00741                        const double* obj);
00743   virtual void deleteCols(const int num, const int * colIndices);
00744   
00746   virtual void addRow(const CoinPackedVectorBase& vec,
00747                       const double rowlb, const double rowub);
00754     virtual void addRow(const CoinPackedVectorBase& vec,
00755                         const double rowlb, const double rowub,
00756                         std::string name) ;
00757   virtual void addRow(const CoinPackedVectorBase& vec,
00758                       const char rowsen, const double rowrhs,   
00759                       const double rowrng);
00761   virtual void addRow(int numberElements, const int * columns, const double * element,
00762                       const double rowlb, const double rowub) ;
00765     virtual void addRow(const CoinPackedVectorBase& vec,
00766                         const char rowsen, const double rowrhs,   
00767                         const double rowrng, std::string name) ;
00769   virtual void addRows(const int numrows,
00770                        const CoinPackedVectorBase * const * rows,
00771                        const double* rowlb, const double* rowub);
00773   virtual void addRows(const int numrows,
00774                        const CoinPackedVectorBase * const * rows,
00775                        const char* rowsen, const double* rowrhs,   
00776                        const double* rowrng);
00777 
00779   virtual void addRows(const int numrows,
00780                        const int * rowStarts, const int * columns, const double * element,
00781                        const double* rowlb, const double* rowub);
00783   void modifyCoefficient(int row, int column, double newElement,
00784                         bool keepZero=false)
00785         {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
00786 
00788   virtual void deleteRows(const int num, const int * rowIndices);
00791   virtual void saveBaseModel() ;
00795   virtual void restoreBaseModel(int numberRows);
00796   
00797   //-----------------------------------------------------------------------
00801   virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
00806   virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
00829     virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
00830                                           double effectivenessLb = 0.0);
00831 
00833 
00834   
00835   //---------------------------------------------------------------------------
00836   
00837 public:
00838   
00852   virtual void loadProblem(const CoinPackedMatrix& matrix,
00853                            const double* collb, const double* colub,   
00854                            const double* obj,
00855                            const double* rowlb, const double* rowub);
00856   
00864   virtual void assignProblem(CoinPackedMatrix*& matrix,
00865                              double*& collb, double*& colub, double*& obj,
00866                              double*& rowlb, double*& rowub);
00867   
00880   virtual void loadProblem(const CoinPackedMatrix& matrix,
00881                            const double* collb, const double* colub,
00882                            const double* obj,
00883                            const char* rowsen, const double* rowrhs,   
00884                            const double* rowrng);
00885   
00893   virtual void assignProblem(CoinPackedMatrix*& matrix,
00894                              double*& collb, double*& colub, double*& obj,
00895                              char*& rowsen, double*& rowrhs,
00896                              double*& rowrng);
00897   
00900   virtual void loadProblem(const int numcols, const int numrows,
00901                            const CoinBigIndex * start, const int* index,
00902                            const double* value,
00903                            const double* collb, const double* colub,   
00904                            const double* obj,
00905                            const double* rowlb, const double* rowub);
00906   
00909   virtual void loadProblem(const int numcols, const int numrows,
00910                            const CoinBigIndex * start, const int* index,
00911                            const double* value,
00912                            const double* collb, const double* colub,   
00913                            const double* obj,
00914                            const char* rowsen, const double* rowrhs,   
00915                            const double* rowrng);
00917   virtual int loadFromCoinModel (  CoinModel & modelObject, bool keepSolution=false);
00918 
00919   using OsiSolverInterface::readMps ;
00922   virtual int readMps(const char *filename,
00923                       const char *extension = "mps") ;
00926   int readMps(const char *filename,bool keepNames,bool allowErrors);
00928   virtual int readMps (const char *filename, const char*extension,
00929                         int & numberSets, CoinSet ** & sets);
00930   
00935   virtual void writeMps(const char *filename,
00936                         const char *extension = "mps",
00937                         double objSense=0.0) const;
00946   virtual int writeMpsNative(const char *filename, 
00947                              const char ** rowNames, const char ** columnNames,
00948                              int formatType=0,int numberAcross=2,
00949                              double objSense=0.0) const ;
00951   virtual int readLp(const char *filename, const double epsilon = 1e-5);
00957   virtual void writeLp(const char *filename,
00958                        const char *extension = "lp",
00959                        double epsilon = 1e-5,
00960                        int numberAcross = 10,
00961                        int decimals = 5,
00962                        double objSense = 0.0,
00963                        bool useRowNames = true) const;
00968   virtual void writeLp(FILE *fp,
00969                double epsilon = 1e-5,
00970                int numberAcross = 10,
00971                int decimals = 5,
00972                double objSense = 0.0,
00973                bool useRowNames = true) const;
00979   virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
00981   virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
00983   
00994   virtual void passInMessageHandler(CoinMessageHandler * handler);
00996   void newLanguage(CoinMessages::Language language);
00997   void setLanguage(CoinMessages::Language language)
00998   {newLanguage(language);}
01000   void setLogLevel(int value);
01002   void generateCpp( FILE * fp);
01004   //---------------------------------------------------------------------------
01005   
01008 
01009   ClpSimplex * getModelPtr() const ;
01011   inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
01012   { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
01014   inline unsigned int specialOptions() const
01015   { return specialOptions_;}
01016   void setSpecialOptions(unsigned int value);
01018   inline int lastAlgorithm() const
01019   { return lastAlgorithm_;}
01021   inline int cleanupScaling() const
01022   { return cleanupScaling_;}
01035   inline void setCleanupScaling(int value)
01036   { cleanupScaling_=value;}
01039   inline double smallestElementInCut() const
01040   { return smallestElementInCut_;}
01043   inline void setSmallestElementInCut(double value)
01044   { smallestElementInCut_=value;}
01051   inline double smallestChangeInCut() const
01052   { return smallestChangeInCut_;}
01059   inline void setSmallestChangeInCut(double value)
01060   { smallestChangeInCut_=value;}
01062   inline void setSolveOptions(const ClpSolve & options)
01063   { solveOptions_ = options;}
01067   virtual int tightenBounds(int lightweight=0);
01069   virtual CoinBigIndex getSizeL() const;
01071   virtual CoinBigIndex getSizeU() const;
01073   const OsiClpDisasterHandler * disasterHandler() const
01074   { return disasterHandler_;}
01076   void passInDisasterHandler(OsiClpDisasterHandler * handler);
01078   ClpLinearObjective * fakeObjective() const
01079   { return fakeObjective_;}
01081   void setFakeObjective(ClpLinearObjective * fakeObjective);
01083   void setFakeObjective(double * fakeObjective);
01103   void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
01105   virtual void synchronizeModel();
01110   void setSpecialOptionsMutable(unsigned int value) const;
01111 
01113   
01114   //---------------------------------------------------------------------------
01115   
01118 
01119   OsiClpSolverInterface ();
01120   
01122   virtual OsiSolverInterface * clone(bool copyData = true) const;
01123   
01125   OsiClpSolverInterface (const OsiClpSolverInterface &);
01126   
01128   OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
01129   
01131   void releaseClp();
01132   
01134   OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs);
01135   
01137   virtual ~OsiClpSolverInterface ();
01138   
01140   virtual void reset();
01142   
01143   //---------------------------------------------------------------------------
01144   
01145 protected:
01147 
01148 
01149   virtual void applyRowCut(const OsiRowCut& rc);
01150   
01152   virtual void applyColCut(const OsiColCut& cc);
01154   
01155   //---------------------------------------------------------------------------
01156   
01157 protected:
01160 
01161   void gutsOfDestructor();
01162   
01164   void freeCachedResults() const;
01165   
01167   void freeCachedResults0() const;
01168   
01170   void freeCachedResults1() const;
01171   
01173   void extractSenseRhsRange() const;
01174   
01176   void fillParamMaps();
01185   CoinWarmStartBasis getBasis(ClpSimplex * model) const;
01194   void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
01196   void crunch();
01198   void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
01199                         const int * indices, const double * elements);
01200 public:
01203   void setBasis( const CoinWarmStartBasis & basis);
01205   inline void setBasis( )
01206   { setBasis(basis_,modelPtr_);}
01208   CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
01210   CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
01212   void deleteScaleFactors();
01214   inline const double * upRange() const
01215   { return rowActivity_;}
01216   inline const double * downRange() const
01217   { return columnActivity_;}
01219   inline void passInRanges(int * array)
01220   { whichRange_=array;}
01222   void setSOSData(int numberSOS,const char * type,
01223                   const int * start,const int * indices, const double * weights=NULL);
01225   void computeLargestAway();
01227   inline double largestAway() const
01228   { return largestAway_;}
01230   inline void setLargestAway(double value)
01231   { largestAway_ = value;}
01233   void lexSolve();
01235   
01236 protected:
01239 
01240   mutable ClpSimplex * modelPtr_;
01242 
01244 
01245   mutable char    *rowsense_;
01246   
01248   mutable double  *rhs_;
01249   
01253   mutable double  *rowrange_;
01254   
01257   mutable CoinWarmStartBasis* ws_;
01260   mutable double * rowActivity_;
01261   mutable double * columnActivity_;
01263   ClpNodeStuff stuff_;
01265   int numberSOS_;
01267   CoinSet * setInfo_;
01269   ClpSimplex * smallModel_;
01271   ClpFactorization * factorization_;
01274   double smallestElementInCut_;
01278   double smallestChangeInCut_;
01280   double largestAway_;
01282   char * spareArrays_;
01284   CoinWarmStartBasis basis_;
01286   int itlimOrig_;
01287   
01298   mutable int lastAlgorithm_;
01299   
01301   bool notOwned_;
01302   
01304   mutable CoinPackedMatrix *matrixByRow_;  
01305   
01307   CoinPackedMatrix *matrixByRowAtContinuous_;  
01308   
01310   char * integerInformation_;
01311   
01316   int * whichRange_;
01317 
01318   //std::map<OsiIntParam, ClpIntParam> intParamMap_;
01319   //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
01320   //std::map<OsiStrParam, ClpStrParam> strParamMap_;
01321   
01323   mutable bool fakeMinInSimplex_ ;
01330   mutable double *linearObjective_;
01331 
01333   mutable ClpDataSave saveData_;
01335   ClpSolve solveOptions_;
01348   int cleanupScaling_;
01376   mutable unsigned int specialOptions_;
01378   ClpSimplex * baseModel_;
01380   int lastNumberRows_;
01382   ClpSimplex * continuousModel_;
01384   OsiClpDisasterHandler * disasterHandler_ ;
01386   ClpLinearObjective * fakeObjective_;
01388   CoinDoubleArrayWithLength rowScale_; 
01390   CoinDoubleArrayWithLength columnScale_; 
01392 };
01393   
01394 class OsiClpDisasterHandler : public ClpDisasterHandler {
01395 public:
01399 
01400   virtual void intoSimplex();
01402   virtual bool check() const ;
01404   virtual void saveInfo();
01406   virtual int typeOfDisaster();
01408   
01409   
01414   OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);
01416   virtual ~OsiClpDisasterHandler();
01417   // Copy
01418   OsiClpDisasterHandler(const OsiClpDisasterHandler&);
01419   // Assignment
01420   OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);
01422   virtual ClpDisasterHandler * clone() const;
01423 
01425   
01430   void setOsiModel(OsiClpSolverInterface * model);
01432   inline OsiClpSolverInterface * osiModel() const
01433   { return osiModel_;}
01435   inline void setWhereFrom(int value)
01436   { whereFrom_=value;}
01438   inline int whereFrom() const
01439   { return whereFrom_;}
01441   inline void setPhase(int value)
01442   { phase_=value;}
01444   inline int phase() const
01445   { return phase_;}
01447   inline bool inTrouble() const
01448   { return inTrouble_;}
01449   
01451   
01452   
01453 protected:
01457 
01458   OsiClpSolverInterface * osiModel_;
01466   int whereFrom_;
01474   int phase_;
01476   bool inTrouble_;
01478 };
01479 // So unit test can find out if NDEBUG set
01480 bool OsiClpHasNDEBUG();
01481 //#############################################################################
01489 int
01490 OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
01491 #endif
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Defines