OsiGlpkSolverInterface.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// name:     OSI Interface for GLPK
//-----------------------------------------------------------------------------
// Copyright (C) 2001, Vivian De Smedt, Braden Hunsaker
// Copyright (C) 2003  University of Pittsburgh
//   University of Pittsburgh coding done by Brady Hunsaker
// All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).

#ifndef OsiGlpkSolverInterface_H
#define OsiGlpkSolverInterface_H

#include <string>
#include "OsiSolverInterface.hpp"
#include "CoinPackedMatrix.hpp"
#include "CoinWarmStartBasis.hpp"

#ifndef LPX
#define LPX glp_prob
#endif

#ifndef GLP_PROB_DEFINED
#define GLP_PROB_DEFINED
// Glpk < 4.48:
typedef struct { double _opaque_prob[100]; } glp_prob;
// Glpk 4.48: typedef struct glp_prob glp_prob;
#endif

class OsiGlpkSolverInterface : virtual public OsiSolverInterface {
  friend void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
  
public:
  
  //---------------------------------------------------------------------------
  virtual void initialSolve();
  
  virtual void resolve();
  
  virtual void branchAndBound();
  
  //---------------------------------------------------------------------------
    // Set an integer parameter
    bool setIntParam(OsiIntParam key, int value);
    // Set an double parameter
    bool setDblParam(OsiDblParam key, double value);
    // Set a string parameter
    bool setStrParam(OsiStrParam key, const std::string & value);
    // Set a hint parameter
    bool setHintParam(OsiHintParam key, bool sense = true,
                      OsiHintStrength strength = OsiHintTry, void *info = 0) ;
    // Get an integer parameter
    bool getIntParam(OsiIntParam key, int& value) const;
    // Get an double parameter
    bool getDblParam(OsiDblParam key, double& value) const;
    // Get a string parameter
    bool getStrParam(OsiStrParam key, std::string& value) const;

  //---------------------------------------------------------------------------

    virtual bool isAbandoned() const;
    virtual bool isProvenOptimal() const;
    virtual bool isProvenPrimalInfeasible() const;
    virtual bool isProvenDualInfeasible() const;
    virtual bool isPrimalObjectiveLimitReached() const;
    virtual bool isDualObjectiveLimitReached() const;
    virtual bool isIterationLimitReached() const;
    virtual bool isTimeLimitReached() const;
    virtual bool isFeasible() const;

