Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OsiGrbSolverInterface.hpp
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // name: OSI Interface for Gurobi
3 // template: OSI Cplex Interface written by T. Achterberg
4 // author: Stefan Vigerske
5 // Humboldt University Berlin
6 // date: 09/02/2009
7 // license: this file may be freely distributed under the terms of EPL
8 // comments: please scan this file for '???' and read the comments
9 //-----------------------------------------------------------------------------
10 // Copyright (C) 2009 Humboldt University Berlin and others.
11 // All Rights Reserved.
12 
13 // $Id: OsiGrbSolverInterface.hpp 1830 2011-11-26 16:46:55Z stefan $
14 
15 #ifndef OsiGrbSolverInterface_H
16 #define OsiGrbSolverInterface_H
17 
18 #include <string>
19 #include "OsiSolverInterface.hpp"
20 
21 typedef struct _GRBmodel GRBmodel;
22 typedef struct _GRBenv GRBenv;
23 
29 class OsiGrbSolverInterface : virtual public OsiSolverInterface {
30  friend void OsiGrbSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
31 
32 public:
33 
34  //---------------------------------------------------------------------------
37  virtual void initialSolve();
39 
41  virtual void resolve();
42 
44  virtual void branchAndBound();
46 
47  //---------------------------------------------------------------------------
63  // Set an integer parameter
64  bool setIntParam(OsiIntParam key, int value);
65  // Set an double parameter
66  bool setDblParam(OsiDblParam key, double value);
67  // Set a string parameter
68  bool setStrParam(OsiStrParam key, const std::string & value);
69  // Set a hint parameter
70  bool setHintParam(OsiHintParam key, bool yesNo = true, OsiHintStrength strength = OsiHintTry, void* = NULL);
71  // Get an integer parameter
72  bool getIntParam(OsiIntParam key, int& value) const;
73  // Get an double parameter
74  bool getDblParam(OsiDblParam key, double& value) const;
75  // Get a string parameter
76  bool getStrParam(OsiStrParam key, std::string& value) const;
77  // Get a hint parameter
78  bool getHintParam(OsiHintParam key, bool& yesNo, OsiHintStrength& strength, void*& otherInformation) const;
79  // Get a hint parameter
80  bool getHintParam(OsiHintParam key, bool& yesNo, OsiHintStrength& strength) const;
81  // Get a hint parameter
82  bool getHintParam(OsiHintParam key, bool& yesNo) const;
83  // Set mipstart option (pass column solution to CPLEX before MIP start)
84  void setMipStart(bool value) { domipstart = value; }
85  // Get mipstart option value
86  bool getMipStart() const { return domipstart; }
88 
89  //---------------------------------------------------------------------------
91 
92  virtual bool isAbandoned() const;
95  virtual bool isProvenOptimal() const;
97  virtual bool isProvenPrimalInfeasible() const;
99  virtual bool isProvenDualInfeasible() const;
101  virtual bool isPrimalObjectiveLimitReached() const;
103  virtual bool isDualObjectiveLimitReached() const;
105  virtual bool isIterationLimitReached() const;
107 
108  //---------------------------------------------------------------------------
111 
119 
121  virtual CoinWarmStart* getWarmStart() const;
124  virtual bool setWarmStart(const CoinWarmStart* warmstart);
126 
127  //---------------------------------------------------------------------------
134  virtual void markHotStart();
137  virtual void solveFromHotStart();
139  virtual void unmarkHotStart();
141 
142  //---------------------------------------------------------------------------
157  virtual int getNumCols() const;
159 
161  virtual int getNumRows() const;
162 
164  virtual int getNumElements() const;
165 
167  virtual const double * getColLower() const;
168 
170  virtual const double * getColUpper() const;
171 
181  virtual const char * getRowSense() const;
182 
191  virtual const double * getRightHandSide() const;
192 
201  virtual const double * getRowRange() const;
202 
204  virtual const double * getRowLower() const;
205 
207  virtual const double * getRowUpper() const;
208 
210  virtual const double * getObjCoefficients() const;
211 
213  virtual double getObjSense() const;
214 
216  virtual bool isContinuous(int colNumber) const;
217 
219  virtual const CoinPackedMatrix * getMatrixByRow() const;
220 
222  virtual const CoinPackedMatrix * getMatrixByCol() const;
223 
225  virtual double getInfinity() const;
227 
230  virtual const double * getColSolution() const;
232 
234  virtual const double * getRowPrice() const;
235 
237  virtual const double * getReducedCost() const;
238 
241  virtual const double * getRowActivity() const;
242 
244  virtual double getObjValue() const;
245 
248  virtual int getIterationCount() const;
249 
267  virtual std::vector<double*> getDualRays(int maxNumRays,
268  bool fullRay=false) const;
280  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
282 
283 
284  //---------------------------------------------------------------------------
285 
288  //-------------------------------------------------------------------------
292  virtual void setObjCoeff(int elementIndex, double elementValue);
293 
295  virtual void setObjCoeffSet(const int* indexFirst, const int* indexLast,
296  const double* coeffList);
297 
301  virtual void setColLower(int elementIndex, double elementValue);
302 
306  virtual void setColUpper(int elementIndex, double elementValue);
307 
311  virtual void setColBounds(int elementIndex, double lower, double upper);
312 
320  virtual void setColSetBounds(const int* indexFirst, const int* indexLast,
321  const double* boundList);
322 
325  virtual void setRowLower(int elementIndex, double elementValue);
326 
329  virtual void setRowUpper(int elementIndex, double elementValue);
330 
334  virtual void setRowBounds(int elementIndex, double lower, double upper);
335 
337  virtual void setRowType(int index, char sense, double rightHandSide,
338  double range);
339 
347  virtual void setRowSetBounds(const int* indexFirst, const int* indexLast,
348  const double* boundList);
349 
359  virtual void setRowSetTypes(const int* indexFirst, const int* indexLast,
360  const char* senseList, const double* rhsList, const double* rangeList);
362 
363  //-------------------------------------------------------------------------
367  virtual void setContinuous(int index);
369  virtual void setInteger(int index);
372  virtual void setContinuous(const int* indices, int len);
375  virtual void setInteger(const int* indices, int len);
377 
378  //-------------------------------------------------------------------------
382  virtual void setRowName(int ndx, std::string name) ;
383 
385  virtual void setColName(int ndx, std::string name) ;
387 
388  //-------------------------------------------------------------------------
390  virtual void setObjSense(double s);
391 
402  virtual void setColSolution(const double * colsol);
403 
414  virtual void setRowPrice(const double * rowprice);
415 
416  //-------------------------------------------------------------------------
423  virtual void addCol(const CoinPackedVectorBase& vec, const double collb,
424  const double colub, const double obj);
425 
428  virtual void addCols(const int numcols,
429  const CoinPackedVectorBase * const * cols, const double* collb,
430  const double* colub, const double* obj);
432  virtual void deleteCols(const int num, const int * colIndices);
433 
436  virtual void addRow(const CoinPackedVectorBase& vec, const double rowlb,
437  const double rowub);
439  virtual void addRow(const CoinPackedVectorBase& vec, const char rowsen,
440  const double rowrhs, const double rowrng);
441 
444  virtual void addRows(const int numrows,
445  const CoinPackedVectorBase * const * rows, const double* rowlb,
446  const double* rowub);
448  virtual void addRows(const int numrows,
449  const CoinPackedVectorBase * const * rows, const char* rowsen,
450  const double* rowrhs, const double* rowrng);
452  virtual void deleteRows(const int num, const int * rowIndices);
454 
455 
456  //---------------------------------------------------------------------------
457 
471  virtual void loadProblem(const CoinPackedMatrix& matrix, const double* collb,
472  const double* colub, const double* obj, const double* rowlb,
473  const double* rowub);
474 
482  virtual void assignProblem(CoinPackedMatrix*& matrix, double*& collb,
483  double*& colub, double*& obj, double*& rowlb, double*& rowub);
484 
497  virtual void loadProblem(const CoinPackedMatrix& matrix, const double* collb,
498  const double* colub, const double* obj, const char* rowsen,
499  const double* rowrhs, const double* rowrng);
500 
508  virtual void assignProblem(CoinPackedMatrix*& matrix, double*& collb,
509  double*& colub, double*& obj, char*& rowsen, double*& rowrhs,
510  double*& rowrng);
511 
514  virtual void loadProblem(const int numcols, const int numrows,
515  const int* start, const int* index, const double* value,
516  const double* collb, const double* colub, const double* obj,
517  const double* rowlb, const double* rowub);
518 
521  virtual void loadProblem(const int numcols, const int numrows,
522  const int* start, const int* index, const double* value,
523  const double* collb, const double* colub, const double* obj,
524  const char* rowsen, const double* rowrhs, const double* rowrng);
525 
528  virtual int readMps(const char *filename, const char *extension = "mps");
529 
534  virtual void writeMps(const char *filename, const char *extension = "mps",
535  double objSense=0.0) const;
536 
538 
539  //---------------------------------------------------------------------------
540 
547  {
570  };
571 
572  GRBmodel* getLpPtr(int keepCached = KEEPCACHED_NONE);
573 
575  GRBenv* getEnvironmentPtr() const;
577 
579  bool isDemoLicense() const;
581 
583  const char* getCtype() const;
584 
594  static void incrementInstanceCounter();
595 
604  static void decrementInstanceCounter();
605 
607  static void setEnvironment(GRBenv* globalenv);
608 
610  static unsigned int getNumInstances();
612 
613 
616  OsiGrbSolverInterface(bool use_local_env = false);
618 
620  OsiGrbSolverInterface(GRBenv* localgrbenv);
621 
623  virtual OsiSolverInterface * clone(bool copyData = true) const;
624 
627 
630 
632  virtual ~OsiGrbSolverInterface();
633 
635  virtual void reset();
637 
638  /***************************************************************************/
655 
659  virtual int canDoSimplexInterface() const;
660 
665  virtual void enableSimplexInterface(int doingPrimal) {
666  }
667  ;
668 
672  virtual void disableSimplexInterface() {
673  }
674  ;
675 
679  virtual void enableFactorization() const {
680  }
681  ;
682 
686  virtual void disableFactorization() const {
687  }
688  ;
689 
691  virtual bool basisIsAvailable() const;
692 
696  virtual void getBasisStatus(int* cstat, int* rstat) const;
697 
698  // ///Get a row of the tableau (slack part in slack if not NULL)
699  // virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
700  //
701  // ///Get a row of the basis inverse
702  // virtual void getBInvRow(int row, double* z) const;
703  //
704  // ///Get a column of the tableau
705  // virtual void getBInvACol(int col, double* vec) const;
706  //
707  // ///Get a column of the basis inverse
708  // virtual void getBInvCol(int col, double* vec) const;
709  //
710  // /** Get indices of the pivot variable in each row
711  // (order of indices corresponds to the
712  // order of elements in a vector retured by getBInvACol() and
713  // getBInvCol()).
714  // */
715  // virtual void getBasics(int* index) const;
717  void switchToLP();
718 
720  void switchToMIP();
721 
723  /***************************************************************************/
724 
725  /***************************************************************************/
726 
750  double effectivenessLb = 0.0);
751 
752 protected:
753 
756  virtual void applyRowCut(const OsiRowCut & rc);
758 
762  virtual void applyColCut(const OsiColCut & cc);
764 
765 private:
768  void resizeColSpace(int minsize);
770 
772  void freeColSpace();
773 
775  void resizeAuxColSpace(int minsize);
776 
778  void resizeAuxColIndSpace();
780 
783  static GRBenv* globalenv_;
786  static bool globalenv_is_ours;
788  static unsigned int numInstances_;
790 
793 
795  GRBmodel* getMutableLpPtr() const;
796 
798  void gutsOfCopy(const OsiGrbSolverInterface & source);
799 
801  void gutsOfConstructor();
802 
804  void gutsOfDestructor();
805 
807  void freeCachedColRim();
808 
810  void freeCachedRowRim();
811 
813  void freeCachedResults();
814 
816  void freeCachedMatrix();
817 
819  void freeCachedData(int keepCached = KEEPCACHED_NONE);
820 
822  void freeAllMemory();
823 
825  void convertToRangedRow(int rowidx, double rhs, double range);
826 
828  void convertToNormalRow(int rowidx, char sense, double rhs);
830 
831 
834  mutable GRBenv* localenv_;
836 
838  mutable GRBmodel* lp_;
839 
846 
849 
852  mutable double *obj_;
854 
856  mutable double *collower_;
857 
859  mutable double *colupper_;
860 
862  mutable char *rowsense_;
863 
865  mutable double *rhs_;
866 
868  mutable double *rowrange_;
869 
871  mutable double *rowlower_;
872 
874  mutable double *rowupper_;
875 
877  mutable double *colsol_;
878 
880  mutable double *rowsol_;
881 
883  mutable double *redcost_;
884 
886  mutable double *rowact_;
887 
890 
894 
897  mutable bool probtypemip_;
899 
902 
905 
907  char *coltype_;
908 
910  int nauxcols;
911 
914 
918 
924 
927 
931  int* auxcolind;
933 };
934 
935 //#############################################################################
937 void OsiGrbSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
938 
939 #endif
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
int auxcolspace
Size of allocated memory for colmap_G2O that exceeds colspace_.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
double * rowupper_
Pointer to dense vector of row upper bounds.
free only cached row and LP solution information
virtual void enableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
void gutsOfDestructor()
The real work of the destructor.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual void markHotStart()
Create a hotstart point of the optimization process.
problem matrix: matrix ordered by column and by row
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
int nameDisc_
OSI name discipline.
int colspace_
Size of allocated memory for coltype_, colmap_O2G, and (with offset auxcolspace) colmap_G2O.
virtual int getNumRows() const
Get number of rows.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual void setColLower(int elementIndex, double elementValue)=0
Set a single column lower bound.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
bool probtypemip_
Stores whether we currently see the problem as a MIP.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
int * hotStartCStat_
Hotstart information.
double * rowact_
Pointer to row activity (slack) vector.
virtual void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Load in an problem by copying the arguments (the constraints on the rows are given by lower and upper...
void OsiGrbSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGrbSolverInterface class.
void gutsOfConstructor()
The real work of the constructor.
GRBmodel * lp_
Gurobi model represented by this class instance.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
virtual void assignProblem(CoinPackedMatrix *&matrix, double *&collb, double *&colub, double *&obj, double *&rowlb, double *&rowub)
Load in an problem by assuming ownership of the arguments (the constraints on the rows are given by l...
double * rowsol_
Pointer to dual solution vector.
GRBmodel * getMutableLpPtr() const
Get LP Pointer for const methods.
struct _GRBenv GRBenv
void freeAllMemory()
free all allocated memory
char * rowsense_
Pointer to dense vector of row sense indicators.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
GRBenv * localenv_
Gurobi environment used only by this class instance.
virtual void setColName(int ndx, std::string name)
Set a column name.
void switchToLP()
Get indices of the pivot variable in each row (order of indices corresponds to the orde...
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
virtual void setColUpper(int elementIndex, double elementValue)=0
Set a single column upper bound.
virtual void enableSimplexInterface(bool doingPrimal)
Enables normal operation of subsequent functions.
double * colupper_
Pointer to dense vector of variable lower bounds.
keep all cached data (similar to getMutableLpPtr())
friend void OsiGrbSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGrbSolverInterface class.
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
void freeColSpace()
frees colsize_ vector
static void setEnvironment(GRBenv *globalenv)
sets the global gurobi environment to a user given one
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
double * rhs_
Pointer to dense vector of row right-hand side values.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual ~OsiGrbSolverInterface()
Destructor.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
Add a set of rows (constraints) to the problem.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
Add a column (primal variable) to the problem.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
double * collower_
Pointer to dense vector of variable lower bounds.
virtual int getNumElements() const
Get number of nonzero elements.
Abstract Base Class for describing an interface to a solver.
virtual void resolve()
Resolve an LP relaxation after problem modification.
bool setHintParam(OsiHintParam key, bool yesNo=true, OsiHintStrength strength=OsiHintTry, void *=NULL)
Set a hint parameter.
free only cached matrix and LP solution information
void resizeAuxColIndSpace()
resizes auxcolind vector to current number of rows and inits values to -1
Abstract base class for various sparse vectors.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
void convertToRangedRow(int rowidx, double rhs, double range)
converts a normal row into a ranged row by adding an auxiliary variable
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
void freeCachedMatrix()
free cached matrices
virtual bool basisIsAvailable() const
Returns true if a basis is available.
int nauxcols
Number of auxiliary columns in Gurobi model for handling of ranged rows.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
static unsigned int getNumInstances()
Return the number of instances of instantiated objects using Gurobi services.
void freeCachedRowRim()
free cached row rim vectors
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
Add a set of rows (constraints) to the problem.
virtual void setRowName(int ndx, std::string name)
Set a row name.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
Add a set of columns (primal variables) to the problem.
int * auxcolind
Gives for each row the index of the corresponding auxiliary variable, if it is a ranged row...
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual void solveFromHotStart()
Optimize starting from the hotstart.
virtual void setRowSetTypes(const int *indexFirst, const int *indexLast, const char *senseList, const double *rhsList, const double *rangeList)
Set the type of a number of rows simultaneously The default implementation just invokes setRowType()...
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
static bool globalenv_is_ours
whether OsiGrb has created the global environment (and thus should free it)
double * redcost_
Pointer to reduced cost vector.
void resizeAuxColSpace(int minsize)
resizes colmap_G2O vector to be able to store at least minsize (auxiliary) elements ...
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
Add a set of columns (primal variables) to the problem.
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
double * colsol_
Pointer to primal solution vector.
discard all cached data (default)
virtual double getObjValue() const
Get objective function value.
void convertToNormalRow(int rowidx, char sense, double rhs)
converts a ranged row into a normal row by removing its auxiliary variable
bool isDemoLicense() const
Return whether the current Gurobi environment runs in demo mode.
double * rowlower_
Pointer to dense vector of row lower bounds.
bool domipstart
Whether to pass a column solution to CPLEX before starting MIP solve (copymipstart) ...
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
static void incrementInstanceCounter()
Gurobi has a context which must be created prior to all other Gurobi calls.
Row Cut Class.
Definition: OsiRowCut.hpp:29
virtual void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously The default implementation just invokes setColl...
virtual void reset()
Resets as if default constructor.
int auxcolindspace
Current length of auxcolind array.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
double * obj_
Pointer to objective vector.
Sparse Matrix Base Class.
virtual bool isProvenOptimal() const
Is optimality proven?
GRBenv * getEnvironmentPtr() const
Method to access Gurobi environment pointer.
virtual bool isIterationLimitReached() const
Iteration limit reached?
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
void resizeColSpace(int minsize)
resizes coltype_, colmap_O2G, colmap_G2O vectors to be able to store at least minsize elements ...
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual void disableFactorization() const
Useless function, defined only for compatibility with OsiSimplexInterface.
This means it is only a hint.
CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound The default implementation just invokes setColLower() and ...
void freeCachedColRim()
free cached column rim vectors
virtual double getInfinity() const
Get solver&#39;s value for infinity.
virtual bool isAbandoned() const
Are there a numerical difficulties?
virtual void getBasisStatus(int *cstat, int *rstat) const
Returns a basis status of the structural/artificial variables At present as warm start i...
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
virtual int canDoSimplexInterface() const
Returns 1 if can just do getBInv etc 2 if has all OsiSimplex methods and 0 if it has none...
const char * getCtype() const
return a vector of variable types (continous, binary, integer)
void switchToMIP()
switches Gurobi to prob type MIP
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
int * colmap_G2O
Maps variable indices from Gurobi to Osi A negative value indicates that a variable is an auxiliary v...
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
OsiGrbSolverInterface(bool use_local_env=false)
Default Constructor.
virtual void initialSolve()
Solve initial LP relaxation.
char * coltype_
Pointer to dense vector of variable types (continous, binary, integer)
struct _GRBmodel GRBmodel
column information: objective values, lower and upper bounds, variable types
virtual int getNumCols() const
Get number of columns.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
static void decrementInstanceCounter()
Gurobi has a context which should be deleted after Gurobi calls.
free only cached column and LP solution information
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
LP solution: primal and dual solution, reduced costs, row activities.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
virtual void setObjCoeffSet(const int *indexFirst, const int *indexLast, const double *coeffList)
Set a a set of objective function coefficients.
Internal class for obtaining status from the applyCuts method.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
bool getHintParam(OsiHintParam key, bool &yesNo, OsiHintStrength &strength, void *&otherInformation) const
Get a hint parameter (all information)
virtual OsiSolverInterface::ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
void gutsOfCopy(const OsiGrbSolverInterface &source)
The real work of a copy constructor (used by copy and assignment)
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
keepCachedFlag
Get pointer to Gurobi model and free all specified cached data entries (combined with logical or-oper...
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
static GRBenv * globalenv_
Gurobi environment pointer.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound The default implementation just invokes setRowLower() and set...
virtual void unmarkHotStart()
Delete the snapshot.
GRBmodel * getLpPtr(int keepCached=KEEPCACHED_NONE)
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
virtual void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously The default implementation just invokes setRowLowe...
static unsigned int numInstances_
Number of instances using the global Gurobi environment.
OsiGrbSolverInterface & operator=(const OsiGrbSolverInterface &rhs)
Assignment operator.
virtual void disableSimplexInterface()
Useless function, defined only for compatibility with OsiSimplexInterface.
Abstract base class for warm start information.
free only cached LP solution information
int * colmap_O2G
Maps variable indices from Osi to Gurobi Is NULL if there are no ranged rows! (assume identity mappin...
virtual void writeMps(const char *filename, const char *extension="mps", double objSense=0.0) const
Write the problem into an mps file of the given filename.
Gurobi Solver Interface.
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
void freeCachedResults()
free cached result vectors
virtual void enableSimplexInterface(int doingPrimal)
Useless function, defined only for compatibility with OsiSimplexInterface.