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: OsiGrbSolverInterface.hpp 1830 2011-11-26 16:46:55Z stefan $

#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