  //---------------------------------------------------------------------------
  inline CoinWarmStart *getEmptyWarmStart () const
  { return (dynamic_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
    virtual CoinWarmStart* getWarmStart() const;
    virtual bool setWarmStart(const CoinWarmStart* warmstart);

  //---------------------------------------------------------------------------
    virtual void markHotStart();
    virtual void solveFromHotStart();
    virtual void unmarkHotStart();

  //---------------------------------------------------------------------------
      virtual int getNumCols() const;
  
      virtual int getNumRows() const;
  
      virtual int getNumElements() const;
          
      virtual const double * getColLower() const;
  
      virtual const double * getColUpper() const;
  
      virtual const char * getRowSense() const;
  
      virtual const double * getRightHandSide() const;
  
      virtual const double * getRowRange() const;
  
      virtual const double * getRowLower() const;
  
      virtual const double * getRowUpper() const;
  
      virtual const double * getObjCoefficients() const;
  
      virtual double getObjSense() const;

      virtual bool isContinuous(int colNumber) const;

#if 0
      virtual bool isBinary(int columnNumber) const;
  
      virtual bool isInteger(int columnNumber) const;
  
      virtual bool isIntegerNonBinary(int columnNumber) const;
  
      virtual bool isFreeBinary(int columnNumber) const;
#endif
  
      virtual const CoinPackedMatrix * getMatrixByRow() const;
  
      virtual const CoinPackedMatrix * getMatrixByCol() const;
  
      virtual double getInfinity() const;
    
      virtual const double * getColSolution() const;
  
      virtual const double * getRowPrice() const;
  
      virtual const double * getReducedCost() const;
  
      virtual const double * getRowActivity() const;
  
      virtual double getObjValue() const;
  
      virtual int getIterationCount() const;
  
      virtual std::vector<double*> getDualRays(int maxNumRays,
                                               bool fullRay=false) const;
      virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
  
#if 0

      virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
        const;
#endif


  
  //---------------------------------------------------------------------------

    //-------------------------------------------------------------------------
      virtual void setObjCoeff( int elementIndex, double elementValue );

      using OsiSolverInterface::setColLower ;
      virtual void setColLower( int elementIndex, double elementValue );
      
      using OsiSolverInterface::setColUpper ;
      virtual void setColUpper( int elementIndex, double elementValue );
      
      virtual void setColBounds( int elementIndex,
                                 double lower, double upper );
    
      virtual void setColSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
      
      virtual void setRowLower( int elementIndex, double elementValue );
      
      virtual void setRowUpper( int elementIndex, double elementValue );
    
      virtual void setRowBounds( int elementIndex,
                                 double lower, double upper );
    
      virtual void setRowType(int index, char sense, double rightHandSide,
                              double range);
    
      virtual void setRowSetBounds(const int* indexFirst,
                                   const int* indexLast,
                                   const double* boundList);
    
      virtual void setRowSetTypes(const int* indexFirst,
                                  const int* indexLast,
                                  const char* senseList,
                                  const double* rhsList,
                                  const double* rangeList);
    
    //-------------------------------------------------------------------------
      virtual void setContinuous(int index);
      virtual void setInteger(int index);
      virtual void setContinuous(const int* indices, int len);
      virtual void setInteger(const int* indices, int len);
    
    //-------------------------------------------------------------------------
    virtual void setObjSense(double s);
    
    virtual void setColSolution(const double * colsol);
    
    virtual void setRowPrice(const double * rowprice);
    
    //-------------------------------------------------------------------------

      using OsiSolverInterface::addCol ;
      virtual void addCol(const CoinPackedVectorBase& vec,
                          const double collb, const double colub,   
                          const double obj);

      using OsiSolverInterface::addCols ;
      virtual void addCols(const int numcols,
                           const CoinPackedVectorBase * const * cols,
                           const double* collb, const double* colub,   
                           const double* obj);
      virtual void deleteCols(const int num, const int * colIndices);
    
      using OsiSolverInterface::addRow ;
      virtual void addRow(const CoinPackedVectorBase& vec,
                          const double rowlb, const double rowub);
      virtual void addRow(const CoinPackedVectorBase& vec,
                          const char rowsen, const double rowrhs,   
                          const double rowrng);

      using OsiSolverInterface::addRows ;
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const double* rowlb, const double* rowub);
      virtual void addRows(const int numrows,
                           const CoinPackedVectorBase * const * rows,
                           const char* rowsen, const double* rowrhs,   
                           const double* rowrng);
      virtual void deleteRows(const int num, const int * rowIndices);
    
#if 0
  // ??? implemented in OsiSolverInterface
      //-----------------------------------------------------------------------
      virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
                                            double effectivenessLb = 0.0);
#endif



