OsiCbcSolverInterface.hpp

Go to the documentation of this file.

// $Id: OsiCbcSolverInterface.hpp 1899 2013-04-09 18:12:08Z stefan $
// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef OsiCbcSolverInterface_H
#define OsiCbcSolverInterface_H
 
#include <string>
#include <cfloat>
#include <map>
#include "CbcModel.hpp"
#include "CoinPackedMatrix.hpp"
#include "OsiSolverInterface.hpp"
#include "CbcStrategy.hpp"
#include "CoinWarmStartBasis.hpp"
 
class OsiRowCut;
class OsiClpSolverInterface;
static const double OsiCbcInfinity = COIN_DBL_MAX;
 
//#############################################################################
 
class OsiCbcSolverInterface :
  virtual public OsiSolverInterface {
  friend void OsiCbcSolverInterfaceUnitTest(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);
  // 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;
  // Set a hint parameter - overrides OsiSolverInterface
  virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
                            OsiHintStrength strength=OsiHintTry,
                            void * otherInformation=NULL);
    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
                              OsiHintStrength& strength,
                              void *& otherInformation) const;
 
  using OsiSolverInterface::getHintParam ;
    virtual bool getHintParam(OsiHintParam key, bool& yesNo,
                              OsiHintStrength& strength) 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 CoinWarmStart *getEmptyWarmStart () const;
  
  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;
  
  
  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;
  
 
 
    virtual std::string dfltRowColName(char rc,
                                 int ndx, unsigned digits = 7) const ;
 
    virtual std::string getObjName (unsigned maxLen = std::string::npos) const ;
 
    virtual void setObjName (std::string name) ;
 
    virtual std::string getRowName(int rowIndex,
                                   unsigned maxLen = std::string::npos) const ;
 
    virtual const OsiNameVec &getRowNames() ;
 
    virtual void setRowName(int ndx, std::string name) ;
 
    virtual void setRowNames(OsiNameVec &srcNames,
                     int srcStart, int len, int tgtStart) ;
 
    virtual void deleteRowNames(int tgtStart, int len) ;
  
    virtual std::string getColName(int colIndex,
                                   unsigned maxLen = std::string::npos) const ;
 
    virtual const OsiNameVec &getColNames() ;
 
    virtual void setColName(int ndx, std::string name) ;
 
    virtual void setColNames(OsiNameVec &srcNames,
                     int srcStart, int len, int tgtStart) ;
 
    virtual void deleteColNames(int tgtStart, int len) ;
 
 
  
  //---------------------------------------------------------------------------
  
  //-------------------------------------------------------------------------
  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);
  virtual void addCol(int numberElements, const int * rows, const double * elements,
                      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);
  
  //-----------------------------------------------------------------------
  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
 
  
  //---------------------------------------------------------------------------
  
public:
  
  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 CoinBigIndex * 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 CoinBigIndex * 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;
  virtual int writeMpsNative(const char *filename, 
                             const char ** rowNames, const char ** columnNames,
                             int formatType=0,int numberAcross=2,
                             double objSense=0.0) const ;
  
  void newLanguage(CoinMessages::Language language);
  void setLanguage(CoinMessages::Language language)
  {newLanguage(language);}
  //---------------------------------------------------------------------------
  
  inline CbcModel * getModelPtr() const 
  { return modelPtr_;}
  inline OsiSolverInterface * getRealSolverPtr() const 
  { return modelPtr_->solver();}
  inline void setCutoff(double value) 
  { modelPtr_->setCutoff(value);}
  inline double getCutoff() const
  { return modelPtr_->getCutoff();}
  inline void setMaximumNodes( int value)
  { modelPtr_->setMaximumNodes(value);}
  inline int getMaximumNodes() const
  { return modelPtr_->getMaximumNodes();}
  inline void setMaximumSolutions( int value) 
  { modelPtr_->setMaximumSolutions(value);}
  inline int getMaximumSolutions() const 
  { return modelPtr_->getMaximumSolutions();}
  inline void setMaximumSeconds( double value) 
  { modelPtr_->setMaximumSeconds(value);}
  inline double getMaximumSeconds() const 
  { return modelPtr_->getMaximumSeconds();}
  inline bool isNodeLimitReached() const
  { return modelPtr_->isNodeLimitReached();}
  inline bool isSolutionLimitReached() const
  { return modelPtr_->isSolutionLimitReached();}
  inline int getNodeCount() const
  { return modelPtr_->getNodeCount();}
    inline int status() const
  { return modelPtr_->status();}
  virtual void passInMessageHandler(CoinMessageHandler * handler);
  
  //---------------------------------------------------------------------------
  
  OsiCbcSolverInterface (OsiSolverInterface * solver=NULL,
                         CbcStrategy * strategy=NULL);
  
  virtual OsiSolverInterface * clone(bool copyData = true) const;
  
  OsiCbcSolverInterface (const OsiCbcSolverInterface &);
#if 0    
  OsiCbcSolverInterface (CbcModel * rhs, bool reallyOwn=false);
  
  void releaseCbc();
#endif    
  OsiCbcSolverInterface & operator=(const OsiCbcSolverInterface& rhs);
  
  virtual ~OsiCbcSolverInterface ();
  
  //---------------------------------------------------------------------------
  
protected:
 
 
  virtual void applyRowCut(const OsiRowCut& rc);
  
  virtual void applyColCut(const OsiColCut& cc);
 
  mutable CbcModel * modelPtr_;
};
// So unit test can find out if NDEBUG set
bool OsiCbcHasNDEBUG();
 
//#############################################################################
void OsiCbcSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
 
#endif