Osi  0.108.6
OsiSpxSolverInterface.hpp
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // name: OSI Interface for SoPlex >= 1.4.2c
3 // authors: Tobias Pfender
4 // Ambros Gleixner
5 // Wei Huang
6 // Konrad-Zuse-Zentrum Berlin (Germany)
7 // email: pfender@zib.de
8 // date: 01/16/2002
9 // license: this file may be freely distributed under the terms of the EPL
10 //-----------------------------------------------------------------------------
11 // Copyright (C) 2002, Tobias Pfender, International Business Machines
12 // Corporation and others. All Rights Reserved.
13 // Last edit: $Id: OsiSpxSolverInterface.hpp 2200 2019-01-06 23:02:02Z unxusr $
14 
15 #ifndef OsiSpxSolverInterface_H
16 #define OsiSpxSolverInterface_H
17 
18 #include <string>
19 #include "OsiSolverInterface.hpp"
20 #include "CoinWarmStartBasis.hpp"
21 
22 #ifndef _SOPLEX_H_
23 /* forward declarations so the header can be compiled without having to include soplex.h
24  * however, these declaration work only for SoPlex < 2.0, so we do them only if soplex.h hasn't been included already
25  */
26 namespace soplex {
27 class DIdxSet;
28 class DVector;
29 class SPxOut;
30 class SoPlex;
31 }
32 #endif
33 
37 class OsiSpxSolverInterface : virtual public OsiSolverInterface {
38  friend void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
39 
40 public:
41  //---------------------------------------------------------------------------
44  virtual void initialSolve();
46 
48  virtual void resolve();
49 
51  virtual void branchAndBound();
53 
54  //---------------------------------------------------------------------------
70  // Set an integer parameter
71  bool setIntParam(OsiIntParam key, int value);
72  // Set an double parameter
73  bool setDblParam(OsiDblParam key, double value);
74  // Get an integer parameter
75  bool getIntParam(OsiIntParam key, int &value) const;
76  // Get an double parameter
77  bool getDblParam(OsiDblParam key, double &value) const;
78  // Get a string parameter
79  bool getStrParam(OsiStrParam key, std::string &value) const;
80  // Set timelimit
81  void setTimeLimit(double value);
82  // Get timelimit
83  double getTimeLimit() const;
85 
86  //---------------------------------------------------------------------------
88 
89  virtual bool isAbandoned() const;
92  virtual bool isProvenOptimal() const;
94  virtual bool isProvenPrimalInfeasible() const;
96  virtual bool isProvenDualInfeasible() const;
97  // Is the given primal objective limit reached? - use implementation from OsiSolverInterface
99  virtual bool isDualObjectiveLimitReached() const;
101  virtual bool isIterationLimitReached() const;
103  virtual bool isTimeLimitReached() const;
105 
106  //---------------------------------------------------------------------------
109  inline CoinWarmStart *getEmptyWarmStart() const
111  {
112  return (dynamic_cast< CoinWarmStart * >(new CoinWarmStartBasis()));
113  }
115  virtual CoinWarmStart *getWarmStart() const;
118  virtual bool setWarmStart(const CoinWarmStart *warmstart);
120 
121  //---------------------------------------------------------------------------
128  virtual void markHotStart();
131  virtual void solveFromHotStart();
133  virtual void unmarkHotStart();
135 
136  //---------------------------------------------------------------------------
151  virtual int getNumCols() const;
153 
155  virtual int getNumRows() const;
156 
158  virtual int getNumElements() const;
159 
161  virtual const double *getColLower() const;
162 
164  virtual const double *getColUpper() const;
165 
175  virtual const char *getRowSense() const;
176 
185  virtual const double *getRightHandSide() const;
186 
195  virtual const double *getRowRange() const;
196 
198  virtual const double *getRowLower() const;
199 
201  virtual const double *getRowUpper() const;
202 
204  virtual const double *getObjCoefficients() const;
205 
207  virtual double getObjSense() const;
208 
210  virtual bool isContinuous(int colNumber) const;
211 
212 #if 0
214  virtual bool isBinary(int columnNumber) const;
215 
220  virtual bool isInteger(int columnNumber) const;
221 
223  virtual bool isIntegerNonBinary(int columnNumber) const;
224 
226  virtual bool isFreeBinary(int columnNumber) const;
227 #endif
228 
230  virtual const CoinPackedMatrix *getMatrixByRow() const;
231 
233  virtual const CoinPackedMatrix *getMatrixByCol() const;
234 
236  virtual double getInfinity() const;
238 
242  virtual const double *getColSolution() const;
243 
245  virtual const double *getRowPrice() const;
246 
248  virtual const double *getReducedCost() const;
249 
252  virtual const double *getRowActivity() const;
253 
255  virtual double getObjValue() const;
256 
259  virtual int getIterationCount() const;
260 
278  virtual std::vector< double * > getDualRays(int maxNumRays,
279  bool fullRay = false) const;
291  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
292 
293 #if 0
296  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
297  const;
298 #endif
300 
301 
302  //---------------------------------------------------------------------------
303 
306  //-------------------------------------------------------------------------
310  virtual void setObjCoeff(int elementIndex, double elementValue);
311 
314  virtual void setColLower(int elementIndex, double elementValue);
315 
318  virtual void setColUpper(int elementIndex, double elementValue);
319 
323  virtual void setColBounds(int elementIndex,
324  double lower, double upper);
325 
326 #if 0 // we are using the default implementation of OsiSolverInterface
335  virtual void setColSetBounds(const int* indexFirst,
336  const int* indexLast,
337  const double* boundList);
338 #endif
339 
342  virtual void setRowLower(int elementIndex, double elementValue);
343 
346  virtual void setRowUpper(int elementIndex, double elementValue);
347 
351  virtual void setRowBounds(int elementIndex,
352  double lower, double upper);
353 
355  virtual void setRowType(int index, char sense, double rightHandSide,
356  double range);
357 
358 #if 0 // we are using the default implementation of OsiSolverInterface
366  virtual void setRowSetBounds(const int* indexFirst,
367  const int* indexLast,
368  const double* boundList);
369 
379  virtual void setRowSetTypes(const int* indexFirst,
380  const int* indexLast,
381  const char* senseList,
382  const double* rhsList,
383  const double* rangeList);
384 #endif
386 
387  //-------------------------------------------------------------------------
391  virtual void setContinuous(int index);
393  virtual void setInteger(int index);
394 #if 0 // we are using the default implementation of OsiSolverInterface
397  virtual void setContinuous(const int* indices, int len);
400  virtual void setInteger(const int* indices, int len);
401 #endif
403 
404  //-------------------------------------------------------------------------
406  virtual void setObjSense(double s);
407 
418  virtual void setColSolution(const double *colsol);
419 
430  virtual void setRowPrice(const double *rowprice);
431 
432  //-------------------------------------------------------------------------
438  virtual void addCol(const CoinPackedVectorBase &vec,
439  const double collb, const double colub,
440  const double obj);
441 
442 #if 0 // we are using the default implementation of OsiSolverInterface
444  virtual void addCols(const int numcols,
445  const CoinPackedVectorBase * const * cols,
446  const double* collb, const double* colub,
447  const double* obj);
448 #endif
449 
451  virtual void deleteCols(const int num, const int *colIndices);
452 
454  virtual void addRow(const CoinPackedVectorBase &vec,
455  const double rowlb, const double rowub);
457  virtual void addRow(const CoinPackedVectorBase &vec,
458  const char rowsen, const double rowrhs,
459  const double rowrng);
460 
461 #if 0 // we are using the default implementation of OsiSolverInterface
463  virtual void addRows(const int numrows,
464  const CoinPackedVectorBase * const * rows,
465  const double* rowlb, const double* rowub);
467  virtual void addRows(const int numrows,
468  const CoinPackedVectorBase * const * rows,
469  const char* rowsen, const double* rowrhs,
470  const double* rowrng);
471 #endif
472 
474  virtual void deleteRows(const int num, const int *rowIndices);
475 
476 #if 0 // we are using the default implementation of OsiSolverInterface \
477  //-----------------------------------------------------------------------
499  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
500  double effectivenessLb = 0.0);
501 #endif
503 
504 
505  //---------------------------------------------------------------------------
506 
520  virtual void loadProblem(const CoinPackedMatrix &matrix,
521  const double *collb, const double *colub,
522  const double *obj,
523  const double *rowlb, const double *rowub);
524 
532  virtual void assignProblem(CoinPackedMatrix *&matrix,
533  double *&collb, double *&colub, double *&obj,
534  double *&rowlb, double *&rowub);
535 
548  virtual void loadProblem(const CoinPackedMatrix &matrix,
549  const double *collb, const double *colub,
550  const double *obj,
551  const char *rowsen, const double *rowrhs,
552  const double *rowrng);
553 
561  virtual void assignProblem(CoinPackedMatrix *&matrix,
562  double *&collb, double *&colub, double *&obj,
563  char *&rowsen, double *&rowrhs,
564  double *&rowrng);
565 
568  virtual void loadProblem(const int numcols, const int numrows,
569  const int *start, const int *index,
570  const double *value,
571  const double *collb, const double *colub,
572  const double *obj,
573  const double *rowlb, const double *rowub);
574 
577  virtual void loadProblem(const int numcols, const int numrows,
578  const int *start, const int *index,
579  const double *value,
580  const double *collb, const double *colub,
581  const double *obj,
582  const char *rowsen, const double *rowrhs,
583  const double *rowrng);
584 
586  virtual int readMps(const char *filename,
587  const char *extension = "mps");
588 
593  virtual void writeMps(const char *filename,
594  const char *extension = "mps",
595  double objSense = 0.0) const;
597 
598  //---------------------------------------------------------------------------
599 
604 
606  virtual OsiSolverInterface *clone(bool copyData = true) const;
607 
610 
613 
617 
641  };
642  soplex::SoPlex *getLpPtr(int keepCached = KEEPCACHED_NONE);
643 
644  soplex::SPxOut *getSPxOut() { return spxout_; }
645 
646 protected:
650  virtual void applyRowCut(const OsiRowCut &rc);
651 
655  virtual void applyColCut(const OsiColCut &cc);
657 
661  soplex::SPxOut *spxout_;
663  soplex::SoPlex *soplex_;
665 
666 private:
669 
672 
675 
678 
681 
683  void freeCachedData(int keepCached = KEEPCACHED_NONE);
684 
688 
692  soplex::DIdxSet *spxintvars_;
693 
700 
704  mutable soplex::DVector *obj_;
705 
707  mutable char *rowsense_;
708 
710  mutable double *rhs_;
711 
713  mutable double *rowrange_;
714 
716  mutable soplex::DVector *colsol_;
717 
719  mutable soplex::DVector *rowsol_;
720 
722  mutable soplex::DVector *redcost_;
723 
725  mutable soplex::DVector *rowact_;
726 
728  mutable CoinPackedMatrix *matrixByRow_;
729 
731  mutable CoinPackedMatrix *matrixByCol_;
733 
734 };
735 
736 //#############################################################################
738 void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
739 
740 #endif
741 
742 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
743 */
std::vector< int > OsiVectorInt
Vector of int.
void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiSpxSolverInterface class.
Column Cut Class.
Definition: OsiColCut.hpp:23
Row Cut Class.
Definition: OsiRowCut.hpp:29
Abstract Base Class for describing an interface to a solver.
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 bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general 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 bool isBinary(int colIndex) const
Return true if the variable is binary.
virtual void setRowSetTypes(const int *indexFirst, const int *indexLast, const char *senseList, const double *rhsList, const double *rangeList)
Set the type of a set of rows.
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
SoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
double getTimeLimit() const
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
virtual void loadProblem(const int numcols, const int numrows, const int *start, const int *index, const double *value, const double *collb, const double *colub, const double *obj, const char *rowsen, const double *rowrhs, const double *rowrng)
Just like the other loadProblem() methods except that the matrix is given in a standard column major ...
virtual bool isTimeLimitReached() const
Time limit reached?
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
Add a column (primal variable) to the problem.
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
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...
OsiSpxSolverInterface()
Default Constructor.
virtual int getNumRows() const
Get number of rows.
friend void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiSpxSolverInterface class.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
CoinWarmStart * getEmptyWarmStart() const
Get empty warm start object.
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
virtual void loadProblem(const CoinPackedMatrix &matrix, const double *collb, const double *colub, const double *obj, const char *rowsen, const double *rowrhs, const double *rowrng)
Load in an problem by copying the arguments (the constraints on the rows are given by sense/rhs/range...
soplex::DVector * rowsol_
Pointer to dual solution vector.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
void freeCachedRowRim()
free cached row rim vectors
virtual bool isIterationLimitReached() const
Iteration limit reached?
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
soplex::SoPlex * getLpPtr(int keepCached=KEEPCACHED_NONE)
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
virtual void markHotStart()
Create a hotstart point of the optimization process.
virtual bool isAbandoned() const
Are there a numerical difficulties?
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
OsiSpxSolverInterface(const OsiSpxSolverInterface &)
Copy constructor.
virtual void deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
void freeCachedColRim()
free cached column rim vectors
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
double * rhs_
Pointer to dense vector of row right-hand side values.
soplex::DVector * rowact_
Pointer to row activity (slack) vector.
OsiSpxSolverInterface & operator=(const OsiSpxSolverInterface &rhs)
Assignment operator.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
soplex::SoPlex * soplex_
SoPlex solver object.
soplex::DVector * obj_
Pointer to objective Vector.
void setTimeLimit(double value)
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound The default implementation just invokes setRowUower and setRo...
char * rowsense_
Pointer to dense vector of row sense indicators.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows)
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
virtual double getInfinity() const
Get solver's value for infinity.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
virtual void initialSolve()
Solve initial LP relaxation.
virtual int getNumCols() const
Get number of columns.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
virtual void unmarkHotStart()
Delete the snapshot.
void freeCachedResults()
free cached result vectors
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
soplex::DVector * redcost_
Pointer to reduced cost vector.
virtual void addRow(const CoinPackedVectorBase &vec, const char rowsen, const double rowrhs, const double rowrng)
Add a row (constraint) to the problem.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
soplex::SPxOut * spxout_
SoPlex output object.
void freeAllMemory()
free all allocated memory
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
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.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
virtual void resolve()
Resolve an LP relaxation after problem modification.
soplex::DVector * colsol_
Pointer to primal solution vector.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
void * hotStartCStat_
Hotstart information.
void freeCachedMatrix()
free cached matrices
@ KEEPCACHED_MATRIX
problem matrix: matrix ordered by column and by row
@ KEEPCACHED_ALL
keep all cached data (similar to getMutableLpPtr())
@ FREECACHED_COLUMN
free only cached column and LP solution information
@ FREECACHED_RESULTS
free only cached LP solution information
@ FREECACHED_MATRIX
free only cached matrix and LP solution information
@ KEEPCACHED_PROBLEM
only discard cached LP solution
@ KEEPCACHED_NONE
discard all cached data (default)
@ FREECACHED_ROW
free only cached row and LP solution information
@ KEEPCACHED_ROW
row information: right hand sides, ranges and senses, lower and upper bounds for row
@ KEEPCACHED_RESULTS
LP solution: primal and dual solution, reduced costs, row activities.
@ KEEPCACHED_COLUMN
column information: objective values, lower and upper bounds, variable types
virtual void assignProblem(CoinPackedMatrix *&matrix, double *&collb, double *&colub, double *&obj, char *&rowsen, double *&rowrhs, double *&rowrng)
Load in an problem by assuming ownership of the arguments (the constraints on the rows are given by s...
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound The default implementation just invokes setColLower and se...
virtual bool isProvenOptimal() const
Is optimality proven?
virtual int getNumElements() const
Get number of nonzero elements.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
virtual double getObjValue() const
Get objective function value.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
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...
virtual void loadProblem(const int numcols, const int numrows, const int *start, const int *index, const double *value, const double *collb, const double *colub, const double *obj, const double *rowlb, const double *rowub)
Just like the other loadProblem() methods except that the matrix is given in a standard column major ...
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
soplex::DIdxSet * spxintvars_
indices of integer variables
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
virtual ~OsiSpxSolverInterface()
Destructor.
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.