Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OsiGlpkSolverInterface.hpp
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // name: OSI Interface for GLPK
3 //-----------------------------------------------------------------------------
4 // Copyright (C) 2001, Vivian De Smedt, Braden Hunsaker
5 // Copyright (C) 2003 University of Pittsburgh
6 // University of Pittsburgh coding done by Brady Hunsaker
7 // All Rights Reserved.
8 // This code is licensed under the terms of the Eclipse Public License (EPL).
9 
10 #ifndef OsiGlpkSolverInterface_H
11 #define OsiGlpkSolverInterface_H
12 
13 #include <string>
14 #include "OsiSolverInterface.hpp"
15 #include "CoinPackedMatrix.hpp"
16 #include "CoinWarmStartBasis.hpp"
17 
23 #ifndef LPX
24 #define LPX glp_prob
25 #endif
26 
27 #ifndef GLP_PROB_DEFINED
28 #define GLP_PROB_DEFINED
29 // Glpk < 4.48:
30 typedef struct { double _opaque_prob[100]; } glp_prob;
31 // Glpk 4.48: typedef struct glp_prob glp_prob;
32 #endif
33 
35  friend void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
36 
37 public:
38 
39  //---------------------------------------------------------------------------
42  virtual void initialSolve();
44 
46  virtual void resolve();
47 
49  virtual void branchAndBound();
51 
52  //---------------------------------------------------------------------------
68  // Set an integer parameter
69  bool setIntParam(OsiIntParam key, int value);
70  // Set an double parameter
71  bool setDblParam(OsiDblParam key, double value);
72  // Set a string parameter
73  bool setStrParam(OsiStrParam key, const std::string & value);
74  // Set a hint parameter
75  bool setHintParam(OsiHintParam key, bool sense = true,
76  OsiHintStrength strength = OsiHintTry, void *info = 0) ;
77  // Get an integer parameter
78  bool getIntParam(OsiIntParam key, int& value) const;
79  // Get an double parameter
80  bool getDblParam(OsiDblParam key, double& value) const;
81  // Get a string parameter
82  bool getStrParam(OsiStrParam key, std::string& value) const;
84 
85  //---------------------------------------------------------------------------
87 
88  virtual bool isAbandoned() const;
91  virtual bool isProvenOptimal() const;
93  virtual bool isProvenPrimalInfeasible() const;
95  virtual bool isProvenDualInfeasible() const;
97  virtual bool isPrimalObjectiveLimitReached() const;
99  virtual bool isDualObjectiveLimitReached() const;
101  virtual bool isIterationLimitReached() const;
103  virtual bool isTimeLimitReached() const;
105  virtual bool isFeasible() const;
107 
108  //---------------------------------------------------------------------------
118  { return (dynamic_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
120  virtual CoinWarmStart* getWarmStart() const;
123  virtual bool setWarmStart(const CoinWarmStart* warmstart);
125 
126  //---------------------------------------------------------------------------
133  virtual void markHotStart();
136  virtual void solveFromHotStart();
138  virtual void unmarkHotStart();
140 
141  //---------------------------------------------------------------------------
156  virtual int getNumCols() const;
158 
160  virtual int getNumRows() const;
161 
163  virtual int getNumElements() const;
164 
166  virtual const double * getColLower() const;
167 
169  virtual const double * getColUpper() const;
170 
180  virtual const char * getRowSense() const;
181 
190  virtual const double * getRightHandSide() const;
191 
200  virtual const double * getRowRange() const;
201 
203  virtual const double * getRowLower() const;
204 
206  virtual const double * getRowUpper() const;
207 
209  virtual const double * getObjCoefficients() const;
210 
212  virtual double getObjSense() const;
213 
215  virtual bool isContinuous(int colNumber) const;
216 
217 #if 0
218  virtual bool isBinary(int columnNumber) const;
220 
225  virtual bool isInteger(int columnNumber) const;
226 
228  virtual bool isIntegerNonBinary(int columnNumber) const;
229 
231  virtual bool isFreeBinary(int columnNumber) const;
232 #endif
233 
235  virtual const CoinPackedMatrix * getMatrixByRow() const;
236 
238  virtual const CoinPackedMatrix * getMatrixByCol() const;
239 
241  virtual double getInfinity() const;
243 
246  virtual const double * getColSolution() const;
248 
250  virtual const double * getRowPrice() const;
251 
253  virtual const double * getReducedCost() const;
254 
257  virtual const double * getRowActivity() const;
258 
260  virtual double getObjValue() const;
261 
264  virtual int getIterationCount() const;
265 
277  virtual std::vector<double*> getDualRays(int maxNumRays,
278  bool fullRay=false) const;
296  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
297 
298 #if 0
299 
301  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
302  const;
303 #endif
304 
305 
306 
307  //---------------------------------------------------------------------------
308 
311  //-------------------------------------------------------------------------
315  virtual void setObjCoeff( int elementIndex, double elementValue );
316 
320  virtual void setColLower( int elementIndex, double elementValue );
321 
325  virtual void setColUpper( int elementIndex, double elementValue );
326 
330  virtual void setColBounds( int elementIndex,
331  double lower, double upper );
332 
341  virtual void setColSetBounds(const int* indexFirst,
342  const int* indexLast,
343  const double* boundList);
344 
347  virtual void setRowLower( int elementIndex, double elementValue );
348 
351  virtual void setRowUpper( int elementIndex, double elementValue );
352 
356  virtual void setRowBounds( int elementIndex,
357  double lower, double upper );
358 
360  virtual void setRowType(int index, char sense, double rightHandSide,
361  double range);
362 
371  virtual void setRowSetBounds(const int* indexFirst,
372  const int* indexLast,
373  const double* boundList);
374 
385  virtual void setRowSetTypes(const int* indexFirst,
386  const int* indexLast,
387  const char* senseList,
388  const double* rhsList,
389  const double* rangeList);
391 
392  //-------------------------------------------------------------------------
396  virtual void setContinuous(int index);
398  virtual void setInteger(int index);
401  virtual void setContinuous(const int* indices, int len);
404  virtual void setInteger(const int* indices, int len);
406 
407  //-------------------------------------------------------------------------
409  virtual void setObjSense(double s);
410 
421  virtual void setColSolution(const double * colsol);
422 
433  virtual void setRowPrice(const double * rowprice);
434 
435  //-------------------------------------------------------------------------
440 
443  virtual void addCol(const CoinPackedVectorBase& vec,
444  const double collb, const double colub,
445  const double obj);
446 
449  virtual void addCols(const int numcols,
450  const CoinPackedVectorBase * const * cols,
451  const double* collb, const double* colub,
452  const double* obj);
454  virtual void deleteCols(const int num, const int * colIndices);
455 
458  virtual void addRow(const CoinPackedVectorBase& vec,
459  const double rowlb, const double rowub);
461  virtual void addRow(const CoinPackedVectorBase& vec,
462  const char rowsen, const double rowrhs,
463  const double rowrng);
464 
467  virtual void addRows(const int numrows,
468  const CoinPackedVectorBase * const * rows,
469  const double* rowlb, const double* rowub);
471  virtual void addRows(const int numrows,
472  const CoinPackedVectorBase * const * rows,
473  const char* rowsen, const double* rowrhs,
474  const double* rowrng);
476  virtual void deleteRows(const int num, const int * rowIndices);
477 
478 #if 0
479  // ??? implemented in OsiSolverInterface
480  //-----------------------------------------------------------------------
502  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
503  double effectivenessLb = 0.0);
504 #endif
505 
506 
507 
508  //---------------------------------------------------------------------------
509 
523  virtual void loadProblem(const CoinPackedMatrix& matrix,
524  const double* collb, const double* colub,
525  const double* obj,
526  const double* rowlb, const double* rowub);
527 
535  virtual void assignProblem(CoinPackedMatrix*& matrix,
536  double*& collb, double*& colub, double*& obj,
537  double*& rowlb, double*& rowub);
538 
551  virtual void loadProblem(const CoinPackedMatrix& matrix,
552  const double* collb, const double* colub,
553  const double* obj,
554  const char* rowsen, const double* rowrhs,
555  const double* rowrng);
556 
564  virtual void assignProblem(CoinPackedMatrix*& matrix,
565  double*& collb, double*& colub, double*& obj,
566  char*& rowsen, double*& rowrhs,
567  double*& rowrng);
568 
571  virtual void loadProblem(const int numcols, const int numrows,
572  const int* start, const int* index,
573  const double* value,
574  const double* collb, const double* colub,
575  const double* obj,
576  const double* rowlb, const double* rowub);
577 
580  virtual void loadProblem(const int numcols, const int numrows,
581  const int* start, const int* index,
582  const double* value,
583  const double* collb, const double* colub,
584  const double* obj,
585  const char* rowsen, const double* rowrhs,
586  const double* rowrng);
587 
590  virtual int readMps(const char *filename,
591  const char *extension = "mps");
592 
597  virtual void writeMps(const char *filename,
598  const char *extension = "mps",
599  double objSense=0.0) const;
601 
602  //---------------------------------------------------------------------------
603 
610 
613  void setObjName (std::string name) ;
614 
620  void setRowName(int ndx, std::string name) ;
621 
627  void setColName(int ndx, std::string name) ;
628 
630 
631  //---------------------------------------------------------------------------
632 
636  {
659  };
660 
662  LPX * getModelPtr();
663 
665 
675 
683  static void decrementInstanceCounter();
684 
686  static unsigned int getNumInstances() { return numInstances_; }
688 
689 
694 
696  virtual OsiSolverInterface * clone(bool copyData = true) const;
697 
700 
703 
705  virtual ~OsiGlpkSolverInterface();
706 
708  virtual void reset();
710 
711 protected:
712 
715  virtual void applyRowCut( const OsiRowCut & rc );
717 
721  virtual void applyColCut( const OsiColCut & cc );
722 
724  LPX * getMutableModelPtr() const;
725 
727 
728 private:
731 
733  void gutsOfCopy( const OsiGlpkSolverInterface & source );
734 
736  void gutsOfConstructor();
737 
739  void gutsOfDestructor();
740 
742  void freeCachedColRim();
743 
745  void freeCachedRowRim();
746 
748  void freeCachedResults();
749 
751  void freeCachedMatrix();
752 
754  void freeCachedData( int keepCached = KEEPCACHED_NONE );
755 
757  void freeAllMemory();
758 
760  void printBounds();
761 
763  void fillColBounds() const;
765 
766 
769  mutable LPX* lp_;
771 
773  static unsigned int numInstances_;
774 
775 
776  // Remember whether simplex or b&b was most recently done
777  // 0 = simplex; 1 = b&b
779 
780  // Int parameters.
787 
788  // Double parameters.
798  double objOffset_;
799 
800  // String parameters
802  std::string probName_;
803 
805  mutable void *info_[OsiLastHintParam] ;
806 
807 
809 
815  double *hotStartCVal_;
818 
824  double *hotStartRVal_;
827 
828  // Status information
853 
856 
858  mutable int iter_used_;
859 
861  mutable double *obj_;
862 
864  mutable double *collower_;
865 
867  mutable double *colupper_;
868 
870  mutable char *ctype_;
871 
873  mutable char *rowsense_;
874 
876  mutable double *rhs_;
877 
879  mutable double *rowrange_;
880 
882  mutable double *rowlower_;
883 
885  mutable double *rowupper_;
886 
888  mutable double *colsol_;
889 
891  mutable double *rowsol_;
892 
894  mutable double *redcost_;
895 
897  mutable double *rowact_;
898 
901 
905 
906 };
907 
908 //#############################################################################
910 void OsiGlpkSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
911 
912 #endif // OsiGlpkSolverInterface_H
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
free only cached column and LP solution information
virtual bool isAbandoned() const
Are there a numerical difficulties?
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
Just a marker, so that OsiSolverInterface can allocate a static sized array to store parameters...
virtual bool isProvenOptimal() const
Is optimality proven?
double * collower_
Pointer to dense vector of variable lower bounds.
char * rowsense_
Pointer to dense vector of row sense indicators.
bool isAbandoned_
glpk abandoned the problem
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
bool setHintParam(OsiHintParam key, bool sense=true, OsiHintStrength strength=OsiHintTry, void *info=0)
Set a hint parameter.
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...
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
double * rowact_
Pointer to row activity (slack) vector.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
void gutsOfConstructor()
The real work of the constructor.
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.
void gutsOfDestructor()
The real work of the destructor.
LPX * getMutableModelPtr() const
Pointer to the model.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual void setColLower(int elementIndex, double elementValue)=0
Set a single column lower bound.
void setRowName(int ndx, std::string name)
Set a row name.
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
double dualObjectiveLimit_
dual objective limit (measure of badness; stop if we&#39;re worse)
virtual int getNumCols() const
Get number of columns.
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
void freeAllMemory()
free all allocated memory
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
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...
LP solution: primal and dual solution, reduced costs, row activities.
virtual int getNumElements() const
Get number of nonzero elements.
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
double * hotStartCDualVal_
dual variable values
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.
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
double * hotStartRDualVal_
row dual values
bool isTimeLimitReached_
glpk stopped on time limit
virtual bool isIterationLimitReached() const
Iteration limit reached?
free only cached matrix and LP solution information
double * colupper_
Pointer to dense vector of variable lower bounds.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
The default COIN simplex (basis-oriented) warm start class.
virtual ~OsiGlpkSolverInterface()
Destructor.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
bool isObjLowerLimitReached_
glpk stopped on lower objective limit
int * hotStartRStat_
row status array
virtual void setColUpper(int elementIndex, double elementValue)=0
Set a single column upper bound.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
static void decrementInstanceCounter()
GLPK has a context which must be freed after all GLPK LPs (or MIPs) are freed.
void freeCachedResults()
free cached result vectors
virtual void initialSolve()
Solve initial LP relaxation.
static void incrementInstanceCounter()
GLPK has a context which must be freed after all GLPK LPs (or MIPs) are freed.
friend void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGlpkSolverInterface class.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
OsiGlpkSolverInterface & operator=(const OsiGlpkSolverInterface &rhs)
Assignment operator.
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
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.
CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
Abstract Base Class for describing an interface to a solver.
Abstract base class for various sparse vectors.
virtual void resolve()
Resolve an LP relaxation after problem modification.
virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05) const
Get vector of indices of primal variables which are integer variables but have fractional values in t...
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...
LPX * getModelPtr()
Get pointer to GLPK model.
virtual void unmarkHotStart()
Delete the snapshot.
void * info_[OsiLastHintParam]
Array for info blocks associated with hints.
std::string probName_
Problem name.
std::vector< int > OsiVectorInt
Vector of int.
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.
double * rowupper_
Pointer to dense vector of row upper bounds.
virtual bool isFeasible() const
(Integer) Feasible solution found?
double primalObjectiveLimit_
primal objective limit (measure of goodness; stop if we&#39;re better)
bool isIterationLimitReached_
glpk stopped on iteration limit
discard all cached data (default)
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound The default implementation just invokes setColLower() and ...
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
double * obj_
Pointer to objective vector.
free only cached row and LP solution information
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
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 bool isBinary(int colIndex) const
Return true if the variable is binary.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
int hotStartMaxIteration_
simplex iteration limit (for hot start)
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
virtual double getObjValue() const
Get objective function value.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
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 const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
void freeCachedMatrix()
free cached matrices
virtual double getInfinity() const
Get solver&#39;s value for infinity.
void freeCachedRowRim()
free cached row rim vectors
void freeCachedColRim()
free cached column rim vectors
static unsigned int getNumInstances()
Return the number of LP/MIP instances of instantiated objects using the GLPK environment.
virtual void reset()
Resets as if default constructor.
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Row Cut Class.
Definition: OsiRowCut.hpp:29
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
int iter_used_
Number of iterations.
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
int * hotStartCStat_
column status array
double objOffset_
constant offset for objective function
virtual int getNumRows() const
Get number of rows.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
Sparse Matrix Base Class.
void setColName(int ndx, std::string name)
Set a column name.
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
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...
virtual void markHotStart()
Create a hotstart point of the optimization process.
bool isPrimInfeasible_
glpk declared the problem primal infeasible
This means it is only a hint.
int nameDisc_
OSI name discipline.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
void gutsOfCopy(const OsiGlpkSolverInterface &source)
The real work of a copy constructor (used by copy and assignment)
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
double * hotStartCVal_
primal variable values
virtual bool isTimeLimitReached() const
Time limit reached?
keep all cached data (similar to getMutableLpPtr())
int hotStartCStatSize_
Hotstart information.
static unsigned int numInstances_
number of GLPK instances currently in use (counts only those created by OsiGlpk)
LPX * lp_
GPLK model represented by this class instance.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
double * rhs_
Pointer to dense vector of row right-hand side values.
double * rowsol_
Pointer to dual solution vector.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
bool isFeasible_
glpk declared the problem feasible
int hotStartRStatSize_
size of row status and value arrays
bool isDualInfeasible_
glpk declared the problem dual infeasible
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
char * ctype_
Pointer to dense vector of variable types (continous, binary, integer)
OsiGlpkSolverInterface()
Default Constructor.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
double * colsol_
Pointer to primal solution vector.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
double * rowlower_
Pointer to dense vector of row lower bounds.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGlpkSolverInterface class.
double * redcost_
Pointer to reduced cost vector.
int maxIteration_
simplex iteration limit (per call to solver)
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
void printBounds()
Just for testing purposes.
bool isObjUpperLimitReached_
glpk stopped on upper objective limit
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
void setObjName(std::string name)
Set the objective function name.
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
double * hotStartRVal_
row slack values
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
double dualTolerance_
dual feasibility tolerance
problem matrix: matrix ordered by column and by row
column information: objective values, lower and upper bounds, variable types
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
double primalTolerance_
primal feasibility tolerance
void fillColBounds() const
Fill cached collumn bounds.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
free only cached LP solution information
Abstract base class for warm start information.
#define LPX
GPLK Solver Interface.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
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...