Cgl 0.60.2

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

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 {
31 double _opaque_prob[100];
32 } glp_prob;
33 // Glpk 4.48: typedef struct glp_prob glp_prob;
34 #endif
35
36 class OsiGlpkSolverInterface : virtual public OsiSolverInterface {
37 friend void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
38
39 public:
40 //---------------------------------------------------------------------------
43 virtual void initialSolve();
45
47 virtual void resolve();
48
50 virtual void branchAndBound();
52
53 //---------------------------------------------------------------------------
69 // Set an integer parameter
70 bool setIntParam(OsiIntParam key, int value);
71 // Set an double parameter
72 bool setDblParam(OsiDblParam key, double value);
73 // Set a string parameter
74 bool setStrParam(OsiStrParam key, const std::string &value);
75 // Set a hint parameter
76 bool setHintParam(OsiHintParam key, bool sense = true,
77 OsiHintStrength strength = OsiHintTry, void *info = 0);
78 // Get an integer parameter
79 bool getIntParam(OsiIntParam key, int &value) const;
80 // Get an double parameter
81 bool getDblParam(OsiDblParam key, double &value) const;
82 // Get a string parameter
83 bool getStrParam(OsiStrParam key, std::string &value) const;
85
86 //---------------------------------------------------------------------------
88
89 virtual bool isAbandoned() const;
92 virtual bool isProvenOptimal() const;
94 virtual bool isProvenPrimalInfeasible() const;
96 virtual bool isProvenDualInfeasible() const;
98 virtual bool isPrimalObjectiveLimitReached() const;
100 virtual bool isDualObjectiveLimitReached() const;
102 virtual bool isIterationLimitReached() const;
104 virtual bool isTimeLimitReached() const;
106 virtual bool isFeasible() const;
108
109 //---------------------------------------------------------------------------
118 inline CoinWarmStart *getEmptyWarmStart() const
119 {
120 return (dynamic_cast< CoinWarmStart * >(new CoinWarmStartBasis()));
121 }
123 virtual CoinWarmStart *getWarmStart() const;
126 virtual bool setWarmStart(const CoinWarmStart *warmstart);
128
129 //---------------------------------------------------------------------------
136 virtual void markHotStart();
139 virtual void solveFromHotStart();
141 virtual void unmarkHotStart();
143
144 //---------------------------------------------------------------------------
159 virtual int getNumCols() const;
161
163 virtual int getNumRows() const;
164
166 virtual CoinBigIndex getNumElements() const;
167
169 virtual const double *getColLower() const;
170
172 virtual const double *getColUpper() const;
173
183 virtual const char *getRowSense() const;
184
193 virtual const double *getRightHandSide() const;
194
203 virtual const double *getRowRange() const;
204
206 virtual const double *getRowLower() const;
207
209 virtual const double *getRowUpper() const;
210
212 virtual const double *getObjCoefficients() const;
213
215 virtual double getObjSense() const;
216
218 virtual bool isContinuous(int colNumber) const;
219
220 #if 0
221 virtual bool isBinary(int columnNumber) const;
223
228 virtual bool isInteger(int columnNumber) const;
229
231 virtual bool isIntegerNonBinary(int columnNumber) const;
232
234 virtual bool isFreeBinary(int columnNumber) const;
235 #endif
236
238 virtual const CoinPackedMatrix *getMatrixByRow() const;
239
241 virtual const CoinPackedMatrix *getMatrixByCol() const;
242
244 virtual double getInfinity() const;
246
249 virtual const double *getColSolution() const;
251
253 virtual const double *getRowPrice() const;
254
256 virtual const double *getReducedCost() const;
257
260 virtual const double *getRowActivity() const;
261
263 virtual double getObjValue() const;
264
267 virtual int getIterationCount() const;
268
280 virtual std::vector< double * > getDualRays(int maxNumRays,
281 bool fullRay = false) const;
299 virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
300
301 #if 0
302
304 virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
305 const;
306 #endif
307
308
309
310 //---------------------------------------------------------------------------
311
314 //-------------------------------------------------------------------------
318 virtual void setObjCoeff(int elementIndex, double elementValue);
319
320 using OsiSolverInterface::setColLower;
323 virtual void setColLower(int elementIndex, double elementValue);
324
325 using OsiSolverInterface::setColUpper;
328 virtual void setColUpper(int elementIndex, double elementValue);
329
333 virtual void setColBounds(int elementIndex,
334 double lower, double upper);
335
344 virtual void setColSetBounds(const int *indexFirst,
345 const int *indexLast,
346 const double *boundList);
347
350 virtual void setRowLower(int elementIndex, double elementValue);
351
354 virtual void setRowUpper(int elementIndex, double elementValue);
355
359 virtual void setRowBounds(int elementIndex,
360 double lower, double upper);
361
363 virtual void setRowType(int index, char sense, double rightHandSide,
364 double range);
365
374 virtual void setRowSetBounds(const int *indexFirst,
375 const int *indexLast,
376 const double *boundList);
377
388 virtual void setRowSetTypes(const int *indexFirst,
389 const int *indexLast,
390 const char *senseList,
391 const double *rhsList,
392 const double *rangeList);
394
395 //-------------------------------------------------------------------------
399 virtual void setContinuous(int index);
401 virtual void setInteger(int index);
404 virtual void setContinuous(const int *indices, int len);
407 virtual void setInteger(const int *indices, int len);
409
410 //-------------------------------------------------------------------------
412 virtual void setObjSense(double s);
413
424 virtual void setColSolution(const double *colsol);
425
436 virtual void setRowPrice(const double *rowprice);
437
438 //-------------------------------------------------------------------------
443
444 using OsiSolverInterface::addCol;
446 virtual void addCol(const CoinPackedVectorBase &vec,
447 const double collb, const double colub,
448 const double obj);
449
450 using OsiSolverInterface::addCols;
452 virtual void addCols(const int numcols,
453 const CoinPackedVectorBase *const *cols,
454 const double *collb, const double *colub,
455 const double *obj);
457 virtual void deleteCols(const int num, const int *colIndices);
458
459 using OsiSolverInterface::addRow;
461 virtual void addRow(const CoinPackedVectorBase &vec,
462 const double rowlb, const double rowub);
464 virtual void addRow(const CoinPackedVectorBase &vec,
465 const char rowsen, const double rowrhs,
466 const double rowrng);
467
468 using OsiSolverInterface::addRows;
470 virtual void addRows(const int numrows,
471 const CoinPackedVectorBase *const *rows,
472 const double *rowlb, const double *rowub);
474 virtual void addRows(const int numrows,
475 const CoinPackedVectorBase *const *rows,
476 const char *rowsen, const double *rowrhs,
477 const double *rowrng);
479 virtual void deleteRows(const int num, const int *rowIndices);
480
481 #if 0
482 // ??? implemented in OsiSolverInterface
483 //-----------------------------------------------------------------------
505 virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
506 double effectivenessLb = 0.0);
507 #endif
508
509
510
511 //---------------------------------------------------------------------------
512
526 virtual void loadProblem(const CoinPackedMatrix &matrix,
527 const double *collb, const double *colub,
528 const double *obj,
529 const double *rowlb, const double *rowub);
530
538 virtual void assignProblem(CoinPackedMatrix *&matrix,
539 double *&collb, double *&colub, double *&obj,
540 double *&rowlb, double *&rowub);
541
554 virtual void loadProblem(const CoinPackedMatrix &matrix,
555 const double *collb, const double *colub,
556 const double *obj,
557 const char *rowsen, const double *rowrhs,
558 const double *rowrng);
559
567 virtual void assignProblem(CoinPackedMatrix *&matrix,
568 double *&collb, double *&colub, double *&obj,
569 char *&rowsen, double *&rowrhs,
570 double *&rowrng);
571
574 virtual void loadProblem(const int numcols, const int numrows,
575 const CoinBigIndex *start, const int *index,
576 const double *value,
577 const double *collb, const double *colub,
578 const double *obj,
579 const double *rowlb, const double *rowub);
580
583 virtual void loadProblem(const int numcols, const int numrows,
584 const CoinBigIndex *start, const int *index,
585 const double *value,
586 const double *collb, const double *colub,
587 const double *obj,
588 const char *rowsen, const double *rowrhs,
589 const double *rowrng);
590
591 using OsiSolverInterface::readMps;
593 virtual int readMps(const char *filename,
594 const char *extension = "mps");
595
600 virtual void writeMps(const char *filename,
601 const char *extension = "mps",
602 double objSense = 0.0) const;
604
605 //---------------------------------------------------------------------------
606
613
616 void setObjName(std::string name);
617
623 void setRowName(int ndx, std::string name);
624
630 void setColName(int ndx, std::string name);
631
633
634 //---------------------------------------------------------------------------
635
638 enum keepCachedFlag {
640 KEEPCACHED_NONE = 0,
642 KEEPCACHED_COLUMN = 1,
644 KEEPCACHED_ROW = 2,
646 KEEPCACHED_MATRIX = 4,
648 KEEPCACHED_RESULTS = 8,
650 KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
652 KEEPCACHED_ALL = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
654 FREECACHED_COLUMN = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN,
656 FREECACHED_ROW = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW,
658 FREECACHED_MATRIX = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX,
660 FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS
661 };
662
664 LPX *getModelPtr();
665
667
676 static void incrementInstanceCounter() { ++numInstances_; }
677
685 static void decrementInstanceCounter();
686
688 static unsigned int getNumInstances() { return numInstances_; }
690
693 OsiGlpkSolverInterface();
695
697 virtual OsiSolverInterface *clone(bool copyData = true) const;
698
700 OsiGlpkSolverInterface(const OsiGlpkSolverInterface &);
701
703 OsiGlpkSolverInterface &operator=(const OsiGlpkSolverInterface &rhs);
704
706 virtual ~OsiGlpkSolverInterface();
707
709 virtual void reset();
711
712 protected:
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
768 mutable LPX *lp_;
770
772 static unsigned int numInstances_;
773
774 // Remember whether simplex or b&b was most recently done
775 // 0 = simplex; 1 = b&b
776 int bbWasLast_;
777
778 // Int parameters.
780 int maxIteration_;
782 int hotStartMaxIteration_;
784 int nameDisc_;
785
786 // Double parameters.
788 double dualObjectiveLimit_;
790 double primalObjectiveLimit_;
792 double dualTolerance_;
794 double primalTolerance_;
796 double objOffset_;
797
798 // String parameters
800 std::string probName_;
801
803 mutable void *info_[OsiLastHintParam];
804
806
808 int hotStartCStatSize_;
810 int *hotStartCStat_;
812 double *hotStartCVal_;
814 double *hotStartCDualVal_;
815
817 int hotStartRStatSize_;
819 int *hotStartRStat_;
821 double *hotStartRVal_;
823 double *hotStartRDualVal_;
824
825 // Status information
827 bool isIterationLimitReached_;
829 bool isTimeLimitReached_;
831 bool isAbandoned_;
837 bool isObjLowerLimitReached_;
843 bool isObjUpperLimitReached_;
845 bool isPrimInfeasible_;
847 bool isDualInfeasible_;
849 bool isFeasible_;
850
853
855 mutable int iter_used_;
856
858 mutable double *obj_;
859
861 mutable double *collower_;
862
864 mutable double *colupper_;
865
867 mutable char *ctype_;
868
870 mutable char *rowsense_;
871
873 mutable double *rhs_;
874
876 mutable double *rowrange_;
877
879 mutable double *rowlower_;
880
882 mutable double *rowupper_;
883
885 mutable double *colsol_;
886
888 mutable double *rowsol_;
889
891 mutable double *redcost_;
892
894 mutable double *rowact_;
895
897 mutable CoinPackedMatrix *matrixByRow_;
898
900 mutable CoinPackedMatrix *matrixByCol_;
902
903 };
904
905 //#############################################################################
907 void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
908
909 #endif // OsiGlpkSolverInterface_H
910
911 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
912 */
OsiGlpkSolverInterface::getReducedCost
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
OsiGlpkSolverInterface::FREECACHED_COLUMN
free only cached column and LP solution information
Definition: OsiGlpkSolverInterface.hpp:654
OsiGlpkSolverInterface::isAbandoned
virtual bool isAbandoned() const
Are there a numerical difficulties?
OsiGlpkSolverInterface::isProvenDualInfeasible
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
OsiSolverInterface::readMps
virtual int readMps(const char *filename, const char *extension="mps")
Read a problem in MPS format from the given filename.
OsiLastHintParam
Just a marker, so that OsiSolverInterface can allocate a static sized array to store parameters...
Definition: OsiSolverParameters.hpp:127
OsiGlpkSolverInterface::isProvenOptimal
virtual bool isProvenOptimal() const
Is optimality proven?
OsiGlpkSolverInterface::collower_
double * collower_
Pointer to dense vector of variable lower bounds.
Definition: OsiGlpkSolverInterface.hpp:861
OsiGlpkSolverInterface::rowsense_
char * rowsense_
Pointer to dense vector of row sense indicators.
Definition: OsiGlpkSolverInterface.hpp:870
OsiGlpkSolverInterface::isAbandoned_
bool isAbandoned_
glpk abandoned the problem
Definition: OsiGlpkSolverInterface.hpp:831
OsiGlpkSolverInterface::getDblParam
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
OsiGlpkSolverInterface::isDualObjectiveLimitReached
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
OsiGlpkSolverInterface::setHintParam
bool setHintParam(OsiHintParam key, bool sense=true, OsiHintStrength strength=OsiHintTry, void *info=0)
Set a hint parameter.
OsiGlpkSolverInterface::assignProblem
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...
OsiGlpkSolverInterface::matrixByCol_
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
Definition: OsiGlpkSolverInterface.hpp:900
OsiGlpkSolverInterface::rowact_
double * rowact_
Pointer to row activity (slack) vector.
Definition: OsiGlpkSolverInterface.hpp:894
OsiGlpkSolverInterface::setRowPrice
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
OsiGlpkSolverInterface::gutsOfConstructor
void gutsOfConstructor()
The real work of the constructor.
OsiGlpkSolverInterface::addCols
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.
OsiGlpkSolverInterface::gutsOfDestructor
void gutsOfDestructor()
The real work of the destructor.
OsiGlpkSolverInterface::getMutableModelPtr
LPX * getMutableModelPtr() const
Pointer to the model.
OsiSolverInterface::isIntegerNonBinary
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
OsiGlpkSolverInterface::applyRowCut
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
OsiGlpkSolverInterface::deleteRows
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
OsiGlpkSolverInterface::clone
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
OsiSolverInterface::setColLower
virtual void setColLower(int elementIndex, double elementValue)=0
Set a single column lower bound.
OsiGlpkSolverInterface::setRowName
void setRowName(int ndx, std::string name)
Set a row name.
OsiGlpkSolverInterface::setDblParam
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
OsiGlpkSolverInterface::addCol
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
OsiGlpkSolverInterface::dualObjectiveLimit_
double dualObjectiveLimit_
dual objective limit (measure of badness; stop if we&#39;re worse)
Definition: OsiGlpkSolverInterface.hpp:788
OsiGlpkSolverInterface::getNumCols
virtual int getNumCols() const
Get number of columns.
OsiGlpkSolverInterface::getIntParam
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
OsiDblParam
OsiDblParam
Definition: OsiSolverParameters.hpp:52
OsiGlpkSolverInterface::freeAllMemory
void freeAllMemory()
free all allocated memory
OsiGlpkSolverInterface::getObjSense
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
OsiGlpkSolverInterface::setRowBounds
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...
OsiGlpkSolverInterface::KEEPCACHED_RESULTS
LP solution: primal and dual solution, reduced costs, row activities.
Definition: OsiGlpkSolverInterface.hpp:648
OsiGlpkSolverInterface::isPrimalObjectiveLimitReached
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
OsiGlpkSolverInterface::hotStartCDualVal_
double * hotStartCDualVal_
dual variable values
Definition: OsiGlpkSolverInterface.hpp:814
OsiGlpkSolverInterface::writeMps
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.
OsiCuts
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
OsiColCut
Column Cut Class.
Definition: OsiColCut.hpp:23
OsiGlpkSolverInterface::setColSolution
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
OsiGlpkSolverInterface::hotStartRDualVal_
double * hotStartRDualVal_
row dual values
Definition: OsiGlpkSolverInterface.hpp:823
OsiGlpkSolverInterface::isTimeLimitReached_
bool isTimeLimitReached_
glpk stopped on time limit
Definition: OsiGlpkSolverInterface.hpp:829
OsiGlpkSolverInterface::isIterationLimitReached
virtual bool isIterationLimitReached() const
Iteration limit reached?
OsiGlpkSolverInterface::FREECACHED_MATRIX
free only cached matrix and LP solution information
Definition: OsiGlpkSolverInterface.hpp:658
OsiGlpkSolverInterface::colupper_
double * colupper_
Pointer to dense vector of variable lower bounds.
Definition: OsiGlpkSolverInterface.hpp:864
OsiGlpkSolverInterface::getRowLower
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
CoinWarmStartBasis
The default COIN simplex (basis-oriented) warm start class.
Definition: CoinWarmStartBasis.hpp:40
OsiGlpkSolverInterface::~OsiGlpkSolverInterface
virtual ~OsiGlpkSolverInterface()
Destructor.
OsiHintStrength
OsiHintStrength
Definition: OsiSolverParameters.hpp:130
OsiGlpkSolverInterface::getRowUpper
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
OsiGlpkSolverInterface::isObjLowerLimitReached_
bool isObjLowerLimitReached_
glpk stopped on lower objective limit
Definition: OsiGlpkSolverInterface.hpp:837
OsiGlpkSolverInterface::hotStartRStat_
int * hotStartRStat_
row status array
Definition: OsiGlpkSolverInterface.hpp:819
OsiSolverInterface::setColUpper
virtual void setColUpper(int elementIndex, double elementValue)=0
Set a single column upper bound.
OsiGlpkSolverInterface::setContinuous
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
OsiGlpkSolverInterface::matrixByRow_
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
Definition: OsiGlpkSolverInterface.hpp:897
OsiGlpkSolverInterface::solveFromHotStart
virtual void solveFromHotStart()
Optimize starting from the hotstart.
OsiGlpkSolverInterface::decrementInstanceCounter
static void decrementInstanceCounter()
GLPK has a context which must be freed after all GLPK LPs (or MIPs) are freed.
OsiGlpkSolverInterface::freeCachedResults
void freeCachedResults()
free cached result vectors
OsiGlpkSolverInterface::initialSolve
virtual void initialSolve()
Solve initial LP relaxation.
OsiGlpkSolverInterface::incrementInstanceCounter
static void incrementInstanceCounter()
GLPK has a context which must be freed after all GLPK LPs (or MIPs) are freed.
Definition: OsiGlpkSolverInterface.hpp:676
OsiGlpkSolverInterface::OsiGlpkSolverInterfaceUnitTest
friend void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGlpkSolverInterface class.
OsiGlpkSolverInterface::isContinuous
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
OsiGlpkSolverInterface::operator=
OsiGlpkSolverInterface & operator=(const OsiGlpkSolverInterface &rhs)
Assignment operator.
OsiSolverInterface::isInteger
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
OsiGlpkSolverInterface::addRows
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.
OsiSolverInterface::addCol
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)=0
Add a column (primal variable) to the problem.
OsiGlpkSolverInterface::getEmptyWarmStart
CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
Definition: OsiGlpkSolverInterface.hpp:118
OsiSolverInterface
Abstract Base Class for describing an interface to a solver.
Definition: OsiSolverInterface.hpp:61
CoinPackedVectorBase
Abstract base class for various sparse vectors.
Definition: CoinPackedVectorBase.hpp:23
OsiGlpkSolverInterface::resolve
virtual void resolve()
Resolve an LP relaxation after problem modification.
OsiSolverInterface::getFractionalIndices
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...
OsiGlpkSolverInterface::setColSetBounds
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...
OsiGlpkSolverInterface::getModelPtr
LPX * getModelPtr()
Get pointer to GLPK model.
OsiGlpkSolverInterface::unmarkHotStart
virtual void unmarkHotStart()
Delete the snapshot.
OsiGlpkSolverInterface::info_
void * info_[OsiLastHintParam]
Array for info blocks associated with hints.
Definition: OsiGlpkSolverInterface.hpp:803
OsiGlpkSolverInterface::probName_
std::string probName_
Problem name.
Definition: OsiGlpkSolverInterface.hpp:800
OsiSolverInterface::addRows
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.
OsiGlpkSolverInterface::rowupper_
double * rowupper_
Pointer to dense vector of row upper bounds.
Definition: OsiGlpkSolverInterface.hpp:882
OsiGlpkSolverInterface::isFeasible
virtual bool isFeasible() const
(Integer) Feasible solution found?
OsiGlpkSolverInterface::KEEPCACHED_PROBLEM
only discard cached LP solution
Definition: OsiGlpkSolverInterface.hpp:650
OsiGlpkSolverInterface::primalObjectiveLimit_
double primalObjectiveLimit_
primal objective limit (measure of goodness; stop if we&#39;re better)
Definition: OsiGlpkSolverInterface.hpp:790
OsiGlpkSolverInterface::isIterationLimitReached_
bool isIterationLimitReached_
glpk stopped on iteration limit
Definition: OsiGlpkSolverInterface.hpp:827
OsiGlpkSolverInterface::KEEPCACHED_NONE
discard all cached data (default)
Definition: OsiGlpkSolverInterface.hpp:640
OsiGlpkSolverInterface::setColBounds
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound The default implementation just invokes setColLower() and ...
OsiGlpkSolverInterface::getColUpper
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
OsiGlpkSolverInterface::getWarmStart
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
OsiGlpkSolverInterface::setRowLower
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
OsiGlpkSolverInterface::branchAndBound
virtual void branchAndBound()
Invoke solver&#39;s built-in enumeration algorithm.
OsiGlpkSolverInterface::freeCachedData
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
OsiStrParam
OsiStrParam
Definition: OsiSolverParameters.hpp:87
OsiGlpkSolverInterface::applyColCut
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
OsiGlpkSolverInterface::obj_
double * obj_
Pointer to objective vector.
Definition: OsiGlpkSolverInterface.hpp:858
OsiGlpkSolverInterface::FREECACHED_ROW
free only cached row and LP solution information
Definition: OsiGlpkSolverInterface.hpp:656
OsiGlpkSolverInterface::isProvenPrimalInfeasible
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
OsiSolverInterface::addCols
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.
OsiSolverInterface::isBinary
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
OsiGlpkSolverInterface::getRowSense
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
OsiGlpkSolverInterface::hotStartMaxIteration_
int hotStartMaxIteration_
simplex iteration limit (for hot start)
Definition: OsiGlpkSolverInterface.hpp:782
OsiGlpkSolverInterface::getPrimalRays
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
OsiGlpkSolverInterface::getMatrixByCol
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
OsiGlpkSolverInterface::setIntParam
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
OsiGlpkSolverInterface::getObjValue
virtual double getObjValue() const
Get objective function value.
OsiGlpkSolverInterface::rowrange_
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
Definition: OsiGlpkSolverInterface.hpp:876
OsiGlpkSolverInterface::setRowSetTypes
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()...
OsiGlpkSolverInterface::getRightHandSide
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
OsiGlpkSolverInterface::freeCachedMatrix
void freeCachedMatrix()
free cached matrices
OsiGlpkSolverInterface::getInfinity
virtual double getInfinity() const
Get solver&#39;s value for infinity.
OsiGlpkSolverInterface::freeCachedRowRim
void freeCachedRowRim()
free cached row rim vectors
OsiGlpkSolverInterface::freeCachedColRim
void freeCachedColRim()
free cached column rim vectors
OsiGlpkSolverInterface::getNumInstances
static unsigned int getNumInstances()
Return the number of LP/MIP instances of instantiated objects using the GLPK environment.
Definition: OsiGlpkSolverInterface.hpp:688
OsiGlpkSolverInterface::reset
virtual void reset()
Resets as if default constructor.
OsiGlpkSolverInterface::getObjCoefficients
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
OsiGlpkSolverInterface::getDualRays
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
OsiRowCut
Row Cut Class.
Definition: OsiRowCut.hpp:29
OsiGlpkSolverInterface::getNumElements
virtual CoinBigIndex getNumElements() const
Get number of nonzero elements.
OsiGlpkSolverInterface::iter_used_
int iter_used_
Number of iterations.
Definition: OsiGlpkSolverInterface.hpp:855
OsiSolverInterface::applyCuts
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
OsiGlpkSolverInterface::readMps
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
OsiGlpkSolverInterface::hotStartCStat_
int * hotStartCStat_
column status array
Definition: OsiGlpkSolverInterface.hpp:810
OsiGlpkSolverInterface::objOffset_
double objOffset_
constant offset for objective function
Definition: OsiGlpkSolverInterface.hpp:796
OsiGlpkSolverInterface::getNumRows
virtual int getNumRows() const
Get number of rows.
OsiGlpkSolverInterface::getIterationCount
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever &quot;iteration&quot; mean to the solver...
CoinPackedMatrix
Sparse Matrix Base Class.
Definition: CoinPackedMatrix.hpp:79
OsiGlpkSolverInterface::setColName
void setColName(int ndx, std::string name)
Set a column name.
OsiGlpkSolverInterface::setStrParam
bool setStrParam(OsiStrParam key, const std::string &value)
Set a string parameter.
OsiGlpkSolverInterface::loadProblem
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...
OsiGlpkSolverInterface::markHotStart
virtual void markHotStart()
Create a hotstart point of the optimization process.
OsiGlpkSolverInterface::isPrimInfeasible_
bool isPrimInfeasible_
glpk declared the problem primal infeasible
Definition: OsiGlpkSolverInterface.hpp:845
OsiHintTry
This means it is only a hint.
Definition: OsiSolverParameters.hpp:134
OsiGlpkSolverInterface::nameDisc_
int nameDisc_
OSI name discipline.
Definition: OsiGlpkSolverInterface.hpp:784
OsiGlpkSolverInterface::setRowType
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
OsiGlpkSolverInterface::deleteCols
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
OsiSolverInterface.hpp
OsiGlpkSolverInterface::getRowPrice
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
OsiSolverInterface::isFreeBinary
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
OsiGlpkSolverInterface::getColSolution
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
OsiGlpkSolverInterface::addRow
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
CoinBigIndex
int CoinBigIndex
Definition: Coin_C_defines.h:136
OsiHintParam
OsiHintParam
Definition: OsiSolverParameters.hpp:106
OsiGlpkSolverInterface::gutsOfCopy
void gutsOfCopy(const OsiGlpkSolverInterface &source)
The real work of a copy constructor (used by copy and assignment)
OsiGlpkSolverInterface::setColLower
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
OsiGlpkSolverInterface::hotStartCVal_
double * hotStartCVal_
primal variable values
Definition: OsiGlpkSolverInterface.hpp:812
OsiGlpkSolverInterface::isTimeLimitReached
virtual bool isTimeLimitReached() const
Time limit reached?
OsiGlpkSolverInterface::KEEPCACHED_ALL
keep all cached data (similar to getMutableLpPtr())
Definition: OsiGlpkSolverInterface.hpp:652
OsiGlpkSolverInterface::hotStartCStatSize_
int hotStartCStatSize_
Hotstart information.
Definition: OsiGlpkSolverInterface.hpp:808
OsiGlpkSolverInterface::numInstances_
static unsigned int numInstances_
number of GLPK instances currently in use (counts only those created by OsiGlpk)
Definition: OsiGlpkSolverInterface.hpp:772
OsiGlpkSolverInterface::lp_
LPX * lp_
GPLK model represented by this class instance.
Definition: OsiGlpkSolverInterface.hpp:769
OsiGlpkSolverInterface::setObjCoeff
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
OsiGlpkSolverInterface::rhs_
double * rhs_
Pointer to dense vector of row right-hand side values.
Definition: OsiGlpkSolverInterface.hpp:873
OsiGlpkSolverInterface::rowsol_
double * rowsol_
Pointer to dual solution vector.
Definition: OsiGlpkSolverInterface.hpp:888
OsiGlpkSolverInterface::getMatrixByRow
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
OsiGlpkSolverInterface
Definition: OsiGlpkSolverInterface.hpp:36
OsiGlpkSolverInterface::isFeasible_
bool isFeasible_
glpk declared the problem feasible
Definition: OsiGlpkSolverInterface.hpp:849
OsiGlpkSolverInterface::hotStartRStatSize_
int hotStartRStatSize_
size of row status and value arrays
Definition: OsiGlpkSolverInterface.hpp:817
OsiGlpkSolverInterface::isDualInfeasible_
bool isDualInfeasible_
glpk declared the problem dual infeasible
Definition: OsiGlpkSolverInterface.hpp:847
OsiGlpkSolverInterface::getRowRange
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
OsiGlpkSolverInterface::ctype_
char * ctype_
Pointer to dense vector of variable types (continous, binary, integer)
Definition: OsiGlpkSolverInterface.hpp:867
OsiGlpkSolverInterface::OsiGlpkSolverInterface
OsiGlpkSolverInterface()
Default Constructor.
CoinWarmStartBasis.hpp
OsiIntParam
OsiIntParam
Definition: OsiSolverParameters.hpp:8
OsiGlpkSolverInterface::colsol_
double * colsol_
Pointer to primal solution vector.
Definition: OsiGlpkSolverInterface.hpp:885
OsiGlpkSolverInterface::keepCachedFlag
keepCachedFlag
Definition: OsiGlpkSolverInterface.hpp:638
OsiGlpkSolverInterface::setWarmStart
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
OsiGlpkSolverInterface::rowlower_
double * rowlower_
Pointer to dense vector of row lower bounds.
Definition: OsiGlpkSolverInterface.hpp:879
OsiGlpkSolverInterface::setObjSense
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
OsiGlpkSolverInterfaceUnitTest
void OsiGlpkSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiGlpkSolverInterface class.
OsiGlpkSolverInterface::redcost_
double * redcost_
Pointer to reduced cost vector.
Definition: OsiGlpkSolverInterface.hpp:891
OsiGlpkSolverInterface::maxIteration_
int maxIteration_
simplex iteration limit (per call to solver)
Definition: OsiGlpkSolverInterface.hpp:780
OsiSolverInterface::addRow
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)=0
Add a row (constraint) to the problem.
OsiVectorInt
std::vector< int > OsiVectorInt
Vector of int.
Definition: OsiCollections.hpp:20
OsiGlpkSolverInterface::printBounds
void printBounds()
Just for testing purposes.
OsiGlpkSolverInterface::isObjUpperLimitReached_
bool isObjUpperLimitReached_
glpk stopped on upper objective limit
Definition: OsiGlpkSolverInterface.hpp:843
OsiGlpkSolverInterface::setRowUpper
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
OsiGlpkSolverInterface::setObjName
void setObjName(std::string name)
Set the objective function name.
OsiGlpkSolverInterface::setColUpper
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
OsiGlpkSolverInterface::hotStartRVal_
double * hotStartRVal_
row slack values
Definition: OsiGlpkSolverInterface.hpp:821
OsiGlpkSolverInterface::KEEPCACHED_ROW
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
Definition: OsiGlpkSolverInterface.hpp:644
OsiGlpkSolverInterface::getRowActivity
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
OsiGlpkSolverInterface::dualTolerance_
double dualTolerance_
dual feasibility tolerance
Definition: OsiGlpkSolverInterface.hpp:792
OsiGlpkSolverInterface::KEEPCACHED_MATRIX
problem matrix: matrix ordered by column and by row
Definition: OsiGlpkSolverInterface.hpp:646
OsiGlpkSolverInterface::KEEPCACHED_COLUMN
column information: objective values, lower and upper bounds, variable types
Definition: OsiGlpkSolverInterface.hpp:642
OsiGlpkSolverInterface::getColLower
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
OsiGlpkSolverInterface::primalTolerance_
double primalTolerance_
primal feasibility tolerance
Definition: OsiGlpkSolverInterface.hpp:794
OsiGlpkSolverInterface::fillColBounds
void fillColBounds() const
Fill cached collumn bounds.
OsiGlpkSolverInterface::setInteger
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
OsiGlpkSolverInterface::bbWasLast_
int bbWasLast_
Definition: OsiGlpkSolverInterface.hpp:776
OsiGlpkSolverInterface::FREECACHED_RESULTS
free only cached LP solution information
Definition: OsiGlpkSolverInterface.hpp:660
CoinWarmStart
Abstract base class for warm start information.
Definition: CoinWarmStart.hpp:21
LPX
#define LPX
GPLK Solver Interface.
Definition: OsiGlpkSolverInterface.hpp:24
OsiGlpkSolverInterface::getStrParam
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
CoinPackedMatrix.hpp
glp_prob
Definition: OsiGlpkSolverInterface.hpp:30
OsiGlpkSolverInterface::setRowSetBounds
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...