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 #include "CoinFinite.hpp"
00023 
00024 class OsiRowCut;
00025 class OsiClpUserSolver;
00026 class OsiClpDisasterHandler;
00027 class CoinSet;
00028 static const double OsiClpInfinity = COIN_DBL_MAX;
00029 
00030 //#############################################################################
00031 
00038 class OsiClpSolverInterface :
00039   virtual public OsiSolverInterface {
00040   friend void 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 resolveGub(int needed);
00054   
00056   virtual void branchAndBound();
00057 
00065   void crossover(int options,int basis);
00067   
00083   virtual int canDoSimplexInterface() const;
00084 
00093   virtual void enableFactorization() const;
00094 
00096   virtual void disableFactorization() const;
00097   
00102   virtual bool basisIsAvailable() const;
00103   
00119   virtual void getBasisStatus(int* cstat, int* rstat) const;
00120   
00131   virtual int setBasisStatus(const int* cstat, const int* rstat);
00132   
00134   virtual void getReducedGradient(double* columnReducedCosts, 
00135                                   double * duals,
00136                                   const double * c) const ;
00137   
00139   virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
00140   
00145   virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
00146                            bool keepScaled=false) const;
00147   
00149   virtual void getBInvRow(int row, double* z) const;
00150   
00152   virtual void getBInvACol(int col, double* vec) const ;
00153   
00155   virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
00156   
00161   virtual void getBInvACol(CoinIndexedVector * vec) const ;
00162   
00164   virtual void getBInvCol(int col, double* vec) const ;
00165   
00170   virtual void getBasics(int* index) const;
00171 
00178   virtual void enableSimplexInterface(bool doingPrimal);
00180   void copyEnabledSuff(OsiClpSolverInterface & rhs);
00181   
00183   virtual void disableSimplexInterface();
00185   void copyEnabledStuff(ClpSimplex & rhs);
00186 
00194   virtual int pivot(int colIn, int colOut, int outStatus);
00195   
00207   virtual int primalPivotResult(int colIn, int sign, 
00208                                 int& colOut, int& outStatus, 
00209                                 double& t, CoinPackedVector* dx);
00210   
00217   virtual int dualPivotResult(int& colIn, int& sign, 
00218                               int colOut, int outStatus, 
00219                               double& t, CoinPackedVector* dx);
00220   
00221   
00223   //---------------------------------------------------------------------------
00239   // Set an integer parameter
00240   bool setIntParam(OsiIntParam key, int value);
00241   // Set an double parameter
00242   bool setDblParam(OsiDblParam key, double value);
00243   // Set a string parameter
00244   bool setStrParam(OsiStrParam key, const std::string & value);
00245   // Get an integer parameter
00246   bool getIntParam(OsiIntParam key, int& value) const;
00247   // Get an double parameter
00248   bool getDblParam(OsiDblParam key, double& value) const;
00249   // Get a string parameter
00250   bool getStrParam(OsiStrParam key, std::string& value) const;
00251   // Set a hint parameter - overrides OsiSolverInterface
00252   virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
00253                             OsiHintStrength strength=OsiHintTry,
00254                             void * otherInformation=NULL);
00256   
00257   //---------------------------------------------------------------------------
00259 
00260 
00261   virtual bool isAbandoned() const;
00263   virtual bool isProvenOptimal() const;
00265   virtual bool isProvenPrimalInfeasible() const;
00267   virtual bool isProvenDualInfeasible() const;
00269   virtual bool isPrimalObjectiveLimitReached() const;
00271   virtual bool isDualObjectiveLimitReached() const;
00273   virtual bool isIterationLimitReached() const;
00275   
00276   //---------------------------------------------------------------------------
00279   
00287   virtual CoinWarmStart *getEmptyWarmStart () const;
00288   
00290   virtual CoinWarmStart* getWarmStart() const;
00292   inline CoinWarmStartBasis* getPointerToWarmStart() 
00293   { return &basis_;}
00295   inline const CoinWarmStartBasis* getConstPointerToWarmStart() const 
00296   { return &basis_;}
00299   virtual bool setWarmStart(const CoinWarmStart* warmstart);
00309   virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
00310 
00312   void setColumnStatus(int iColumn, ClpSimplex::Status status);
00313 
00315   
00316   //---------------------------------------------------------------------------
00323 
00324   virtual void markHotStart();
00326   virtual void solveFromHotStart();
00328   virtual void unmarkHotStart();
00337   int startFastDual(int options);
00339   void stopFastDual();
00341   void setStuff(double tolerance,double increment);
00343   OsiRowCut * smallModelCut(const double * originalLower, const double * originalUpper,
00344                             int numberRowsAtContinuous,const int * whichGenerator,
00345                             int typeCut=0);
00349   OsiRowCut * modelCut(const double * originalLower, const double * originalUpper,
00350                        int numberRowsAtContinuous,const int * whichGenerator,
00351                        int typeCut=0);
00353   
00354   //---------------------------------------------------------------------------
00369 
00370   virtual int getNumCols() const {
00371     return modelPtr_->numberColumns(); }
00372   
00374   virtual int getNumRows() const {
00375     return modelPtr_->numberRows(); }
00376   
00378   virtual int getNumElements() const {
00379     int retVal = 0;
00380     const CoinPackedMatrix * matrix =modelPtr_->matrix();
00381     if ( matrix != NULL ) retVal=matrix->getNumElements();
00382     return retVal; }
00383 
00386     virtual std::string getRowName(int rowIndex,
00387                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;
00388     
00391     virtual std::string getColName(int colIndex,
00392                                    unsigned maxLen = static_cast<unsigned>(std::string::npos)) const;
00393     
00394   
00396   virtual const double * getColLower() const { return modelPtr_->columnLower(); }
00397   
00399   virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
00400   
00410   virtual const char * getRowSense() const;
00411   
00420   virtual const double * getRightHandSide() const ;
00421   
00430   virtual const double * getRowRange() const ;
00431   
00433   virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
00434   
00436   virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
00437   
00439   virtual const double * getObjCoefficients() const 
00440   { if (fakeMinInSimplex_)
00441       return linearObjective_ ;
00442     else
00443       return modelPtr_->objective(); }
00444   
00446   virtual double getObjSense() const 
00447   { return ((fakeMinInSimplex_)?-modelPtr_->optimizationDirection():
00448                                  modelPtr_->optimizationDirection()); }
00449   
00451   virtual bool isContinuous(int colNumber) const;
00453   virtual bool isBinary(int colIndex) const;
00454   
00459   virtual bool isInteger(int colIndex) const;
00460   
00462   virtual bool isIntegerNonBinary(int colIndex) const;
00463   
00465   virtual bool isFreeBinary(int colIndex) const; 
00471   virtual const char * getColType(bool refresh=false) const;
00472   
00478   bool isOptionalInteger(int colIndex) const;
00480   void setOptionalInteger(int index);
00481   
00483   virtual const CoinPackedMatrix * getMatrixByRow() const;
00484   
00486   virtual const CoinPackedMatrix * getMatrixByCol() const;
00487   
00489   virtual CoinPackedMatrix * getMutableMatrixByCol() const;
00490   
00492   virtual double getInfinity() const { return OsiClpInfinity; }
00494   
00497 
00498   virtual const double * getColSolution() const; 
00499   
00501   virtual const double * getRowPrice() const;
00502   
00504   virtual const double * getReducedCost() const; 
00505   
00508   virtual const double * getRowActivity() const; 
00509   
00511   virtual double getObjValue() const;
00512   
00515   virtual int getIterationCount() const 
00516   { return modelPtr_->numberIterations(); }
00517   
00535   virtual std::vector<double*> getDualRays(int maxNumRays,
00536                                            bool fullRay = false) const;
00548   virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
00549   
00551 
00552   
00553   //---------------------------------------------------------------------------
00554   
00557   //-------------------------------------------------------------------------
00561   virtual void setObjCoeff( int elementIndex, double elementValue );
00562   
00565   virtual void setColLower( int elementIndex, double elementValue );
00566   
00569   virtual void setColUpper( int elementIndex, double elementValue );
00570   
00572   virtual void setColBounds( int elementIndex,
00573                              double lower, double upper );
00574   
00583   virtual void setColSetBounds(const int* indexFirst,
00584                                const int* indexLast,
00585                                const double* boundList);
00586   
00589   virtual void setRowLower( int elementIndex, double elementValue );
00590   
00593   virtual void setRowUpper( int elementIndex, double elementValue ) ;
00594   
00596   virtual void setRowBounds( int elementIndex,
00597                              double lower, double upper ) ;
00598   
00600   virtual void setRowType(int index, char sense, double rightHandSide,
00601                           double range);
00602   
00611   virtual void setRowSetBounds(const int* indexFirst,
00612                                const int* indexLast,
00613                                const double* boundList);
00614   
00625   virtual void setRowSetTypes(const int* indexFirst,
00626                               const int* indexLast,
00627                               const char* senseList,
00628                               const double* rhsList,
00629                               const double* rangeList);
00634     virtual void setObjective(const double * array);
00635 
00640     virtual void setColLower(const double * array);
00641 
00646     virtual void setColUpper(const double * array);
00647 
00648 //    using OsiSolverInterface::setRowName ;
00650 //    virtual void setRowName(int rowIndex, std::string & name) ;
00651     virtual void setRowName(int rowIndex, std::string  name) ;
00652     
00653 //    using OsiSolverInterface::setColName ;
00655 //    virtual void setColName(int colIndex, std::string & name) ;
00656     virtual void setColName(int colIndex, std::string  name) ;
00657     
00659   
00660   //-------------------------------------------------------------------------
00664   virtual void setContinuous(int index);
00666   virtual void setInteger(int index);
00669   virtual void setContinuous(const int* indices, int len);
00672   virtual void setInteger(const int* indices, int len);
00674   inline int numberSOS() const
00675   { return numberSOS_;}
00677   inline const CoinSet * setInfo() const
00678   { return setInfo_;}
00688   virtual int findIntegersAndSOS(bool justCount);
00690   
00691   //-------------------------------------------------------------------------
00693   virtual void setObjSense(double s ) 
00694   { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
00695   
00706   virtual void setColSolution(const double * colsol);
00707   
00718   virtual void setRowPrice(const double * rowprice);
00719   
00720   //-------------------------------------------------------------------------
00725 
00726   //using OsiSolverInterface::addCol ;
00728   virtual void addCol(const CoinPackedVectorBase& vec,
00729                       const double collb, const double colub,   
00730                       const double obj);
00733   virtual void addCol(const CoinPackedVectorBase& vec,
00734                       const double collb, const double colub,   
00735                       const double obj, std::string name) ;
00737   virtual void addCol(int numberElements, const int * rows, const double * elements,
00738                       const double collb, const double colub,   
00739                       const double obj) ;
00742   virtual void addCol(int numberElements,
00743                       const int* rows, const double* elements,
00744                       const double collb, const double colub,   
00745                       const double obj, std::string name) ;
00747   virtual void addCols(const int numcols,
00748                        const CoinPackedVectorBase * const * cols,
00749                        const double* collb, const double* colub,   
00750                        const double* obj);
00752   virtual void addCols(const int numcols,
00753                        const int * columnStarts, const int * rows, const double * elements,
00754                        const double* collb, const double* colub,   
00755                        const double* obj);
00757   virtual void deleteCols(const int num, const int * colIndices);
00758   
00760   virtual void addRow(const CoinPackedVectorBase& vec,
00761                       const double rowlb, const double rowub);
00768     virtual void addRow(const CoinPackedVectorBase& vec,
00769                         const double rowlb, const double rowub,
00770                         std::string name) ;
00771   virtual void addRow(const CoinPackedVectorBase& vec,
00772                       const char rowsen, const double rowrhs,   
00773                       const double rowrng);
00775   virtual void addRow(int numberElements, const int * columns, const double * element,
00776                       const double rowlb, const double rowub) ;
00779     virtual void addRow(const CoinPackedVectorBase& vec,
00780                         const char rowsen, const double rowrhs,   
00781                         const double rowrng, std::string name) ;
00783   virtual void addRows(const int numrows,
00784                        const CoinPackedVectorBase * const * rows,
00785                        const double* rowlb, const double* rowub);
00787   virtual void addRows(const int numrows,
00788                        const CoinPackedVectorBase * const * rows,
00789                        const char* rowsen, const double* rowrhs,   
00790                        const double* rowrng);
00791 
00793   virtual void addRows(const int numrows,
00794                        const int * rowStarts, const int * columns, const double * element,
00795                        const double* rowlb, const double* rowub);
00797   void modifyCoefficient(int row, int column, double newElement,
00798                         bool keepZero=false)
00799         {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
00800 
00802   virtual void deleteRows(const int num, const int * rowIndices);
00805   virtual void saveBaseModel() ;
00809   virtual void restoreBaseModel(int numberRows);
00810   
00811   //-----------------------------------------------------------------------
00815   virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
00820   virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
00843     virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
00844                                           double effectivenessLb = 0.0);
00845 
00847 
00848   
00849   //---------------------------------------------------------------------------
00850   
00851 public:
00852   
00866   virtual void loadProblem(const CoinPackedMatrix& matrix,
00867                            const double* collb, const double* colub,   
00868                            const double* obj,
00869                            const double* rowlb, const double* rowub);
00870   
00878   virtual void assignProblem(CoinPackedMatrix*& matrix,
00879                              double*& collb, double*& colub, double*& obj,
00880                              double*& rowlb, double*& rowub);
00881   
00894   virtual void loadProblem(const CoinPackedMatrix& matrix,
00895                            const double* collb, const double* colub,
00896                            const double* obj,
00897                            const char* rowsen, const double* rowrhs,   
00898                            const double* rowrng);
00899   
00907   virtual void assignProblem(CoinPackedMatrix*& matrix,
00908                              double*& collb, double*& colub, double*& obj,
00909                              char*& rowsen, double*& rowrhs,
00910                              double*& rowrng);
00911   
00914   virtual void loadProblem(const ClpMatrixBase& matrix,
00915                            const double* collb, const double* colub,
00916                            const double* obj,
00917                            const double* rowlb, const double* rowub) ;
00918 
00921   virtual void loadProblem(const int numcols, const int numrows,
00922                            const CoinBigIndex * start, const int* index,
00923                            const double* value,
00924                            const double* collb, const double* colub,   
00925                            const double* obj,
00926                            const double* rowlb, const double* rowub);
00927   
00930   virtual void loadProblem(const int numcols, const int numrows,
00931                            const CoinBigIndex * start, const int* index,
00932                            const double* value,
00933                            const double* collb, const double* colub,   
00934                            const double* obj,
00935                            const char* rowsen, const double* rowrhs,   
00936                            const double* rowrng);
00938   virtual int loadFromCoinModel (  CoinModel & modelObject, bool keepSolution=false);
00939 
00940   using OsiSolverInterface::readMps ;
00943   virtual int readMps(const char *filename,
00944                       const char *extension = "mps") ;
00947   int readMps(const char *filename,bool keepNames,bool allowErrors);
00949   virtual int readMps (const char *filename, const char*extension,
00950                         int & numberSets, CoinSet ** & sets);
00951   
00956   virtual void writeMps(const char *filename,
00957                         const char *extension = "mps",
00958                         double objSense=0.0) const;
00967   virtual int writeMpsNative(const char *filename, 
00968                              const char ** rowNames, const char ** columnNames,
00969                              int formatType=0,int numberAcross=2,
00970                              double objSense=0.0) const ;
00972   virtual int readLp(const char *filename, const double epsilon = 1e-5);
00978   virtual void writeLp(const char *filename,
00979                        const char *extension = "lp",
00980                        double epsilon = 1e-5,
00981                        int numberAcross = 10,
00982                        int decimals = 5,
00983                        double objSense = 0.0,
00984                        bool useRowNames = true) const;
00989   virtual void writeLp(FILE *fp,
00990                double epsilon = 1e-5,
00991                int numberAcross = 10,
00992                int decimals = 5,
00993                double objSense = 0.0,
00994                bool useRowNames = true) const;
01000   virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
01002   virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
01004   
01015   virtual void passInMessageHandler(CoinMessageHandler * handler);
01017   void newLanguage(CoinMessages::Language language);
01018   void setLanguage(CoinMessages::Language language)
01019   {newLanguage(language);}
01021   void setLogLevel(int value);
01023   void generateCpp( FILE * fp);
01025   //---------------------------------------------------------------------------
01026   
01029 
01030   ClpSimplex * getModelPtr() const ;
01032   inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
01033   { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
01035   inline unsigned int specialOptions() const
01036   { return specialOptions_;}
01037   void setSpecialOptions(unsigned int value);
01039   inline int lastAlgorithm() const
01040   { return lastAlgorithm_;}
01042   inline void setLastAlgorithm(int value)
01043   { lastAlgorithm_ = value;}
01045   inline int cleanupScaling() const
01046   { return cleanupScaling_;}
01059   inline void setCleanupScaling(int value)
01060   { cleanupScaling_=value;}
01063   inline double smallestElementInCut() const
01064   { return smallestElementInCut_;}
01067   inline void setSmallestElementInCut(double value)
01068   { smallestElementInCut_=value;}
01075   inline double smallestChangeInCut() const
01076   { return smallestChangeInCut_;}
01083   inline void setSmallestChangeInCut(double value)
01084   { smallestChangeInCut_=value;}
01086   inline void setSolveOptions(const ClpSolve & options)
01087   { solveOptions_ = options;}
01091   virtual int tightenBounds(int lightweight=0);
01093   int infeasibleOtherWay(char * whichWay);
01095   virtual CoinBigIndex getSizeL() const;
01097   virtual CoinBigIndex getSizeU() const;
01099   const OsiClpDisasterHandler * disasterHandler() const
01100   { return disasterHandler_;}
01102   void passInDisasterHandler(OsiClpDisasterHandler * handler);
01104   ClpLinearObjective * fakeObjective() const
01105   { return fakeObjective_;}
01107   void setFakeObjective(ClpLinearObjective * fakeObjective);
01109   void setFakeObjective(double * fakeObjective);
01129   void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
01131   virtual void synchronizeModel();
01136   void setSpecialOptionsMutable(unsigned int value) const;
01137 
01139   
01140   //---------------------------------------------------------------------------
01141   
01144 
01145   OsiClpSolverInterface ();
01146   
01148   virtual OsiSolverInterface * clone(bool copyData = true) const;
01149   
01151   OsiClpSolverInterface (const OsiClpSolverInterface &);
01152   
01154   OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
01155   
01157   void releaseClp();
01158   
01160   OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs);
01161   
01163   virtual ~OsiClpSolverInterface ();
01164   
01166   virtual void reset();
01168   
01169   //---------------------------------------------------------------------------
01170   
01171 protected:
01173 
01174 
01175   virtual void applyRowCut(const OsiRowCut& rc);
01176   
01178   virtual void applyColCut(const OsiColCut& cc);
01180   
01181   //---------------------------------------------------------------------------
01182   
01183 protected:
01186 
01187   void gutsOfDestructor();
01188   
01190   void freeCachedResults() const;
01191   
01193   void freeCachedResults0() const;
01194   
01196   void freeCachedResults1() const;
01197   
01199   void extractSenseRhsRange() const;
01200   
01202   void fillParamMaps();
01211   CoinWarmStartBasis getBasis(ClpSimplex * model) const;
01220   void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
01222   void crunch();
01224   void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
01225                         const int * indices, const double * elements);
01226 public:
01229   void setBasis( const CoinWarmStartBasis & basis);
01231   inline void setBasis( )
01232   { setBasis(basis_,modelPtr_);}
01234   CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
01236   CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
01238   void deleteScaleFactors();
01240   inline const double * upRange() const
01241   { return rowActivity_;}
01242   inline const double * downRange() const
01243   { return columnActivity_;}
01245   inline void passInRanges(int * array)
01246   { whichRange_=array;}
01248   void setSOSData(int numberSOS,const char * type,
01249                   const int * start,const int * indices, const double * weights=NULL);
01251   void computeLargestAway();
01253   inline double largestAway() const
01254   { return largestAway_;}
01256   inline void setLargestAway(double value)
01257   { largestAway_ = value;}
01259   void lexSolve();
01261   
01262 protected:
01265 
01266   mutable ClpSimplex * modelPtr_;
01268 
01270 
01271   mutable char    *rowsense_;
01272   
01274   mutable double  *rhs_;
01275   
01279   mutable double  *rowrange_;
01280   
01283   mutable CoinWarmStartBasis* ws_;
01286   mutable double * rowActivity_;
01287   mutable double * columnActivity_;
01289   ClpNodeStuff stuff_;
01291   int numberSOS_;
01293   CoinSet * setInfo_;
01295   ClpSimplex * smallModel_;
01297   ClpFactorization * factorization_;
01300   double smallestElementInCut_;
01304   double smallestChangeInCut_;
01306   double largestAway_;
01308   char * spareArrays_;
01310   CoinWarmStartBasis basis_;
01312   int itlimOrig_;
01313   
01324   mutable int lastAlgorithm_;
01325   
01327   bool notOwned_;
01328   
01330   mutable CoinPackedMatrix *matrixByRow_;  
01331   
01333   CoinPackedMatrix *matrixByRowAtContinuous_;  
01334   
01336   char * integerInformation_;
01337   
01342   int * whichRange_;
01343 
01344   //std::map<OsiIntParam, ClpIntParam> intParamMap_;
01345   //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
01346   //std::map<OsiStrParam, ClpStrParam> strParamMap_;
01347   
01349   mutable bool fakeMinInSimplex_ ;
01356   mutable double *linearObjective_;
01357 
01359   mutable ClpDataSave saveData_;
01361   ClpSolve solveOptions_;
01374   int cleanupScaling_;
01402   mutable unsigned int specialOptions_;
01404   ClpSimplex * baseModel_;
01406   int lastNumberRows_;
01408   ClpSimplex * continuousModel_;
01410   OsiClpDisasterHandler * disasterHandler_ ;
01412   ClpLinearObjective * fakeObjective_;
01414   CoinDoubleArrayWithLength rowScale_; 
01416   CoinDoubleArrayWithLength columnScale_; 
01418 };
01419   
01420 class OsiClpDisasterHandler : public ClpDisasterHandler {
01421 public:
01425 
01426   virtual void intoSimplex();
01428   virtual bool check() const ;
01430   virtual void saveInfo();
01432   virtual int typeOfDisaster();
01434   
01435   
01440   OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL);
01442   virtual ~OsiClpDisasterHandler();
01443   // Copy
01444   OsiClpDisasterHandler(const OsiClpDisasterHandler&);
01445   // Assignment
01446   OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&);
01448   virtual ClpDisasterHandler * clone() const;
01449 
01451   
01456   void setOsiModel(OsiClpSolverInterface * model);
01458   inline OsiClpSolverInterface * osiModel() const
01459   { return osiModel_;}
01461   inline void setWhereFrom(int value)
01462   { whereFrom_=value;}
01464   inline int whereFrom() const
01465   { return whereFrom_;}
01467   inline void setPhase(int value)
01468   { phase_=value;}
01470   inline int phase() const
01471   { return phase_;}
01473   bool inTrouble() const;
01474   
01476   
01477   
01478 protected:
01482 
01483   OsiClpSolverInterface * osiModel_;
01491   int whereFrom_;
01499   int phase_;
01501   bool inTrouble_;
01503 };
01504 // So unit test can find out if NDEBUG set
01505 bool OsiClpHasNDEBUG();
01506 //#############################################################################
01508 void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
01509 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 3 Jun 2015 for Cgl by  doxygen 1.6.1