OsiGlpkSolverInterface.hpp

Go to the documentation of this file.
00001 //-----------------------------------------------------------------------------
00002 // name:     OSI Interface for GLPK
00003 //-----------------------------------------------------------------------------
00004 // Copyright (C) 2001, Vivian De Smedt, Braden Hunsaker
00005 // Copyright (C) 2003  University of Pittsburgh
00006 //   University of Pittsburgh coding done by Brady Hunsaker
00007 // All Rights Reserved.
00008 // This code is licensed under the terms of the Eclipse Public License (EPL).
00009 
00010 #ifndef OsiGlpkSolverInterface_H
00011 #define OsiGlpkSolverInterface_H
00012 
00013 #include <string>
00014 #include "OsiSolverInterface.hpp"
00015 #include "CoinPackedMatrix.hpp"
00016 #include "CoinWarmStartBasis.hpp"
00017 
00023 #ifndef LPX
00024 #define LPX glp_prob
00025 #endif
00026 
00027 #ifndef GLP_PROB_DEFINED
00028 #define GLP_PROB_DEFINED
00029 // Glpk < 4.48:
00030 typedef struct { double _opaque_prob[100]; } glp_prob;
00031 // Glpk 4.48: typedef struct glp_prob glp_prob;
00032 #endif
00033 
00034 class OsiGlpkSolverInterface : virtual public OsiSolverInterface {
00035   friend void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
00036   
00037 public:
00038   
00039   //---------------------------------------------------------------------------
00042 
00043   virtual void initialSolve();
00044   
00046   virtual void resolve();
00047   
00049   virtual void branchAndBound();
00051   
00052   //---------------------------------------------------------------------------
00068     // Set an integer parameter
00069     bool setIntParam(OsiIntParam key, int value);
00070     // Set an double parameter
00071     bool setDblParam(OsiDblParam key, double value);
00072     // Set a string parameter
00073     bool setStrParam(OsiStrParam key, const std::string & value);
00074     // Set a hint parameter
00075     bool setHintParam(OsiHintParam key, bool sense = true,
00076                       OsiHintStrength strength = OsiHintTry, void *info = 0) ;
00077     // Get an integer parameter
00078     bool getIntParam(OsiIntParam key, int& value) const;
00079     // Get an double parameter
00080     bool getDblParam(OsiDblParam key, double& value) const;
00081     // Get a string parameter
00082     bool getStrParam(OsiStrParam key, std::string& value) const;
00084 
00085   //---------------------------------------------------------------------------
00087 
00088 
00089     virtual bool isAbandoned() const;
00091     virtual bool isProvenOptimal() const;
00093     virtual bool isProvenPrimalInfeasible() const;
00095     virtual bool isProvenDualInfeasible() const;
00097     virtual bool isPrimalObjectiveLimitReached() const;
00099     virtual bool isDualObjectiveLimitReached() const;
00101     virtual bool isIterationLimitReached() const;
00103     virtual bool isTimeLimitReached() const;
00105     virtual bool isFeasible() const;
00107 
00108   //---------------------------------------------------------------------------
00117   inline CoinWarmStart *getEmptyWarmStart () const
00118   { return (dynamic_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
00120     virtual CoinWarmStart* getWarmStart() const;
00123     virtual bool setWarmStart(const CoinWarmStart* warmstart);
00125 
00126   //---------------------------------------------------------------------------
00133 
00134     virtual void markHotStart();
00136     virtual void solveFromHotStart();
00138     virtual void unmarkHotStart();
00140 
00141   //---------------------------------------------------------------------------
00156 
00157       virtual int getNumCols() const;
00158   
00160       virtual int getNumRows() const;
00161   
00163       virtual int getNumElements() const;
00164           
00166       virtual const double * getColLower() const;
00167   
00169       virtual const double * getColUpper() const;
00170   
00180       virtual const char * getRowSense() const;
00181   
00190       virtual const double * getRightHandSide() const;
00191   
00200       virtual const double * getRowRange() const;
00201   
00203       virtual const double * getRowLower() const;
00204   
00206       virtual const double * getRowUpper() const;
00207   
00209       virtual const double * getObjCoefficients() const;
00210   
00212       virtual double getObjSense() const;
00213 
00215       virtual bool isContinuous(int colNumber) const;
00216 
00217 #if 0
00219       virtual bool isBinary(int columnNumber) const;
00220   
00225       virtual bool isInteger(int columnNumber) const;
00226   
00228       virtual bool isIntegerNonBinary(int columnNumber) const;
00229   
00231       virtual bool isFreeBinary(int columnNumber) const;
00232 #endif
00233   
00235       virtual const CoinPackedMatrix * getMatrixByRow() const;
00236   
00238       virtual const CoinPackedMatrix * getMatrixByCol() const;
00239   
00241       virtual double getInfinity() const;
00243     
00246 
00247       virtual const double * getColSolution() const;
00248   
00250       virtual const double * getRowPrice() const;
00251   
00253       virtual const double * getReducedCost() const;
00254   
00257       virtual const double * getRowActivity() const;
00258   
00260       virtual double getObjValue() const;
00261   
00264       virtual int getIterationCount() const;
00265   
00277       virtual std::vector<double*> getDualRays(int maxNumRays,
00278                                                bool fullRay=false) const;
00296       virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
00297   
00298 #if 0
00299 
00301       virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
00302         const;
00303 #endif
00304 
00305 
00306   
00307   //---------------------------------------------------------------------------
00308 
00311     //-------------------------------------------------------------------------
00315       virtual void setObjCoeff( int elementIndex, double elementValue );
00316 
00317       using OsiSolverInterface::setColLower ;
00320       virtual void setColLower( int elementIndex, double elementValue );
00321       
00322       using OsiSolverInterface::setColUpper ;
00325       virtual void setColUpper( int elementIndex, double elementValue );
00326       
00330       virtual void setColBounds( int elementIndex,
00331                                  double lower, double upper );
00332     
00341       virtual void setColSetBounds(const int* indexFirst,
00342                                    const int* indexLast,
00343                                    const double* boundList);
00344       
00347       virtual void setRowLower( int elementIndex, double elementValue );
00348       
00351       virtual void setRowUpper( int elementIndex, double elementValue );
00352     
00356       virtual void setRowBounds( int elementIndex,
00357                                  double lower, double upper );
00358     
00360       virtual void setRowType(int index, char sense, double rightHandSide,
00361                               double range);
00362     
00371       virtual void setRowSetBounds(const int* indexFirst,
00372                                    const int* indexLast,
00373                                    const double* boundList);
00374     
00385       virtual void setRowSetTypes(const int* indexFirst,
00386                                   const int* indexLast,
00387                                   const char* senseList,
00388                                   const double* rhsList,
00389                                   const double* rangeList);
00391     
00392     //-------------------------------------------------------------------------
00396       virtual void setContinuous(int index);
00398       virtual void setInteger(int index);
00401       virtual void setContinuous(const int* indices, int len);
00404       virtual void setInteger(const int* indices, int len);
00406     
00407     //-------------------------------------------------------------------------
00409     virtual void setObjSense(double s);
00410     
00421     virtual void setColSolution(const double * colsol);
00422     
00433     virtual void setRowPrice(const double * rowprice);
00434     
00435     //-------------------------------------------------------------------------
00440 
00441       using OsiSolverInterface::addCol ;
00443       virtual void addCol(const CoinPackedVectorBase& vec,
00444                           const double collb, const double colub,   
00445                           const double obj);
00446 
00447       using OsiSolverInterface::addCols ;
00449       virtual void addCols(const int numcols,
00450                            const CoinPackedVectorBase * const * cols,
00451                            const double* collb, const double* colub,   
00452                            const double* obj);
00454       virtual void deleteCols(const int num, const int * colIndices);
00455     
00456       using OsiSolverInterface::addRow ;
00458       virtual void addRow(const CoinPackedVectorBase& vec,
00459                           const double rowlb, const double rowub);
00461       virtual void addRow(const CoinPackedVectorBase& vec,
00462                           const char rowsen, const double rowrhs,   
00463                           const double rowrng);
00464 
00465       using OsiSolverInterface::addRows ;
00467       virtual void addRows(const int numrows,
00468                            const CoinPackedVectorBase * const * rows,
00469                            const double* rowlb, const double* rowub);
00471       virtual void addRows(const int numrows,
00472                            const CoinPackedVectorBase * const * rows,
00473                            const char* rowsen, const double* rowrhs,   
00474                            const double* rowrng);
00476       virtual void deleteRows(const int num, const int * rowIndices);
00477     
00478 #if 0
00479   // ??? implemented in OsiSolverInterface
00480       //-----------------------------------------------------------------------
00502       virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
00503                                             double effectivenessLb = 0.0);
00504 #endif
00505 
00506 
00507 
00508   //---------------------------------------------------------------------------
00509 
00523     virtual void loadProblem(const CoinPackedMatrix& matrix,
00524                              const double* collb, const double* colub,   
00525                              const double* obj,
00526                              const double* rowlb, const double* rowub);
00527                             
00535     virtual void assignProblem(CoinPackedMatrix*& matrix,
00536                                double*& collb, double*& colub, double*& obj,
00537                                double*& rowlb, double*& rowub);
00538 
00551     virtual void loadProblem(const CoinPackedMatrix& matrix,
00552                              const double* collb, const double* colub,
00553                              const double* obj,
00554                              const char* rowsen, const double* rowrhs,   
00555                              const double* rowrng);
00556 
00564     virtual void assignProblem(CoinPackedMatrix*& matrix,
00565                                double*& collb, double*& colub, double*& obj,
00566                                char*& rowsen, double*& rowrhs,
00567                                double*& rowrng);
00568 
00571     virtual void loadProblem(const int numcols, const int numrows,
00572                              const int* start, const int* index,
00573                              const double* value,
00574                              const double* collb, const double* colub,   
00575                              const double* obj,
00576                              const double* rowlb, const double* rowub);
00577 
00580     virtual void loadProblem(const int numcols, const int numrows,
00581                              const int* start, const int* index,
00582                              const double* value,
00583                              const double* collb, const double* colub,   
00584                              const double* obj,
00585                              const char* rowsen, const double* rowrhs,   
00586                              const double* rowrng);
00587 
00588     using OsiSolverInterface::readMps ;
00590     virtual int readMps(const char *filename,
00591                          const char *extension = "mps");
00592 
00597     virtual void writeMps(const char *filename,
00598                           const char *extension = "mps",
00599                           double objSense=0.0) const;
00601 
00602   //---------------------------------------------------------------------------
00603 
00610 
00613     void setObjName (std::string name) ;
00614 
00620     void setRowName(int ndx, std::string name) ;
00621 
00627     void setColName(int ndx, std::string name) ;
00628 
00630 
00631   //---------------------------------------------------------------------------
00632 
00635   enum keepCachedFlag
00636   {
00638     KEEPCACHED_NONE    = 0,
00640     KEEPCACHED_COLUMN  = 1,
00642     KEEPCACHED_ROW     = 2,
00644     KEEPCACHED_MATRIX  = 4,
00646     KEEPCACHED_RESULTS = 8,
00648     KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
00650     KEEPCACHED_ALL     = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
00652     FREECACHED_COLUMN  = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN,
00654     FREECACHED_ROW     = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW,
00656     FREECACHED_MATRIX  = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX,
00658     FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS
00659   };
00660 
00662   LPX * getModelPtr();
00663 
00665   
00674   static void incrementInstanceCounter() { ++numInstances_; }
00675     
00683   static void decrementInstanceCounter();
00684     
00686   static unsigned int getNumInstances() { return numInstances_; }
00688 
00689 
00692 
00693   OsiGlpkSolverInterface(); 
00694   
00696   virtual OsiSolverInterface * clone(bool copyData = true) const;
00697   
00699   OsiGlpkSolverInterface( const OsiGlpkSolverInterface& );
00700   
00702   OsiGlpkSolverInterface& operator=( const OsiGlpkSolverInterface& rhs );
00703   
00705   virtual ~OsiGlpkSolverInterface();
00706 
00708   virtual void reset();
00710   
00711 protected:
00712   
00715 
00716   virtual void applyRowCut( const OsiRowCut & rc );
00717   
00721   virtual void applyColCut( const OsiColCut & cc );
00722 
00724   LPX * getMutableModelPtr() const;
00725 
00727  
00728 private: 
00731     
00733   void gutsOfCopy( const OsiGlpkSolverInterface & source );
00734   
00736   void gutsOfConstructor();
00737   
00739   void gutsOfDestructor();
00740 
00742   void freeCachedColRim();
00743 
00745   void freeCachedRowRim();
00746 
00748   void freeCachedResults();
00749   
00751   void freeCachedMatrix();
00752 
00754   void freeCachedData( int keepCached = KEEPCACHED_NONE );
00755 
00757   void freeAllMemory();
00758 
00760   void printBounds(); 
00761 
00763   void fillColBounds() const;
00765   
00766   
00769 
00770   mutable LPX* lp_;
00771   
00773   static unsigned int numInstances_;
00774 
00775 
00776   // Remember whether simplex or b&b was most recently done
00777   // 0 = simplex;  1 = b&b
00778   int bbWasLast_; 
00779 
00780   // Int parameters.
00782   int maxIteration_;
00784   int hotStartMaxIteration_;
00786   int nameDisc_;
00787 
00788   // Double parameters.
00790   double dualObjectiveLimit_;
00792   double primalObjectiveLimit_;
00794   double dualTolerance_;
00796   double primalTolerance_;
00798   double objOffset_;
00799 
00800   // String parameters
00802   std::string probName_;
00803 
00805   mutable void *info_[OsiLastHintParam] ;
00806 
00807 
00809 
00811   int hotStartCStatSize_;
00813   int *hotStartCStat_;
00815   double *hotStartCVal_;
00817   double *hotStartCDualVal_;
00818 
00820   int hotStartRStatSize_;
00822   int *hotStartRStat_;
00824   double *hotStartRVal_;
00826   double *hotStartRDualVal_;
00827 
00828   // Status information
00830   bool isIterationLimitReached_;
00832   bool isTimeLimitReached_;
00834   bool isAbandoned_;
00840   bool isObjLowerLimitReached_;
00846   bool isObjUpperLimitReached_;
00848   bool isPrimInfeasible_;
00850   bool isDualInfeasible_;
00852   bool isFeasible_;
00853 
00856 
00858   mutable int iter_used_;
00859 
00861   mutable double  *obj_;
00862   
00864   mutable double  *collower_;
00865   
00867   mutable double  *colupper_;
00868   
00870   mutable char    *ctype_;
00871   
00873   mutable char    *rowsense_;
00874   
00876   mutable double  *rhs_;
00877   
00879   mutable double  *rowrange_;
00880   
00882   mutable double  *rowlower_;
00883   
00885   mutable double  *rowupper_;
00886   
00888   mutable double  *colsol_;
00889   
00891   mutable double  *rowsol_;
00892 
00894   mutable double  *redcost_;
00895 
00897   mutable double  *rowact_;
00898 
00900   mutable CoinPackedMatrix *matrixByRow_;  
00901   
00903   mutable CoinPackedMatrix *matrixByCol_;  
00905 
00906 };
00907 
00908 //#############################################################################
00910 void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
00911 
00912 #endif // OsiGlpkSolverInterface_H
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

Generated on 31 Oct 2014 for Osi by  doxygen 1.6.1