Osi  0.106.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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 1968 2014-06-12 16:03:54Z stefan $
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 SoPlex;
30 }
31 #endif
32 
36 class OsiSpxSolverInterface : virtual public OsiSolverInterface {
37  friend void OsiSpxSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
38 
39 public:
40 
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  { return (dynamic_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
113  virtual CoinWarmStart* getWarmStart() const;
116  virtual bool setWarmStart(const CoinWarmStart* warmstart);
118 
119  //---------------------------------------------------------------------------
126  virtual void markHotStart();
129  virtual void solveFromHotStart();
131  virtual void unmarkHotStart();
133 
134  //---------------------------------------------------------------------------
149  virtual int getNumCols() const;
151 
153  virtual int getNumRows() const;
154 
156  virtual int getNumElements() const;
157 
159  virtual const double * getColLower() const;
160 
162  virtual const double * getColUpper() const;
163 
173  virtual const char * getRowSense() const;
174 
183  virtual const double * getRightHandSide() const;
184 
193  virtual const double * getRowRange() const;
194 
196  virtual const double * getRowLower() const;
197 
199  virtual const double * getRowUpper() const;
200 
202  virtual const double * getObjCoefficients() const;
203 
205  virtual double getObjSense() const;
206 
208  virtual bool isContinuous(int colNumber) const;
209 
210 #if 0
211  virtual bool isBinary(int columnNumber) const;
213 
218  virtual bool isInteger(int columnNumber) const;
219 
221  virtual bool isIntegerNonBinary(int columnNumber) const;
222 
224  virtual bool isFreeBinary(int columnNumber) const;
225 #endif
226 
228  virtual const CoinPackedMatrix * getMatrixByRow() const;
229 
231  virtual const CoinPackedMatrix * getMatrixByCol() const;
232 
234  virtual double getInfinity() const;
236 
239  virtual const double * getColSolution() const;
241 
243  virtual const double * getRowPrice() const;
244 
246  virtual const double * getReducedCost() const;
247 
250  virtual const double * getRowActivity() const;
251 
253  virtual double getObjValue() const;
254 
257  virtual int getIterationCount() const;
258 
276  virtual std::vector<double*> getDualRays(int maxNumRays,
277  bool fullRay=false) const;
289  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
290 
291 #if 0
292 
294  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
295  const;
296 #endif
297 
298 
299 
300  //---------------------------------------------------------------------------
301 
304  //-------------------------------------------------------------------------
308  virtual void setObjCoeff( int elementIndex, double elementValue );
309 
312  virtual void setColLower( int elementIndex, double elementValue );
313 
316  virtual void setColUpper( int elementIndex, double elementValue );
317 
321  virtual void setColBounds( int elementIndex,
322  double lower, double upper );
323 
324 #if 0 // we are using the default implementation of OsiSolverInterface
325 
333  virtual void setColSetBounds(const int* indexFirst,
334  const int* indexLast,
335  const double* boundList);
336 #endif
337 
340  virtual void setRowLower( int elementIndex, double elementValue );
341 
344  virtual void setRowUpper( int elementIndex, double elementValue );
345 
349  virtual void setRowBounds( int elementIndex,
350  double lower, double upper );
351 
353  virtual void setRowType(int index, char sense, double rightHandSide,
354  double range);
355 
356 #if 0 // we are using the default implementation of OsiSolverInterface
357 
364  virtual void setRowSetBounds(const int* indexFirst,
365  const int* indexLast,
366  const double* boundList);
367 
377  virtual void setRowSetTypes(const int* indexFirst,
378  const int* indexLast,
379  const char* senseList,
380  const double* rhsList,
381  const double* rangeList);
382 #endif
383 
384 
385  //-------------------------------------------------------------------------
389  virtual void setContinuous(int index);
391  virtual void setInteger(int index);
392 #if 0 // we are using the default implementation of OsiSolverInterface
393 
395  virtual void setContinuous(const int* indices, int len);
398  virtual void setInteger(const int* indices, int len);
399 #endif
400 
401 
402  //-------------------------------------------------------------------------
404  virtual void setObjSense(double s);
405 
416  virtual void setColSolution(const double * colsol);
417 
428  virtual void setRowPrice(const double * rowprice);
429 
430  //-------------------------------------------------------------------------
436  virtual void addCol(const CoinPackedVectorBase& vec,
437  const double collb, const double colub,
438  const double obj);
439 
440 #if 0 // we are using the default implementation of OsiSolverInterface
441 
442  virtual void addCols(const int numcols,
443  const CoinPackedVectorBase * const * cols,
444  const double* collb, const double* colub,
445  const double* obj);
446 #endif
447 
449  virtual void deleteCols(const int num, const int * colIndices);
450 
452  virtual void addRow(const CoinPackedVectorBase& vec,
453  const double rowlb, const double rowub);
455  virtual void addRow(const CoinPackedVectorBase& vec,
456  const char rowsen, const double rowrhs,
457  const double rowrng);
458 
459 #if 0 // we are using the default implementation of OsiSolverInterface
460 
461  virtual void addRows(const int numrows,
462  const CoinPackedVectorBase * const * rows,
463  const double* rowlb, const double* rowub);
465  virtual void addRows(const int numrows,
466  const CoinPackedVectorBase * const * rows,
467  const char* rowsen, const double* rowrhs,
468  const double* rowrng);
469 #endif
470 
472  virtual void deleteRows(const int num, const int * rowIndices);
473 
474 #if 0 // we are using the default implementation of OsiSolverInterface
475  //-----------------------------------------------------------------------
497  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
498  double effectivenessLb = 0.0);
499 #endif
500 
501 
502 
503  //---------------------------------------------------------------------------
504 
518  virtual void loadProblem(const CoinPackedMatrix& matrix,
519  const double* collb, const double* colub,
520  const double* obj,
521  const double* rowlb, const double* rowub);
522 
530  virtual void assignProblem(CoinPackedMatrix*& matrix,
531  double*& collb, double*& colub, double*& obj,
532  double*& rowlb, double*& rowub);
533 
546  virtual void loadProblem(const CoinPackedMatrix& matrix,
547  const double* collb, const double* colub,
548  const double* obj,
549  const char* rowsen, const double* rowrhs,
550  const double* rowrng);
551 
559  virtual void assignProblem(CoinPackedMatrix*& matrix,
560  double*& collb, double*& colub, double*& obj,
561  char*& rowsen, double*& rowrhs,
562  double*& rowrng);
563 
566  virtual void loadProblem(const int numcols, const int numrows,
567  const int* start, const int* index,
568  const double* value,
569  const double* collb, const double* colub,
570  const double* obj,
571  const double* rowlb, const double* rowub);
572 
575  virtual void loadProblem(const int numcols, const int numrows,
576  const int* start, const int* index,
577  const double* value,
578  const double* collb, const double* colub,
579  const double* obj,
580  const char* rowsen, const double* rowrhs,
581  const double* rowrng);
582 
584  virtual int readMps(const char *filename,
585  const char *extension = "mps");
586 
591  virtual void writeMps(const char *filename,
592  const char *extension = "mps",
593  double objSense=0.0) const;
595 
596  //---------------------------------------------------------------------------
597 
602 
604  virtual OsiSolverInterface * clone(bool copyData = true) const;
605 
608 
611 
613  virtual ~OsiSpxSolverInterface();
615 
616 protected:
617 
620  virtual void applyRowCut( const OsiRowCut & rc );
622 
626  virtual void applyColCut( const OsiColCut & cc );
628 
631  soplex::SoPlex *soplex_;
634 
635 
636 private:
639 
641  void freeCachedColRim();
642 
644  void freeCachedRowRim();
645 
647  void freeCachedResults();
648 
650  void freeCachedMatrix();
651 
653  {
676  };
677 
679  void freeCachedData( int keepCached = KEEPCACHED_NONE );
680 
682  void freeAllMemory();
684 
685 
688  soplex::DIdxSet *spxintvars_;
690 
697 
700  mutable soplex::DVector *obj_;
702 
704  mutable char *rowsense_;
705 
707  mutable double *rhs_;
708 
710  mutable double *rowrange_;
711 
713  mutable soplex::DVector *colsol_;
714 
716  mutable soplex::DVector *rowsol_;
717 
719  mutable soplex::DVector *redcost_;
720 
722  mutable soplex::DVector *rowact_;
723 
725  mutable CoinPackedMatrix *matrixByRow_;
726 
728  mutable CoinPackedMatrix *matrixByCol_;
730 
731 };
732 
733 //#############################################################################
735 void OsiSpxSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
736 
737 #endif
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 const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
SoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex.
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut. Return true if cut was applied.
char * rowsense_
Pointer to dense vector of row sense indicators.
column information: objective values, lower and upper bounds, variable types
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -COIN_DBL_MAX for -infinity.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
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 bool isAbandoned() const
Are there a numerical difficulties?
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
virtual void unmarkHotStart()
Delete the snapshot.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
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 void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the upper and lower bounds of a set of columns.
virtual double getInfinity() const
Get solver's value for infinity.
soplex::DVector * rowsol_
Pointer to dual solution vector.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows) ...
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
virtual double getObjValue() const
Get objective function value.
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename.
virtual void markHotStart()
Create a hotstart point of the optimization process.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -COIN_DBL_MAX for -infinity.
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
Add a row (constraint) to the problem.
free only cached row and LP solution information
void freeCachedMatrix()
free cached matrices
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
virtual bool isProvenOptimal() const
Is optimality proven?
problem matrix: matrix ordered by column and by row
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
Abstract Base Class for describing an interface to a solver.
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
virtual bool isTimeLimitReached() const
Time limit reached?
void freeAllMemory()
free all allocated memory
void * hotStartCStat_
Hotstart information.
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver...
OsiSpxSolverInterface()
Default Constructor.
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 deleteCols(const int num, const int *colIndices)
Remove a set of columns (primal variables) from the problem.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
virtual bool isIterationLimitReached() const
Iteration limit reached?
discard all cached data (default)
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use COIN_DBL_MAX for infinity.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
void freeCachedColRim()
free cached column rim vectors
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
std::vector< int > OsiVectorInt
Vector of int.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
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)
Add a column (primal variable) to the problem.
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
virtual int getNumRows() const
Get number of rows.
soplex::DVector * obj_
Pointer to objective Vector.
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
virtual int getNumCols() const
Get number of columns.
bool setIntParam(OsiIntParam key, int value)
Set an integer parameter.
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.
soplex::DVector * colsol_
Pointer to primal solution vector.
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
row information: right hand sides, ranges and senses, lower and upper bounds for row ...
void setTimeLimit(double value)
virtual void initialSolve()
Solve initial LP relaxation.
keep all cached data (similar to getMutableLpPtr())
void freeCachedRowRim()
free cached row rim vectors
void freeCachedData(int keepCached=KEEPCACHED_NONE)
free all cached data (except specified entries, see getLpPtr())
double getTimeLimit() const
free only cached LP solution information
Row Cut Class.
Definition: OsiRowCut.hpp:29
bool getStrParam(OsiStrParam key, std::string &value) const
Get a string parameter.
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
void freeCachedResults()
free cached result vectors
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
virtual void resolve()
Resolve an LP relaxation after problem modification.
free only cached matrix and LP solution information
virtual void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a set of rows.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
double * rhs_
Pointer to dense vector of row right-hand side values.
soplex::DIdxSet * spxintvars_
indices of integer variables
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
virtual int getNumElements() const
Get number of nonzero elements.
soplex::DVector * rowact_
Pointer to row activity (slack) vector.
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
virtual ~OsiSpxSolverInterface()
Destructor.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
free only cached column and LP solution information
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use COIN_DBL_MAX for infinity.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
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...
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (bound adjustment).
virtual void deleteRows(const int num, const int *rowIndices)
Delete a set of rows (constraints) from the problem.
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
CoinWarmStart * getEmptyWarmStart() const
Get empty warm start object.
soplex::DVector * redcost_
Pointer to reduced cost vector.
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...
soplex::SoPlex * soplex_
SoPlex solver object.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiSpxSolverInterface class.
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
bool getDblParam(OsiDblParam key, double &value) const
Get a double parameter.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
Internal class for obtaining status from the applyCuts method.
LP solution: primal and dual solution, reduced costs, row activities.
friend void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiSpxSolverInterface class.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
bool setDblParam(OsiDblParam key, double value)
Set a double parameter.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
bool getIntParam(OsiIntParam key, int &value) const
Get an integer parameter.
OsiSpxSolverInterface & operator=(const OsiSpxSolverInterface &rhs)
Assignment operator.
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...