OsiClpSolverInterface.hpp
Go to the documentation of this file.
1 // Copyright (C) 2000, International Business Machines
2 // Corporation and others. All Rights Reserved.
3 
4 #ifndef OsiClpSolverInterface_H
5 #define OsiClpSolverInterface_H
6 
7 #include <string>
8 #include <cfloat>
9 #include <map>
10 
11 #include "ClpSimplex.hpp"
12 #include "ClpLinearObjective.hpp"
13 #include "CoinPackedMatrix.hpp"
14 #include "OsiSolverInterface.hpp"
15 #include "CoinWarmStartBasis.hpp"
16 #include "ClpEventHandler.hpp"
17 #include "ClpNode.hpp"
18 #include "CoinIndexedVector.hpp"
19 
20 class OsiRowCut;
21 class OsiClpUserSolver;
23 class CoinSet;
24 #ifndef COIN_DBL_MAX
25 static const double OsiClpInfinity = DBL_MAX;
26 #else
27 static const double OsiClpInfinity = COIN_DBL_MAX;
28 #endif
29 
30 //#############################################################################
31 
39  virtual public OsiSolverInterface {
40  friend int OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
41 
42 public:
43  //---------------------------------------------------------------------------
46 
47  virtual void initialSolve();
48 
50  virtual void resolve();
51 
53  virtual void branchAndBound();
54 
62  void crossover(int options,int basis);
64 
66 
67 
73  virtual void enableSimplexInterface(bool doingPrimal);
74 
76  virtual void disableSimplexInterface();
80  virtual int canDoSimplexInterface() const;
87  virtual void enableFactorization() const;
89  virtual void disableFactorization() const;
90 
106  void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0);
108  virtual void synchronizeModel();
109  // Sleazy methods to fool const requirements (no less safe as modelPtr_ mutable)
110  void setSpecialOptionsMutable(unsigned int value) const;
111 
116  virtual bool basisIsAvailable() const;
117 
133  virtual void getBasisStatus(int* cstat, int* rstat) const;
134 
145  virtual int setBasisStatus(const int* cstat, const int* rstat);
146 
154  virtual int pivot(int colIn, int colOut, int outStatus);
155 
167  virtual int primalPivotResult(int colIn, int sign,
168  int& colOut, int& outStatus,
169  double& t, CoinPackedVector* dx);
170 
177  virtual int dualPivotResult(int& colIn, int& sign,
178  int colOut, int outStatus,
179  double& t, CoinPackedVector* dx);
180 
182  virtual void getReducedGradient(double* columnReducedCosts,
183  double * duals,
184  const double * c);
185 
188  virtual void setObjectiveAndRefresh(double* c);
189 
191  virtual void getBInvARow(int row, double* z, double * slack=NULL) const;
192 
197  virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL,
198  bool keepScaled=false) const;
199 
201  virtual void getBInvRow(int row, double* z) const;
202 
204  virtual void getBInvACol(int col, double* vec) const ;
205 
207  virtual void getBInvACol(int col, CoinIndexedVector * vec) const ;
208 
213  virtual void getBInvACol(CoinIndexedVector * vec) const ;
214 
216  virtual void getBInvCol(int col, double* vec) const ;
217 
222  virtual void getBasics(int* index) const;
223 
225  //---------------------------------------------------------------------------
241  // Set an integer parameter
242  bool setIntParam(OsiIntParam key, int value);
243  // Set an double parameter
244  bool setDblParam(OsiDblParam key, double value);
245  // Set a string parameter
246  bool setStrParam(OsiStrParam key, const std::string & value);
247  // Get an integer parameter
248  bool getIntParam(OsiIntParam key, int& value) const;
249  // Get an double parameter
250  bool getDblParam(OsiDblParam key, double& value) const;
251  // Get a string parameter
252  bool getStrParam(OsiStrParam key, std::string& value) const;
253  // Set a hint parameter - overrides OsiSolverInterface
254  virtual bool setHintParam(OsiHintParam key, bool yesNo=true,
255  OsiHintStrength strength=OsiHintTry,
256  void * otherInformation=NULL);
258 
259  //---------------------------------------------------------------------------
261 
262 
263  virtual bool isAbandoned() const;
265  virtual bool isProvenOptimal() const;
267  virtual bool isProvenPrimalInfeasible() const;
269  virtual bool isProvenDualInfeasible() const;
271  virtual bool isPrimalObjectiveLimitReached() const;
273  virtual bool isDualObjectiveLimitReached() const;
275  virtual bool isIterationLimitReached() const;
277 
278  //---------------------------------------------------------------------------
281 
289  virtual CoinWarmStart *getEmptyWarmStart () const;
290 
292  virtual CoinWarmStart* getWarmStart() const;
294  inline CoinWarmStartBasis* getPointerToWarmStart()
295  { return &basis_;}
297  inline const CoinWarmStartBasis* getConstPointerToWarmStart() const
298  { return &basis_;}
301  virtual bool setWarmStart(const CoinWarmStart* warmstart);
311  virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ;
312 
314 
315  //---------------------------------------------------------------------------
322 
323  virtual void markHotStart();
325  virtual void solveFromHotStart();
327  virtual void unmarkHotStart();
336  int startFastDual(int options);
338  void stopFastDual();
340  void setStuff(double tolerance,double increment);
342 
343  //---------------------------------------------------------------------------
358 
359  virtual int getNumCols() const {
360  return modelPtr_->numberColumns(); }
361 
363  virtual int getNumRows() const {
364  return modelPtr_->numberRows(); }
365 
367  virtual int getNumElements() const {
368  int retVal = 0;
369  const CoinPackedMatrix * matrix =modelPtr_->matrix();
370  if ( matrix != NULL ) retVal=matrix->getNumElements();
371  return retVal; }
372 
375  virtual std::string getRowName(int rowIndex,
376  unsigned maxLen = std::string::npos) const;
377 
380  virtual std::string getColName(int colIndex,
381  unsigned maxLen = std::string::npos) const;
382 
383 
385  virtual const double * getColLower() const { return modelPtr_->columnLower(); }
386 
388  virtual const double * getColUpper() const { return modelPtr_->columnUpper(); }
389 
399  virtual const char * getRowSense() const;
400 
409  virtual const double * getRightHandSide() const ;
410 
419  virtual const double * getRowRange() const ;
420 
422  virtual const double * getRowLower() const { return modelPtr_->rowLower(); }
423 
425  virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); }
426 
428  virtual const double * getObjCoefficients() const
429  { return modelPtr_->objective(); }
430 
432  virtual double getObjSense() const
433  { return modelPtr_->optimizationDirection(); }
434 
436  virtual bool isContinuous(int colNumber) const;
438  virtual bool isBinary(int colIndex) const;
439 
444  virtual bool isInteger(int colIndex) const;
445 
447  virtual bool isIntegerNonBinary(int colIndex) const;
448 
450  virtual bool isFreeBinary(int colIndex) const;
456  virtual const char * getColType(bool refresh=false) const;
457 
463  bool isOptionalInteger(int colIndex) const;
465  void setOptionalInteger(int index);
466 
468  virtual const CoinPackedMatrix * getMatrixByRow() const;
469 
471  virtual const CoinPackedMatrix * getMatrixByCol() const;
472 
474  virtual CoinPackedMatrix * getMutableMatrixByCol() const;
475 
477  virtual double getInfinity() const { return OsiClpInfinity; }
479 
482 
483  virtual const double * getColSolution() const;
484 
486  virtual const double * getRowPrice() const;
487 
489  virtual const double * getReducedCost() const;
490 
493  virtual const double * getRowActivity() const;
494 
496  virtual double getObjValue() const;
497 
500  virtual int getIterationCount() const
501  { return modelPtr_->numberIterations(); }
502 
514  virtual std::vector<double*> getDualRays(int maxNumRays) const;
526  virtual std::vector<double*> getPrimalRays(int maxNumRays) const;
527 
529 
530 
531  //---------------------------------------------------------------------------
532 
535  //-------------------------------------------------------------------------
539  virtual void setObjCoeff( int elementIndex, double elementValue );
540 
543  virtual void setColLower( int elementIndex, double elementValue );
544 
547  virtual void setColUpper( int elementIndex, double elementValue );
548 
550  virtual void setColBounds( int elementIndex,
551  double lower, double upper );
552 
561  virtual void setColSetBounds(const int* indexFirst,
562  const int* indexLast,
563  const double* boundList);
564 
567  virtual void setRowLower( int elementIndex, double elementValue );
568 
571  virtual void setRowUpper( int elementIndex, double elementValue ) ;
572 
574  virtual void setRowBounds( int elementIndex,
575  double lower, double upper ) ;
576 
578  virtual void setRowType(int index, char sense, double rightHandSide,
579  double range);
580 
589  virtual void setRowSetBounds(const int* indexFirst,
590  const int* indexLast,
591  const double* boundList);
592 
603  virtual void setRowSetTypes(const int* indexFirst,
604  const int* indexLast,
605  const char* senseList,
606  const double* rhsList,
607  const double* rangeList);
612  virtual void setObjective(const double * array);
613 
618  virtual void setColLower(const double * array);
619 
624  virtual void setColUpper(const double * array);
625 
626 // using OsiSolverInterface::setRowName ;
628 // virtual void setRowName(int rowIndex, std::string & name) ;
629  virtual void setRowName(int rowIndex, std::string name) ;
630 
631 // using OsiSolverInterface::setColName ;
633 // virtual void setColName(int colIndex, std::string & name) ;
634  virtual void setColName(int colIndex, std::string name) ;
635 
637 
638  //-------------------------------------------------------------------------
642  virtual void setContinuous(int index);
644  virtual void setInteger(int index);
647  virtual void setContinuous(const int* indices, int len);
650  virtual void setInteger(const int* indices, int len);
652  inline int numberSOS() const
653  { return numberSOS_;}
655  inline const CoinSet * setInfo() const
656  { return setInfo_;}
666  virtual int findIntegersAndSOS(bool justCount);
668 
669  //-------------------------------------------------------------------------
671  virtual void setObjSense(double s )
672  { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); }
673 
684  virtual void setColSolution(const double * colsol);
685 
696  virtual void setRowPrice(const double * rowprice);
697 
698  //-------------------------------------------------------------------------
703 
704  //using OsiSolverInterface::addCol ;
706  virtual void addCol(const CoinPackedVectorBase& vec,
707  const double collb, const double colub,
708  const double obj);
711  virtual void addCol(const CoinPackedVectorBase& vec,
712  const double collb, const double colub,
713  const double obj, std::string name) ;
715  virtual void addCol(int numberElements, const int * rows, const double * elements,
716  const double collb, const double colub,
717  const double obj) ;
720  virtual void addCol(int numberElements,
721  const int* rows, const double* elements,
722  const double collb, const double colub,
723  const double obj, std::string name) ;
725  virtual void addCols(const int numcols,
726  const CoinPackedVectorBase * const * cols,
727  const double* collb, const double* colub,
728  const double* obj);
730  virtual void addCols(const int numcols,
731  const int * columnStarts, const int * rows, const double * elements,
732  const double* collb, const double* colub,
733  const double* obj);
735  virtual void deleteCols(const int num, const int * colIndices);
736 
738  virtual void addRow(const CoinPackedVectorBase& vec,
739  const double rowlb, const double rowub);
746  virtual void addRow(const CoinPackedVectorBase& vec,
747  const double rowlb, const double rowub,
748  std::string name) ;
749  virtual void addRow(const CoinPackedVectorBase& vec,
750  const char rowsen, const double rowrhs,
751  const double rowrng);
753  virtual void addRow(int numberElements, const int * columns, const double * element,
754  const double rowlb, const double rowub) ;
757  virtual void addRow(const CoinPackedVectorBase& vec,
758  const char rowsen, const double rowrhs,
759  const double rowrng, std::string name) ;
761  virtual void addRows(const int numrows,
762  const CoinPackedVectorBase * const * rows,
763  const double* rowlb, const double* rowub);
765  virtual void addRows(const int numrows,
766  const CoinPackedVectorBase * const * rows,
767  const char* rowsen, const double* rowrhs,
768  const double* rowrng);
769 
771  virtual void addRows(const int numrows,
772  const int * rowStarts, const int * columns, const double * element,
773  const double* rowlb, const double* rowub);
775  void modifyCoefficient(int row, int column, double newElement,
776  bool keepZero=false)
777  {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);}
778 
780  virtual void deleteRows(const int num, const int * rowIndices);
783  virtual void saveBaseModel() ;
787  virtual void restoreBaseModel(int numberRows);
788 
789  //-----------------------------------------------------------------------
793  virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts);
798  virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts);
821  virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs,
822  double effectivenessLb = 0.0);
823 
825 
826 
827  //---------------------------------------------------------------------------
828 
829 public:
830 
844  virtual void loadProblem(const CoinPackedMatrix& matrix,
845  const double* collb, const double* colub,
846  const double* obj,
847  const double* rowlb, const double* rowub);
848 
856  virtual void assignProblem(CoinPackedMatrix*& matrix,
857  double*& collb, double*& colub, double*& obj,
858  double*& rowlb, double*& rowub);
859 
872  virtual void loadProblem(const CoinPackedMatrix& matrix,
873  const double* collb, const double* colub,
874  const double* obj,
875  const char* rowsen, const double* rowrhs,
876  const double* rowrng);
877 
885  virtual void assignProblem(CoinPackedMatrix*& matrix,
886  double*& collb, double*& colub, double*& obj,
887  char*& rowsen, double*& rowrhs,
888  double*& rowrng);
889 
892  virtual void loadProblem(const int numcols, const int numrows,
893  const CoinBigIndex * start, const int* index,
894  const double* value,
895  const double* collb, const double* colub,
896  const double* obj,
897  const double* rowlb, const double* rowub);
898 
901  virtual void loadProblem(const int numcols, const int numrows,
902  const CoinBigIndex * start, const int* index,
903  const double* value,
904  const double* collb, const double* colub,
905  const double* obj,
906  const char* rowsen, const double* rowrhs,
907  const double* rowrng);
909  virtual int loadFromCoinModel ( CoinModel & modelObject, bool keepSolution=false);
910 
914  virtual int readMps(const char *filename,
915  const char *extension = "mps") ;
918  int readMps(const char *filename,bool keepNames,bool allowErrors);
920  virtual int readMps (const char *filename, const char*extension,
921  int & numberSets, CoinSet ** & sets);
922 
927  virtual void writeMps(const char *filename,
928  const char *extension = "mps",
929  double objSense=0.0) const;
938  virtual int writeMpsNative(const char *filename,
939  const char ** rowNames, const char ** columnNames,
940  int formatType=0,int numberAcross=2,
941  double objSense=0.0) const ;
943  virtual int readLp(const char *filename, const double epsilon = 1e-5);
949  virtual void writeLp(const char *filename,
950  const char *extension = "lp",
951  double epsilon = 1e-5,
952  int numberAcross = 10,
953  int decimals = 5,
954  double objSense = 0.0,
955  bool useRowNames = true) const;
960  virtual void writeLp(FILE *fp,
961  double epsilon = 1e-5,
962  int numberAcross = 10,
963  int decimals = 5,
964  double objSense = 0.0,
965  bool useRowNames = true) const;
971  virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix);
973  virtual void replaceMatrix(const CoinPackedMatrix & matrix) ;
975 
986  virtual void passInMessageHandler(CoinMessageHandler * handler);
988  void newLanguage(CoinMessages::Language language);
989  void setLanguage(CoinMessages::Language language)
990  {newLanguage(language);}
992  void setLogLevel(int value);
994  void generateCpp( FILE * fp);
996  //---------------------------------------------------------------------------
997 
1000 
1001  ClpSimplex * getModelPtr() const ;
1003  inline ClpSimplex * swapModelPtr(ClpSimplex * newModel)
1004  { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;}
1006  inline unsigned int specialOptions() const
1007  { return specialOptions_;}
1008  void setSpecialOptions(unsigned int value);
1010  inline int lastAlgorithm() const
1011  { return lastAlgorithm_;}
1013  inline int cleanupScaling() const
1014  { return cleanupScaling_;}
1027  inline void setCleanupScaling(int value)
1028  { cleanupScaling_=value;}
1031  inline double smallestElementInCut() const
1032  { return smallestElementInCut_;}
1035  inline void setSmallestElementInCut(double value)
1036  { smallestElementInCut_=value;}
1043  inline double smallestChangeInCut() const
1044  { return smallestChangeInCut_;}
1051  inline void setSmallestChangeInCut(double value)
1052  { smallestChangeInCut_=value;}
1054  inline void setSolveOptions(const ClpSolve & options)
1055  { solveOptions_ = options;}
1059  virtual int tightenBounds(int lightweight=0);
1061  virtual CoinBigIndex getSizeL() const;
1063  virtual CoinBigIndex getSizeU() const;
1066  { return disasterHandler_;}
1070  ClpLinearObjective * fakeObjective() const
1071  { return fakeObjective_;}
1073  void setFakeObjective(ClpLinearObjective * fakeObjective);
1075  void setFakeObjective(double * fakeObjective);
1077 
1078  //---------------------------------------------------------------------------
1079 
1082 
1084 
1086  virtual OsiSolverInterface * clone(bool copyData = true) const;
1087 
1090 
1092  OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false);
1093 
1095  void releaseClp();
1096 
1099 
1101  virtual ~OsiClpSolverInterface ();
1102 
1104  virtual void reset();
1106 
1107  //---------------------------------------------------------------------------
1108 
1109 protected:
1111 
1112 
1113  virtual void applyRowCut(const OsiRowCut& rc);
1114 
1116  virtual void applyColCut(const OsiColCut& cc);
1118 
1119  //---------------------------------------------------------------------------
1120 
1121 protected:
1124 
1125  void gutsOfDestructor();
1126 
1128  void freeCachedResults() const;
1129 
1131  void freeCachedResults0() const;
1132 
1134  void freeCachedResults1() const;
1135 
1137  void extractSenseRhsRange() const;
1138 
1140  void fillParamMaps();
1149  CoinWarmStartBasis getBasis(ClpSimplex * model) const;
1158  void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model);
1160  void crunch();
1162  void redoScaleFactors(int numberRows,const CoinBigIndex * starts,
1163  const int * indices, const double * elements);
1164 public:
1167  void setBasis( const CoinWarmStartBasis & basis);
1169  inline void setBasis( )
1172  CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ;
1174  CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ;
1176  void deleteScaleFactors();
1178  inline const double * upRange() const
1179  { return rowActivity_;}
1180  inline const double * downRange() const
1181  { return columnActivity_;}
1183  inline void passInRanges(int * array)
1184  { whichRange_=array;}
1186  void setSOSData(int numberSOS,const char * type,
1187  const int * start,const int * indices, const double * weights=NULL);
1189  void computeLargestAway();
1191  inline double largestAway() const
1192  { return largestAway_;}
1194  inline void setLargestAway(double value)
1195  { largestAway_ = value;}
1197  void lexSolve();
1198 protected:
1200 
1203 
1204  mutable ClpSimplex * modelPtr_;
1209 
1210  mutable char *rowsense_;
1211 
1213  mutable double *rhs_;
1214 
1218  mutable double *rowrange_;
1219 
1222  mutable CoinWarmStartBasis* ws_;
1225  mutable double * rowActivity_;
1226  mutable double * columnActivity_;
1228  ClpNodeStuff stuff_;
1232  CoinSet * setInfo_;
1234  ClpSimplex * smallModel_;
1236  ClpFactorization * factorization_;
1249  CoinWarmStartBasis basis_;
1252 
1254  mutable int lastAlgorithm_;
1255 
1258 
1260  mutable CoinPackedMatrix *matrixByRow_;
1261 
1263  CoinPackedMatrix *matrixByRowAtContinuous_;
1264 
1267 
1273 
1274  //std::map<OsiIntParam, ClpIntParam> intParamMap_;
1275  //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
1276  //std::map<OsiStrParam, ClpStrParam> strParamMap_;
1277 
1279  mutable ClpDataSave saveData_;
1281  ClpSolve solveOptions_;
1319  mutable unsigned int specialOptions_;
1321  ClpSimplex * baseModel_;
1325  ClpSimplex * continuousModel_;
1329  ClpLinearObjective * fakeObjective_;
1331  CoinDoubleArrayWithLength rowScale_;
1333  CoinDoubleArrayWithLength columnScale_;
1335 };
1336 
1337 class OsiClpDisasterHandler : public ClpDisasterHandler {
1338 public:
1342 
1343  virtual void intoSimplex();
1345  virtual bool check() const ;
1347  virtual void saveInfo();
1349  virtual int typeOfDisaster();
1351 
1352 
1359  virtual ~OsiClpDisasterHandler();
1360  // Copy
1362  // Assignment
1365  virtual ClpDisasterHandler * clone() const;
1366 
1368 
1373  void setOsiModel(OsiClpSolverInterface * model);
1376  { return osiModel_;}
1378  inline void setWhereFrom(int value)
1379  { whereFrom_=value;}
1381  inline int whereFrom() const
1382  { return whereFrom_;}
1384  inline void setPhase(int value)
1385  { phase_=value;}
1387  inline int phase() const
1388  { return phase_;}
1390  inline bool inTrouble() const
1391  { return inTrouble_;}
1392 
1394 
1395 
1396 protected:
1400 
1417  int phase_;
1420 
1422 };
1423 // So unit test can find out if NDEBUG set
1424 bool OsiClpHasNDEBUG();
1425 //#############################################################################
1433 int
1434 OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir);
1435 #endif