  //---------------------------------------------------------------------------

    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const double* rowlb, const double* rowub);
                            
    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               double*& rowlb, double*& rowub);

    virtual void loadProblem(const CoinPackedMatrix& matrix,
                             const double* collb, const double* colub,
                             const double* obj,
                             const char* rowsen, const double* rowrhs,   
                             const double* rowrng);

    virtual void assignProblem(CoinPackedMatrix*& matrix,
                               double*& collb, double*& colub, double*& obj,
                               char*& rowsen, double*& rowrhs,
                               double*& rowrng);

    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const double* rowlb, const double* rowub);

    virtual void loadProblem(const int numcols, const int numrows,
                             const int* start, const int* index,
                             const double* value,
                             const double* collb, const double* colub,   
                             const double* obj,
                             const char* rowsen, const double* rowrhs,   
                             const double* rowrng);

    using OsiSolverInterface::readMps ;
    virtual int readMps(const char *filename,
                         const char *extension = "mps");

    virtual void writeMps(const char *filename,
                          const char *extension = "mps",
                          double objSense=0.0) const;

  //---------------------------------------------------------------------------


    void setObjName (std::string name) ;

    void setRowName(int ndx, std::string name) ;

    void setColName(int ndx, std::string name) ;


  //---------------------------------------------------------------------------

  enum keepCachedFlag
  {
    KEEPCACHED_NONE    = 0,
    KEEPCACHED_COLUMN  = 1,
    KEEPCACHED_ROW     = 2,
    KEEPCACHED_MATRIX  = 4,
    KEEPCACHED_RESULTS = 8,
    KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
    KEEPCACHED_ALL     = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
    FREECACHED_COLUMN  = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN,
    FREECACHED_ROW     = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW,
    FREECACHED_MATRIX  = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX,
    FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS
  };

  LPX * getModelPtr();

  
  static void incrementInstanceCounter() { ++numInstances_; }
    
  static void decrementInstanceCounter();
    
  static unsigned int getNumInstances() { return numInstances_; }


  OsiGlpkSolverInterface(); 
  
  virtual OsiSolverInterface * clone(bool copyData = true) const;
  
  OsiGlpkSolverInterface( const OsiGlpkSolverInterface& );
  
  OsiGlpkSolverInterface& operator=( const OsiGlpkSolverInterface& rhs );
  
  virtual ~OsiGlpkSolverInterface();

  virtual void reset();
  
protected:
  
  virtual void applyRowCut( const OsiRowCut & rc );
  
  virtual void applyColCut( const OsiColCut & cc );

  LPX * getMutableModelPtr() const;

 
private: 
    
  void gutsOfCopy( const OsiGlpkSolverInterface & source );
  
  void gutsOfConstructor();
  
  void gutsOfDestructor();

  void freeCachedColRim();

  void freeCachedRowRim();

  void freeCachedResults();
  
  void freeCachedMatrix();

  void freeCachedData( int keepCached = KEEPCACHED_NONE );

  void freeAllMemory();

  void printBounds(); 

  void fillColBounds() const;
  
  
  mutable LPX* lp_;
  
  static unsigned int numInstances_;


  // Remember whether simplex or b&b was most recently done
  // 0 = simplex;  1 = b&b
  int bbWasLast_; 

  // Int parameters.
  int maxIteration_;
  int hotStartMaxIteration_;
  int nameDisc_;

  // Double parameters.
  double dualObjectiveLimit_;
  double primalObjectiveLimit_;
  double dualTolerance_;
  double primalTolerance_;
  double objOffset_;

  // String parameters
  std::string probName_;

  mutable void *info_[OsiLastHintParam] ;



  int hotStartCStatSize_;
  int *hotStartCStat_;
  double *hotStartCVal_;
  double *hotStartCDualVal_;

  int hotStartRStatSize_;
  int *hotStartRStat_;
  double *hotStartRVal_;
  double *hotStartRDualVal_;

  // Status information
  bool isIterationLimitReached_;
  bool isTimeLimitReached_;
  bool isAbandoned_;
  bool isObjLowerLimitReached_;
  bool isObjUpperLimitReached_;
  bool isPrimInfeasible_;
  bool isDualInfeasible_;
  bool isFeasible_;


  mutable int iter_used_;

  mutable double  *obj_;
  
  mutable double  *collower_;
  
  mutable double  *colupper_;
  
  mutable char    *ctype_;
  
  mutable char    *rowsense_;
  
  mutable double  *rhs_;
  
  mutable double  *rowrange_;
  
  mutable double  *rowlower_;
  
  mutable double  *rowupper_;
  
  mutable double  *colsol_;
  
  mutable double  *rowsol_;

  mutable double  *redcost_;

  mutable double  *rowact_;

  mutable CoinPackedMatrix *matrixByRow_;  
  
  mutable CoinPackedMatrix *matrixByCol_;  

};

//#############################################################################
void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);

#endif // OsiGlpkSolverInterface_H