Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups 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 2019 2015-06-11 08:50:04Z 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 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 
42  //---------------------------------------------------------------------------
45  virtual void initialSolve();
47 
49  virtual void resolve();
50 
52  virtual void branchAndBound();
54 
55  //---------------------------------------------------------------------------
71  // Set an integer parameter
72  bool setIntParam(OsiIntParam key, int value);
73  // Set an double parameter
74  bool setDblParam(OsiDblParam key, double value);
75  // Get an integer parameter
76  bool getIntParam(OsiIntParam key, int& value) const;
77  // Get an double parameter
78  bool getDblParam(OsiDblParam key, double& value) const;
79  // Get a string parameter
80  bool getStrParam(OsiStrParam key, std::string& value) const;
81  // Set timelimit
82  void setTimeLimit(double value);
83  // Get timelimit
84  double getTimeLimit() const;
86 
87  //---------------------------------------------------------------------------
89 
90  virtual bool isAbandoned() const;
93  virtual bool isProvenOptimal() const;
95  virtual bool isProvenPrimalInfeasible() const;
97  virtual bool isProvenDualInfeasible() const;
98  // Is the given primal objective limit reached? - use implementation from OsiSolverInterface
100  virtual bool isDualObjectiveLimitReached() const;
102  virtual bool isIterationLimitReached() const;
104  virtual bool isTimeLimitReached() const;
106 
107  //---------------------------------------------------------------------------
110  inline CoinWarmStart *getEmptyWarmStart () const
112  { return (dynamic_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
114  virtual CoinWarmStart* getWarmStart() const;
117  virtual bool setWarmStart(const CoinWarmStart* warmstart);
119 
120  //---------------------------------------------------------------------------
127  virtual void markHotStart();
130  virtual void solveFromHotStart();
132  virtual void unmarkHotStart();
134 
135  //---------------------------------------------------------------------------
150  virtual int getNumCols() const;
152 
154  virtual int getNumRows() const;
155 
157  virtual int getNumElements() const;
158 
160  virtual const double * getColLower() const;
161 
163  virtual const double * getColUpper() const;
164 
174  virtual const char * getRowSense() const;
175 
184  virtual const double * getRightHandSide() const;
185 
194  virtual const double * getRowRange() const;
195 
197  virtual const double * getRowLower() const;
198 
200  virtual const double * getRowUpper() const;
201 
203  virtual const double * getObjCoefficients() const;
204 
206  virtual double getObjSense() const;
207 
209  virtual bool isContinuous(int colNumber) const;
210 
211 #if 0
212  virtual bool isBinary(int columnNumber) const;
214 
219  virtual bool isInteger(int columnNumber) const;
220 
222  virtual bool isIntegerNonBinary(int columnNumber) const;
223 
225  virtual bool isFreeBinary(int columnNumber) const;
226 #endif
227 
229  virtual const CoinPackedMatrix * getMatrixByRow() const;
230 
232  virtual const CoinPackedMatrix * getMatrixByCol() const;
233 
235  virtual double getInfinity() const;
237 
240  virtual const double * getColSolution() const;
242 
244  virtual const double * getRowPrice() const;
245 
247  virtual const double * getReducedCost() const;
248 
251  virtual const double * getRowActivity() const;
252 
254  virtual double getObjValue() const;
255 
258  virtual int getIterationCount() const;
259 
277  virtual std::vector<double*> getDualRays(int maxNumRays,
278  bool fullRay=false) const;
290  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
291 
292 #if 0
293 
295  virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05)
296  const;
297 #endif
298 
299 
300 
301  //---------------------------------------------------------------------------
302 
305  //-------------------------------------------------------------------------
309  virtual void setObjCoeff( int elementIndex, double elementValue );
310 
313  virtual void setColLower( int elementIndex, double elementValue );
314 
317  virtual void setColUpper( int elementIndex, double elementValue );
318 
322  virtual void setColBounds( int elementIndex,
323  double lower, double upper );
324 
325 #if 0 // we are using the default implementation of OsiSolverInterface
326 
334  virtual void setColSetBounds(const int* indexFirst,
335  const int* indexLast,
336  const double* boundList);
337 #endif
338 
341  virtual void setRowLower( int elementIndex, double elementValue );
342 
345  virtual void setRowUpper( int elementIndex, double elementValue );
346 
350  virtual void setRowBounds( int elementIndex,
351  double lower, double upper );
352 
354  virtual void setRowType(int index, char sense, double rightHandSide,
355  double range);
356 
357 #if 0 // we are using the default implementation of OsiSolverInterface
358 
365  virtual void setRowSetBounds(const int* indexFirst,
366  const int* indexLast,
367  const double* boundList);
368 
378  virtual void setRowSetTypes(const int* indexFirst,
379  const int* indexLast,
380  const char* senseList,
381  const double* rhsList,
382  const double* rangeList);
383 #endif
384 
385 
386  //-------------------------------------------------------------------------
390  virtual void setContinuous(int index);
392  virtual void setInteger(int index);
393 #if 0 // we are using the default implementation of OsiSolverInterface
394 
396  virtual void setContinuous(const int* indices, int len);
399  virtual void setInteger(const int* indices, int len);
400 #endif
401 
402 
403  //-------------------------------------------------------------------------
405  virtual void setObjSense(double s);
406 
417  virtual void setColSolution(const double * colsol);
418 
429  virtual void setRowPrice(const double * rowprice);
430 
431  //-------------------------------------------------------------------------
437  virtual void addCol(const CoinPackedVectorBase& vec,
438  const double collb, const double colub,
439  const double obj);
440 
441 #if 0 // we are using the default implementation of OsiSolverInterface
442 
443  virtual void addCols(const int numcols,
444  const CoinPackedVectorBase * const * cols,
445  const double* collb, const double* colub,
446  const double* obj);
447 #endif
448 
450  virtual void deleteCols(const int num, const int * colIndices);
451 
453  virtual void addRow(const CoinPackedVectorBase& vec,
454  const double rowlb, const double rowub);
456  virtual void addRow(const CoinPackedVectorBase& vec,
457  const char rowsen, const double rowrhs,
458  const double rowrng);
459 
460 #if 0 // we are using the default implementation of OsiSolverInterface
461 
462  virtual void addRows(const int numrows,
463  const CoinPackedVectorBase * const * rows,
464  const double* rowlb, const double* rowub);
466  virtual void addRows(const int numrows,
467  const CoinPackedVectorBase * const * rows,
468  const char* rowsen, const double* rowrhs,
469  const double* rowrng);
470 #endif
471 
473  virtual void deleteRows(const int num, const int * rowIndices);
474 
475 #if 0 // we are using the default implementation of OsiSolverInterface
476  //-----------------------------------------------------------------------
498  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
499  double effectivenessLb = 0.0);
500 #endif
501 
502 
503 
504  //---------------------------------------------------------------------------
505 
519  virtual void loadProblem(const CoinPackedMatrix& matrix,
520  const double* collb, const double* colub,
521  const double* obj,
522  const double* rowlb, const double* rowub);
523 
531  virtual void assignProblem(CoinPackedMatrix*& matrix,
532  double*& collb, double*& colub, double*& obj,
533  double*& rowlb, double*& rowub);
534 
547  virtual void loadProblem(const CoinPackedMatrix& matrix,
548  const double* collb, const double* colub,
549  const double* obj,
550  const char* rowsen, const double* rowrhs,
551  const double* rowrng);
552 
560  virtual void assignProblem(CoinPackedMatrix*& matrix,
561  double*& collb, double*& colub, double*& obj,
562  char*& rowsen, double*& rowrhs,
563  double*& rowrng);
564 
567  virtual void loadProblem(const int numcols, const int numrows,
568  const int* start, const int* index,
569  const double* value,
570  const double* collb, const double* colub,
571  const double* obj,
572  const double* rowlb, const double* rowub);
573 
576  virtual void loadProblem(const int numcols, const int numrows,
577  const int* start, const int* index,
578  const double* value,
579  const double* collb, const double* colub,
580  const double* obj,
581  const char* rowsen, const double* rowrhs,
582  const double* rowrng);
583 
585  virtual int readMps(const char *filename,
586  const char *extension = "mps");
587 
592  virtual void writeMps(const char *filename,
593  const char *extension = "mps",
594  double objSense=0.0) const;
596 
597  //---------------------------------------------------------------------------
598 
603 
605  virtual OsiSolverInterface * clone(bool copyData = true) const;
606 
609 
612 
614  virtual ~OsiSpxSolverInterface();
616 
617 
619  {
642  };
643  soplex::SoPlex* getLpPtr( int keepCached = KEEPCACHED_NONE );
644 
645  soplex::SPxOut* getSPxOut() { return spxout_; }
646 
647 protected:
648 
651  virtual void applyRowCut( const OsiRowCut & rc );
653 
657  virtual void applyColCut( const OsiColCut & cc );
659 
662  soplex::SPxOut *spxout_;
665  soplex::SoPlex *soplex_;
667 
668 
669 private:
672 
674  void freeCachedColRim();
675 
677  void freeCachedRowRim();
678 
680  void freeCachedResults();
681 
683  void freeCachedMatrix();
684 
686  void freeCachedData( int keepCached = KEEPCACHED_NONE );
687 
689  void freeAllMemory();
691 
692 
695  soplex::DIdxSet *spxintvars_;
697 
704 
707  mutable soplex::DVector *obj_;
709 
711  mutable char *rowsense_;
712 
714  mutable double *rhs_;
715 
717  mutable double *rowrange_;
718 
720  mutable soplex::DVector *colsol_;
721 
723  mutable soplex::DVector *rowsol_;
724 
726  mutable soplex::DVector *redcost_;
727 
729  mutable soplex::DVector *rowact_;
730 
733 
737 
738 };
739 
740 //#############################################################################
742 void OsiSpxSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
743 
744 #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...
soplex::SoPlex * getLpPtr(int keepCached=KEEPCACHED_NONE)
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&#39;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
The default COIN simplex (basis-oriented) warm start class.
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 &quot;iteration&quot; mean to the solver...
OsiSpxSolverInterface()
Default Constructor.
Abstract base class for various sparse vectors.
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.
soplex::SPxOut * spxout_
SoPlex output object.
virtual void branchAndBound()
Invoke solver&#39;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.
Sparse Matrix Base Class.
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.
Abstract base class for warm start information.
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...