OsiGrbSolverInterface.hpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// name:     OSI Interface for Gurobi
// template: OSI Cplex Interface written by T. Achterberg
// author:   Stefan Vigerske
//           Humboldt University Berlin
// date:     09/02/2009
// license:  this file may be freely distributed under the terms of EPL
// comments: please scan this file for '???' and read the comments
//-----------------------------------------------------------------------------
// Copyright (C) 2009 Humboldt University Berlin and others.
// All Rights Reserved.
 
// $Id$
 
#ifndef OsiGrbSolverInterface_H
#define OsiGrbSolverInterface_H
 
#include <string>
#include "OsiSolverInterface.hpp"
 
typedef struct _GRBmodel GRBmodel;
typedef struct _GRBenv GRBenv;
 
class OsiGrbSolverInterface : virtual public OsiSolverInterface {
  friend void OsiGrbSolverInterfaceUnitTest(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 yesNo = true, OsiHintStrength strength = OsiHintTry, void * = NULL);
  // 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;
  // Get a hint parameter
  bool getHintParam(OsiHintParam key, bool &yesNo, OsiHintStrength &strength, void *&otherInformation) const;
  // Get a hint parameter
  bool getHintParam(OsiHintParam key, bool &yesNo, OsiHintStrength &strength) const;
  // Get a hint parameter
  bool getHintParam(OsiHintParam key, bool &yesNo) const;
  // Set mipstart option (pass column solution to CPLEX before MIP start)
  void setMipStart(bool value) { domipstart = value; }
  // Get mipstart option value
  bool getMipStart() const { return domipstart; }
 
  //---------------------------------------------------------------------------
 
  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;
 
  //---------------------------------------------------------------------------
 
  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 void setObjCoeff(int elementIndex, double elementValue);
 
  virtual void setObjCoeffSet(const int *indexFirst, const int *indexLast,
    const double *coeffList);
 
  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 setRowName(int ndx, std::string name);
 
  virtual void setColName(int ndx, std::string name);
 
  //-------------------------------------------------------------------------
  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);
 
 
  //---------------------------------------------------------------------------
 
  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;
 
 
  //---------------------------------------------------------------------------
 
  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
  };
 
  GRBmodel *getLpPtr(int keepCached = KEEPCACHED_NONE);
 
  GRBenv *getEnvironmentPtr() const;
 
  bool isDemoLicense() const;
 
  const char *getCtype() const;
 
  static void incrementInstanceCounter();
 
  static void decrementInstanceCounter();
 
  static void setEnvironment(GRBenv *globalenv);
 
  static unsigned int getNumInstances();
 
 
  OsiGrbSolverInterface(bool use_local_env = false);
 
  OsiGrbSolverInterface(GRBenv *localgrbenv);
 
  virtual OsiSolverInterface *clone(bool copyData = true) const;
 
  OsiGrbSolverInterface(const OsiGrbSolverInterface &);
 
  OsiGrbSolverInterface &operator=(const OsiGrbSolverInterface &rhs);
 
  virtual ~OsiGrbSolverInterface();
 
  virtual void reset();
 
  /***************************************************************************/
 
  virtual int canDoSimplexInterface() const;
 
  using OsiSolverInterface::enableSimplexInterface;
  virtual void enableSimplexInterface(int doingPrimal) {};
 
  virtual void disableSimplexInterface() {};
 
  virtual void enableFactorization() const {};
 
  virtual void disableFactorization() const {};
 
  virtual bool basisIsAvailable() const;
 
  virtual void getBasisStatus(int *cstat, int *rstat) const;
 
  //  ///Get a row of the tableau (slack part in slack if not NULL)
  //  virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
  //
  //  ///Get a row of the basis inverse
  //  virtual void getBInvRow(int row, double* z) const;
  //
  //  ///Get a column of the tableau
  //  virtual void getBInvACol(int col, double* vec) const;
  //
  //  ///Get a column of the basis inverse
  //  virtual void getBInvCol(int col, double* vec) const;
  //
  //  /**  Get indices of the pivot variable in each row
  //      (order of indices corresponds to the
  //      order of elements in a vector retured by getBInvACol() and
  //      getBInvCol()).
  //  */
  //  virtual void getBasics(int* index) const;
  void switchToLP();
 
  void switchToMIP();
 
  /***************************************************************************/
 
  /***************************************************************************/
 
  virtual OsiSolverInterface::ApplyCutsReturnCode applyCuts(const OsiCuts &cs,
    double effectivenessLb = 0.0);
 
protected:
  virtual void applyRowCut(const OsiRowCut &rc);
 
  virtual void applyColCut(const OsiColCut &cc);
 
private:
  void resizeColSpace(int minsize);
 
  void freeColSpace();
 
  void resizeAuxColSpace(int minsize);
 
  void resizeAuxColIndSpace();
 
  static GRBenv *globalenv_;
  static bool globalenv_is_ours;
  static unsigned int numInstances_;
 
 
  GRBmodel *getMutableLpPtr() const;
 
  void gutsOfCopy(const OsiGrbSolverInterface &source);
 
  void gutsOfConstructor();
 
  void gutsOfDestructor();
 
  void freeCachedColRim();
 
  void freeCachedRowRim();
 
  void freeCachedResults();
 
  void freeCachedMatrix();
 
  void freeCachedData(int keepCached = KEEPCACHED_NONE);
 
  void freeAllMemory();
 
  void convertToRangedRow(int rowidx, double rhs, double range);
 
  void convertToNormalRow(int rowidx, char sense, double rhs);
 
  mutable GRBenv *localenv_;
 
  mutable GRBmodel *lp_;
 
  int *hotStartCStat_;
  int hotStartCStatSize_;
  int *hotStartRStat_;
  int hotStartRStatSize_;
  int hotStartMaxIteration_;
 
  int nameDisc_;
 
  mutable double *obj_;
 
  mutable double *collower_;
 
  mutable double *colupper_;
 
  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_;
 
  mutable bool probtypemip_;
 
  bool domipstart;
 
  int colspace_;
 
  char *coltype_;
 
  int nauxcols;
 
  int auxcolspace;
 
  int *colmap_O2G;
 
  int *colmap_G2O;
 
  int auxcolindspace;
 
  int *auxcolind;
};
 
//#############################################################################
void OsiGrbSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/