OsiCbcSolverInterface.hpp

Go to the documentation of this file.

// $Id$
// 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 CoinBigIndex 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(std::string::size_type maxLen = std::string::npos) const;
 
  virtual void setObjName(std::string name);
 
  virtual std::string getRowName(int rowIndex,
    std::string::size_type 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,
    std::string::size_type 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