Osi  0.107.8
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 
611  OsiSpxSolverInterface& operator=( const OsiSpxSolverInterface& rhs );
612 
614  virtual ~OsiSpxSolverInterface();
616 
617 
619  {
621  KEEPCACHED_NONE = 0,
623  KEEPCACHED_COLUMN = 1,
625  KEEPCACHED_ROW = 2,
627  KEEPCACHED_MATRIX = 4,
629  KEEPCACHED_RESULTS = 8,
631  KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX,
633  KEEPCACHED_ALL = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS,
635  FREECACHED_COLUMN = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN,
637  FREECACHED_ROW = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW,
639  FREECACHED_MATRIX = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX,
641  FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS
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 
732  mutable CoinPackedMatrix *matrixByRow_;
733 
735  mutable CoinPackedMatrix *matrixByCol_;
737 
738 };
739 
740 //#############################################################################
742 void OsiSpxSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
743 
744 #endif
SoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex.
char * rowsense_
Pointer to dense vector of row sense indicators.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
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
CoinPackedMatrix * matrixByCol_
Pointer to row-wise copy of problem matrix coefficients.
Abstract Base Class for describing an interface to a solver.
void * hotStartCStat_
Hotstart information.
std::vector< int > OsiVectorInt
Vector of int.
soplex::DVector * colsol_
Pointer to primal solution vector.
Row Cut Class.
Definition: OsiRowCut.hpp:29
double * rhs_
Pointer to dense vector of row right-hand side values.
soplex::DVector * rowact_
Pointer to row activity (slack) vector.
soplex::DVector * redcost_
Pointer to reduced cost vector.
soplex::SoPlex * soplex_
SoPlex solver object.
void OsiSpxSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiSpxSolverInterface class.
Internal class for obtaining status from the applyCuts method.