Clp  1.17.3
OsiClpSolverInterface.hpp
Go to the documentation of this file.
1 // $Id$
2 // Copyright (C) 2000, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef OsiClpSolverInterface_H
7 #define OsiClpSolverInterface_H
8 
9 #include <string>
10 #include <cfloat>
11 #include <map>
12 
13 #include "ClpSimplex.hpp"
14 #include "ClpLinearObjective.hpp"
15 #include "CoinPackedMatrix.hpp"
16 #include "OsiSolverInterface.hpp"
17 #include "CoinWarmStartBasis.hpp"
18 #include "ClpEventHandler.hpp"
19 #include "ClpNode.hpp"
20 #include "CoinIndexedVector.hpp"
21 #include "CoinFinite.hpp"
22 
23 class OsiRowCut;
24 class OsiClpUserSolver;
26 class CoinSet;
27 static const double OsiClpInfinity = COIN_DBL_MAX;
28 
29 //#############################################################################
30 
37 class OsiClpSolverInterface : virtual public OsiSolverInterface {
38  friend void OsiClpSolverInterfaceUnitTest(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 resolveGub(int needed);
52 
54  virtual void branchAndBound();
55 
63  void crossover(int options, int basis);
65 
81  virtual int canDoSimplexInterface() const;
82 
91  virtual void enableFactorization() const;
92 
94  virtual void disableFactorization() const;
95 
100  virtual bool basisIsAvailable() const;
101 
117  virtual void getBasisStatus(int *cstat, int *rstat) const;
118 
129  virtual int setBasisStatus(const int *cstat, const int *rstat);
130 
132  virtual void getReducedGradient(double *columnReducedCosts,
133  double *duals,
134  const double *c) const;
135 
137  virtual void getBInvARow(int row, double *z, double *slack = NULL) const;
138 
143  virtual void getBInvARow(int row, CoinIndexedVector *z, CoinIndexedVector *slack = NULL,
144  bool keepScaled = false) const;
145 
147  virtual void getBInvRow(int row, double *z) const;
148 
150  virtual void getBInvACol(int col, double *vec) const;
151 
153  virtual void getBInvACol(int col, CoinIndexedVector *vec) const;
154 
159  virtual void getBInvACol(CoinIndexedVector *vec) const;
160 
162  virtual void getBInvCol(int col, double *vec) const;
163 
168  virtual void getBasics(int *index) const;
169 
176  virtual void enableSimplexInterface(bool doingPrimal);
179 
181  virtual void disableSimplexInterface();
183  void copyEnabledStuff(ClpSimplex &rhs);
184 
192  virtual int pivot(int colIn, int colOut, int outStatus);
193 
205  virtual int primalPivotResult(int colIn, int sign,
206  int &colOut, int &outStatus,
207  double &t, CoinPackedVector *dx);
208 
215  virtual int dualPivotResult(int &colIn, int &sign,
216  int colOut, int outStatus,
217  double &t, CoinPackedVector *dx);
218 
220  //---------------------------------------------------------------------------
236  // Set an integer parameter
237  bool setIntParam(OsiIntParam key, int value);
238  // Set an double parameter
239  bool setDblParam(OsiDblParam key, double value);
240  // Set a string parameter
241  bool setStrParam(OsiStrParam key, const std::string &value);
242  // Get an integer parameter
243  bool getIntParam(OsiIntParam key, int &value) const;
244  // Get an double parameter
245  bool getDblParam(OsiDblParam key, double &value) const;
246  // Get a string parameter
247  bool getStrParam(OsiStrParam key, std::string &value) const;
248  // Set a hint parameter - overrides OsiSolverInterface
249  virtual bool setHintParam(OsiHintParam key, bool yesNo = true,
250  OsiHintStrength strength = OsiHintTry,
251  void *otherInformation = NULL);
253 
254  //---------------------------------------------------------------------------
256 
257  virtual bool isAbandoned() const;
260  virtual bool isProvenOptimal() const;
262  virtual bool isProvenPrimalInfeasible() const;
264  virtual bool isProvenDualInfeasible() const;
266  virtual bool isPrimalObjectiveLimitReached() const;
268  virtual bool isDualObjectiveLimitReached() const;
270  virtual bool isIterationLimitReached() const;
272 
273  //---------------------------------------------------------------------------
276 
284  virtual CoinWarmStart *getEmptyWarmStart() const;
285 
287  virtual CoinWarmStart *getWarmStart() const;
290  {
291  return &basis_;
292  }
295  {
296  return &basis_;
297  }
300  virtual bool setWarmStart(const CoinWarmStart *warmstart);
310  virtual CoinWarmStart *getPointerToWarmStart(bool &mustDelete);
311 
313  void setColumnStatus(int iColumn, ClpSimplex::Status status);
314 
316 
317  //---------------------------------------------------------------------------
324  virtual void markHotStart();
327  virtual void solveFromHotStart();
329  virtual void unmarkHotStart();
338  int startFastDual(int options);
340  void stopFastDual();
342  void setStuff(double tolerance, double increment);
344  OsiRowCut *smallModelCut(const double *originalLower, const double *originalUpper,
345  int numberRowsAtContinuous, const int *whichGenerator,
346  int typeCut = 0);
350  OsiRowCut *modelCut(const double *originalLower, const double *originalUpper,
351  int numberRowsAtContinuous, const int *whichGenerator,
352  int typeCut = 0);
354 
355  //---------------------------------------------------------------------------
370  virtual int getNumCols() const
372  {
373  return modelPtr_->numberColumns();
374  }
375 
377  virtual int getNumRows() const
378  {
379  return modelPtr_->numberRows();
380  }
381 
383  virtual CoinBigIndex getNumElements() const
384  {
385  CoinBigIndex retVal = 0;
386  const CoinPackedMatrix *matrix = modelPtr_->matrix();
387  if (matrix != NULL)
388  retVal = matrix->getNumElements();
389  return retVal;
390  }
391 
394  virtual std::string getRowName(int rowIndex,
395  unsigned maxLen = static_cast< unsigned >(std::string::npos)) const;
396 
399  virtual std::string getColName(int colIndex,
400  unsigned maxLen = static_cast< unsigned >(std::string::npos)) const;
401 
403  virtual const double *getColLower() const { return modelPtr_->columnLower(); }
404 
406  virtual const double *getColUpper() const { return modelPtr_->columnUpper(); }
407 
417  virtual const char *getRowSense() const;
418 
427  virtual const double *getRightHandSide() const;
428 
437  virtual const double *getRowRange() const;
438 
440  virtual const double *getRowLower() const { return modelPtr_->rowLower(); }
441 
443  virtual const double *getRowUpper() const { return modelPtr_->rowUpper(); }
444 
446  virtual const double *getObjCoefficients() const
447  {
448  if (fakeMinInSimplex_)
449  return linearObjective_;
450  else
451  return modelPtr_->objective();
452  }
453 
455  virtual double getObjSense() const
456  {
458  }
459 
461  virtual bool isContinuous(int colNumber) const;
463  virtual bool isBinary(int colIndex) const;
464 
469  virtual bool isInteger(int colIndex) const;
470 
472  virtual bool isIntegerNonBinary(int colIndex) const;
473 
475  virtual bool isFreeBinary(int colIndex) const;
481  virtual const char *getColType(bool refresh = false) const;
482 
488  bool isOptionalInteger(int colIndex) const;
490  void setOptionalInteger(int index);
492  inline bool isHeuristicInteger(int colIndex) const
493  {
494  return (integerInformation_ && integerInformation_[colIndex] == 1);
495  }
497  inline int integerType(int colIndex) const
498  {
499  return integerInformation_ ? integerInformation_[colIndex] : 0;
500  }
502  inline void setIntegerType(int colIndex, int value)
503  {
504  integerInformation_[colIndex] = static_cast< char >(value);
505  }
507  virtual const CoinPackedMatrix *getMatrixByRow() const;
508 
510  virtual const CoinPackedMatrix *getMatrixByCol() const;
511 
513  virtual CoinPackedMatrix *getMutableMatrixByCol() const;
514 
516  virtual double getInfinity() const { return OsiClpInfinity; }
518 
521  virtual const double *getColSolution() const;
523 
525  virtual const double *getRowPrice() const;
526 
528  virtual const double *getReducedCost() const;
529 
532  virtual const double *getRowActivity() const;
533 
535  virtual double getObjValue() const;
536 
539  virtual int getIterationCount() const
540  {
541  return modelPtr_->numberIterations();
542  }
543 
561  virtual std::vector< double * > getDualRays(int maxNumRays,
562  bool fullRay = false) const;
574  virtual std::vector< double * > getPrimalRays(int maxNumRays) const;
575 
577 
578 
579  //---------------------------------------------------------------------------
580 
583  //-------------------------------------------------------------------------
587  virtual void setObjCoeff(int elementIndex, double elementValue);
588 
591  virtual void setColLower(int elementIndex, double elementValue);
592 
595  virtual void setColUpper(int elementIndex, double elementValue);
596 
598  virtual void setColBounds(int elementIndex,
599  double lower, double upper);
600 
609  virtual void setColSetBounds(const int *indexFirst,
610  const int *indexLast,
611  const double *boundList);
612 
615  virtual void setRowLower(int elementIndex, double elementValue);
616 
619  virtual void setRowUpper(int elementIndex, double elementValue);
620 
622  virtual void setRowBounds(int elementIndex,
623  double lower, double upper);
624 
626  virtual void setRowType(int index, char sense, double rightHandSide,
627  double range);
628 
637  virtual void setRowSetBounds(const int *indexFirst,
638  const int *indexLast,
639  const double *boundList);
640 
651  virtual void setRowSetTypes(const int *indexFirst,
652  const int *indexLast,
653  const char *senseList,
654  const double *rhsList,
655  const double *rangeList);
660  virtual void setObjective(const double *array);
661 
666  virtual void setColLower(const double *array);
667 
672  virtual void setColUpper(const double *array);
673 
674  // using OsiSolverInterface::setRowName ;
676  // virtual void setRowName(int rowIndex, std::string & name) ;
677  virtual void setRowName(int rowIndex, std::string name);
678 
679  // using OsiSolverInterface::setColName ;
681  // virtual void setColName(int colIndex, std::string & name) ;
682  virtual void setColName(int colIndex, std::string name);
683 
685 
686  //-------------------------------------------------------------------------
690  virtual void setContinuous(int index);
692  virtual void setInteger(int index);
695  virtual void setContinuous(const int *indices, int len);
698  virtual void setInteger(const int *indices, int len);
700  inline int numberSOS() const
701  {
702  return numberSOS_;
703  }
705  inline const CoinSet *setInfo() const
706  {
707  return setInfo_;
708  }
720  virtual int findIntegersAndSOS(bool justCount);
722 
723  //-------------------------------------------------------------------------
725  virtual void setObjSense(double s)
726  {
727  modelPtr_->setOptimizationDirection(s < 0 ? -1 : 1);
728  }
729 
740  virtual void setColSolution(const double *colsol);
741 
752  virtual void setRowPrice(const double *rowprice);
753 
754  //-------------------------------------------------------------------------
759 
760  //using OsiSolverInterface::addCol ;
762  virtual void addCol(const CoinPackedVectorBase &vec,
763  const double collb, const double colub,
764  const double obj);
767  virtual void addCol(const CoinPackedVectorBase &vec,
768  const double collb, const double colub,
769  const double obj, std::string name);
771  virtual void addCol(int numberElements, const int *rows, const double *elements,
772  const double collb, const double colub,
773  const double obj);
776  virtual void addCol(int numberElements,
777  const int *rows, const double *elements,
778  const double collb, const double colub,
779  const double obj, std::string name);
781  virtual void addCols(const int numcols,
782  const CoinPackedVectorBase *const *cols,
783  const double *collb, const double *colub,
784  const double *obj);
786  virtual void addCols(const int numcols,
787  const CoinBigIndex *columnStarts, const int *rows, const double *elements,
788  const double *collb, const double *colub,
789  const double *obj);
791  virtual void deleteCols(const int num, const int *colIndices);
792 
794  virtual void addRow(const CoinPackedVectorBase &vec,
795  const double rowlb, const double rowub);
802  virtual void addRow(const CoinPackedVectorBase &vec,
803  const double rowlb, const double rowub,
804  std::string name);
805  virtual void addRow(const CoinPackedVectorBase &vec,
806  const char rowsen, const double rowrhs,
807  const double rowrng);
809  virtual void addRow(int numberElements, const int *columns, const double *element,
810  const double rowlb, const double rowub);
813  virtual void addRow(const CoinPackedVectorBase &vec,
814  const char rowsen, const double rowrhs,
815  const double rowrng, std::string name);
817  virtual void addRows(const int numrows,
818  const CoinPackedVectorBase *const *rows,
819  const double *rowlb, const double *rowub);
821  virtual void addRows(const int numrows,
822  const CoinPackedVectorBase *const *rows,
823  const char *rowsen, const double *rowrhs,
824  const double *rowrng);
825 
827  virtual void addRows(const int numrows,
828  const CoinBigIndex *rowStarts, const int *columns, const double *element,
829  const double *rowlb, const double *rowub);
831  void modifyCoefficient(int row, int column, double newElement,
832  bool keepZero = false)
833  {
834  modelPtr_->modifyCoefficient(row, column, newElement, keepZero);
835  }
836 
838  virtual void deleteRows(const int num, const int *rowIndices);
841  virtual void saveBaseModel();
845  virtual void restoreBaseModel(int numberRows);
846 
847  //-----------------------------------------------------------------------
851  virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts);
856  virtual void applyRowCuts(int numberCuts, const OsiRowCut **cuts);
879  virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs,
880  double effectivenessLb = 0.0);
881 
883 
884 
885  //---------------------------------------------------------------------------
886 
887 public:
901  virtual void loadProblem(const CoinPackedMatrix &matrix,
902  const double *collb, const double *colub,
903  const double *obj,
904  const double *rowlb, const double *rowub);
905 
913  virtual void assignProblem(CoinPackedMatrix *&matrix,
914  double *&collb, double *&colub, double *&obj,
915  double *&rowlb, double *&rowub);
916 
929  virtual void loadProblem(const CoinPackedMatrix &matrix,
930  const double *collb, const double *colub,
931  const double *obj,
932  const char *rowsen, const double *rowrhs,
933  const double *rowrng);
934 
942  virtual void assignProblem(CoinPackedMatrix *&matrix,
943  double *&collb, double *&colub, double *&obj,
944  char *&rowsen, double *&rowrhs,
945  double *&rowrng);
946 
949  virtual void loadProblem(const ClpMatrixBase &matrix,
950  const double *collb, const double *colub,
951  const double *obj,
952  const double *rowlb, const double *rowub);
953 
956  virtual void loadProblem(const int numcols, const int numrows,
957  const CoinBigIndex *start, const int *index,
958  const double *value,
959  const double *collb, const double *colub,
960  const double *obj,
961  const double *rowlb, const double *rowub);
962 
965  virtual void loadProblem(const int numcols, const int numrows,
966  const CoinBigIndex *start, const int *index,
967  const double *value,
968  const double *collb, const double *colub,
969  const double *obj,
970  const char *rowsen, const double *rowrhs,
971  const double *rowrng);
973  virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution = false);
974 
978  virtual int readMps(const char *filename,
979  const char *extension = "mps");
982  int readMps(const char *filename, bool keepNames, bool allowErrors);
984  virtual int readMps(const char *filename, const char *extension,
985  int &numberSets, CoinSet **&sets);
986 
991  virtual void writeMps(const char *filename,
992  const char *extension = "mps",
993  double objSense = 0.0) const;
1002  virtual int writeMpsNative(const char *filename,
1003  const char **rowNames, const char **columnNames,
1004  int formatType = 0, int numberAcross = 2,
1005  double objSense = 0.0) const;
1007  virtual int readLp(const char *filename, const double epsilon = 1e-5);
1013  virtual void writeLp(const char *filename,
1014  const char *extension = "lp",
1015  double epsilon = 1e-5,
1016  int numberAcross = 10,
1017  int decimals = 5,
1018  double objSense = 0.0,
1019  bool useRowNames = true) const;
1024  virtual void writeLp(FILE *fp,
1025  double epsilon = 1e-5,
1026  int numberAcross = 10,
1027  int decimals = 5,
1028  double objSense = 0.0,
1029  bool useRowNames = true) const;
1035  virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix);
1037  virtual void replaceMatrix(const CoinPackedMatrix &matrix);
1039 
1050  virtual void passInMessageHandler(CoinMessageHandler *handler);
1052  void newLanguage(CoinMessages::Language language);
1054  {
1055  newLanguage(language);
1056  }
1058  void setLogLevel(int value);
1060  void generateCpp(FILE *fp);
1062  //---------------------------------------------------------------------------
1063 
1066  ClpSimplex *getModelPtr() const;
1070  {
1071  ClpSimplex *model = modelPtr_;
1072  modelPtr_ = newModel;
1073  return model;
1074  }
1076  inline unsigned int specialOptions() const
1077  {
1078  return specialOptions_;
1079  }
1080  void setSpecialOptions(unsigned int value);
1082  inline int lastAlgorithm() const
1083  {
1084  return lastAlgorithm_;
1085  }
1087  inline void setLastAlgorithm(int value)
1088  {
1089  lastAlgorithm_ = value;
1090  }
1092  inline int cleanupScaling() const
1093  {
1094  return cleanupScaling_;
1095  }
1108  inline void setCleanupScaling(int value)
1109  {
1110  cleanupScaling_ = value;
1111  }
1114  inline double smallestElementInCut() const
1115  {
1116  return smallestElementInCut_;
1117  }
1120  inline void setSmallestElementInCut(double value)
1121  {
1122  smallestElementInCut_ = value;
1123  }
1130  inline double smallestChangeInCut() const
1131  {
1132  return smallestChangeInCut_;
1133  }
1140  inline void setSmallestChangeInCut(double value)
1141  {
1142  smallestChangeInCut_ = value;
1143  }
1145  inline void setSolveOptions(const ClpSolve &options)
1146  {
1147  solveOptions_ = options;
1148  }
1152  virtual int tightenBounds(int lightweight = 0);
1154  int infeasibleOtherWay(char *whichWay);
1156  virtual CoinBigIndex getSizeL() const;
1158  virtual CoinBigIndex getSizeU() const;
1161  {
1162  return disasterHandler_;
1163  }
1168  {
1169  return fakeObjective_;
1170  }
1174  void setFakeObjective(double *fakeObjective);
1194  void setupForRepeatedUse(int senseOfAdventure = 0, int printOut = 0);
1196  virtual void synchronizeModel();
1201  void setSpecialOptionsMutable(unsigned int value) const;
1202 
1204 
1205  //---------------------------------------------------------------------------
1206 
1211 
1213  virtual OsiSolverInterface *clone(bool copyData = true) const;
1214 
1217 
1219  OsiClpSolverInterface(ClpSimplex *rhs, bool reallyOwn = false);
1220 
1222  void releaseClp();
1223 
1226 
1228  virtual ~OsiClpSolverInterface();
1229 
1231  virtual void reset();
1233 
1234  //---------------------------------------------------------------------------
1235 
1236 protected:
1238 
1239 
1240  virtual void applyRowCut(const OsiRowCut &rc);
1241 
1243  virtual void applyColCut(const OsiColCut &cc);
1245 
1246  //---------------------------------------------------------------------------
1247 
1248 protected:
1251  void gutsOfDestructor();
1253 
1255  void freeCachedResults() const;
1256 
1258  void freeCachedResults0() const;
1259 
1261  void freeCachedResults1() const;
1262 
1264  void extractSenseRhsRange() const;
1265 
1267  void fillParamMaps();
1276  CoinWarmStartBasis getBasis(ClpSimplex *model) const;
1285  void setBasis(const CoinWarmStartBasis &basis, ClpSimplex *model);
1287  void crunch();
1289  void redoScaleFactors(int numberRows, const CoinBigIndex *starts,
1290  const int *indices, const double *elements);
1291 
1292 public:
1295  void setBasis(const CoinWarmStartBasis &basis);
1297  inline void setBasis()
1298  {
1300  }
1302  CoinWarmStartDiff *getBasisDiff(const unsigned char *statusArray) const;
1304  CoinWarmStartBasis *getBasis(const unsigned char *statusArray) const;
1306  void deleteScaleFactors();
1308  inline const double *upRange() const
1309  {
1310  return rowActivity_;
1311  }
1312  inline const double *downRange() const
1313  {
1314  return columnActivity_;
1315  }
1317  inline void passInRanges(int *array)
1318  {
1319  whichRange_ = array;
1320  }
1322  void setSOSData(int numberSOS, const char *type,
1323  const int *start, const int *indices, const double *weights = NULL);
1325  void computeLargestAway();
1327  inline double largestAway() const
1328  {
1329  return largestAway_;
1330  }
1332  inline void setLargestAway(double value)
1333  {
1334  largestAway_ = value;
1335  }
1337  void lexSolve();
1340  {
1341  return continuousModel_;
1342  }
1344  inline void setContinuousModel(ClpSimplex *model)
1345  {
1346  continuousModel_ = model;
1347  }
1349 
1350 protected:
1353  mutable ClpSimplex *modelPtr_;
1356 
1358  mutable char *rowsense_;
1360 
1362  mutable double *rhs_;
1363 
1367  mutable double *rowrange_;
1368 
1374  mutable double *rowActivity_;
1375  mutable double *columnActivity_;
1401 
1412  mutable int lastAlgorithm_;
1413 
1416 
1419 
1422 
1425 
1431 
1432  //std::map<OsiIntParam, ClpIntParam> intParamMap_;
1433  //std::map<OsiDblParam, ClpDblParam> dblParamMap_;
1434  //std::map<OsiStrParam, ClpStrParam> strParamMap_;
1435 
1437  mutable bool fakeMinInSimplex_;
1444  mutable double *linearObjective_;
1445 
1491  mutable unsigned int specialOptions_;
1507 };
1508 
1510 public:
1514  virtual void intoSimplex();
1517  virtual bool check() const;
1519  virtual void saveInfo();
1521  virtual int typeOfDisaster();
1523 
1530  virtual ~OsiClpDisasterHandler();
1531  // Copy
1533  // Assignment
1536  virtual ClpDisasterHandler *clone() const;
1537 
1539 
1544  void setOsiModel(OsiClpSolverInterface *model);
1547  {
1548  return osiModel_;
1549  }
1551  inline void setWhereFrom(int value)
1552  {
1553  whereFrom_ = value;
1554  }
1556  inline int whereFrom() const
1557  {
1558  return whereFrom_;
1559  }
1561  inline void setPhase(int value)
1562  {
1563  phase_ = value;
1564  }
1566  inline int phase() const
1567  {
1568  return phase_;
1569  }
1571  bool inTrouble() const;
1572 
1574 
1575 protected:
1596  int phase_;
1600 };
1601 // So unit test can find out if NDEBUG set
1602 bool OsiClpHasNDEBUG();
1603 //#############################################################################
1605 void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir);
1606 #endif
1607 
1608 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
1609 */
ClpLinearObjective * fakeObjective() const
Get fake objective.
virtual void writeLp(const char *filename, const char *extension="lp", double epsilon=1e-5, int numberAcross=10, int decimals=5, double objSense=0.0, bool useRowNames=true) const
Write the problem into an Lp file of the given filename.
virtual int pivot(int colIn, int colOut, int outStatus)
Perform a pivot by substituting a colIn for colOut in the basis.
void setStuff(double tolerance, double increment)
Sets integer tolerance and increment.
This is a very simple class to guide algorithms.
Definition: ClpSolve.hpp:20
virtual int readMps(const char *filename, const char *extension="mps")
char * integerInformation_
Pointer to integer information.
unsigned int specialOptions_
Special options 0x80000000 off 0 simple stuff for branch and bound 1 try and keep work regions as muc...
int numberSOS_
Number of SOS sets.
int phase_
phase 0 initial 1 trying continuing with back in and maybe different perturb 2 trying continuing with...
virtual void branchAndBound()
Invoke solver's built-in enumeration algorithm.
int integerType(int colIndex) const
Return integer type (0,1,2=optional,3=sc,4=scint)
virtual void initialSolve()
Solve initial LP relaxation.
virtual void markHotStart()
Create a hotstart point of the optimization process.
double smallestElementInCut_
Smallest allowed element in cut.
void redoScaleFactors(int numberRows, const CoinBigIndex *starts, const int *indices, const double *elements)
Extend scale factors.
Status
enums for status of various sorts.
Definition: ClpSimplex.hpp:114
void lexSolve()
Sort of lexicographic resolve.
bool getDblParam(OsiDblParam key, double &value) const
int lastAlgorithm_
Last algorithm used.
double * linearObjective_
Linear objective.
const CoinWarmStartBasis * getConstPointerToWarmStart() const
Get warmstarting information.
void setLargestAway(double value)
Set largest amount continuous away from bound.
virtual ClpDisasterHandler * clone() const
Clone.
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 disableFactorization() const
Undo any setting changes made by enableFactorization.
virtual double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
virtual bool isProvenOptimal() const
Is optimality proven?
virtual void passInMessageHandler(CoinMessageHandler *handler)
Pass in a message handler.
Abstract base class for Clp Matrices.
bool getStrParam(OsiStrParam key, std::string &value) const
void setWhereFrom(int value)
Set where from.
double * rowActivity_
also save row and column information for hot starts only used in hotstarts so can be casual
int numberColumns() const
Definition: ClpModel.hpp:328
virtual void getBInvARow(int row, double *z, double *slack=NULL) const
Get a row of the tableau (slack part in slack if not NULL)
virtual void applyRowCuts(int numberCuts, const OsiRowCut *cuts)
Apply a collection of row cuts which are all effective.
double * objective() const
Objective.
Definition: ClpModel.hpp:713
virtual int primalPivotResult(int colIn, int sign, int &colOut, int &outStatus, double &t, CoinPackedVector *dx)
Obtain a result of the primal pivot Outputs: colOut – leaving column, outStatus – its status,...
friend void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
virtual int readLp(const char *filename, const double epsilon=1e-5)
Read file in LP format (with names)
virtual void enableSimplexInterface(bool doingPrimal)
Enables simplex mode 2 (individual pivot control)
OsiDblParam
virtual void getBInvACol(int col, double *vec) const
Get a column of the tableau.
virtual ~OsiClpSolverInterface()
Destructor.
void newLanguage(CoinMessages::Language language)
Set language.
virtual CoinBigIndex getNumElements() const
Get number of nonzero elements.
int phase() const
Get phase.
ClpSimplex * continuousModel_
Continuous model.
void freeCachedResults0() const
Deletes all mutable stuff for row ranges etc.
void setSpecialOptions(unsigned int value)
void replaceSetInfo(int numberSOS, CoinSet *setInfo)
Replace setInfo (takes over ownership)
ClpSimplex * modelPtr_
Clp model represented by this class instance.
void freeCachedResults() const
Deletes all mutable stuff.
bool setDblParam(OsiDblParam key, double value)
virtual bool isContinuous(int colNumber) const
Return true if column is continuous.
void copyEnabledSuff(OsiClpSolverInterface &rhs)
Copy across enabled stuff from one solver to another.
virtual bool isInteger(int colIndex) const
Return true if column is integer.
Base class for Clp disaster handling.
virtual void synchronizeModel()
Synchronize model (really if no cuts in tree)
virtual void getBInvCol(int col, double *vec) const
Get a column of the basis inverse.
double * rowLower() const
Row lower.
Definition: ClpModel.hpp:535
virtual void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
double * columnLower() const
Column Lower.
Definition: ClpModel.hpp:750
ClpSimplex * smallModel_
Alternate model (hot starts) - but also could be permanent and used for crunch.
virtual void applyColCut(const OsiColCut &cc)
Apply a column cut (adjust one or more bounds).
Clp Solver Interface.
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.
ClpSimplex * swapModelPtr(ClpSimplex *newModel)
Set pointer to Clp model and return old.
bool isHeuristicInteger(int colIndex) const
Return true only if integer and not optional.
CoinDoubleArrayWithLength columnScale_
Column scale factors (has inverse at end)
virtual int typeOfDisaster()
Type of disaster 0 can fix, 1 abort.
int cleanupScaling() const
Get scaling action option.
void setPhase(int value)
Set phase.
This just implements CoinFactorization when an ClpMatrixBase object is passed.
int lastNumberRows_
Number of rows when last "scaled".
virtual std::string getRowName(int rowIndex, unsigned maxLen=static_cast< unsigned >(std::string::npos)) const
Return name of row if one exists or Rnnnnnnn maxLen is currently ignored and only there to match the ...
OsiHintStrength
virtual void setRowSetTypes(const int *indexFirst, const int *indexLast, const char *senseList, const double *rhsList, const double *rangeList)
Set the type of a number of rows simultaneously The default implementation just invokes setRowType()...
double optimizationDirection() const
Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore.
Definition: ClpModel.hpp:485
virtual const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vecto...
void setSmallestElementInCut(double value)
Set smallest allowed element in cut.
double * columnUpper() const
Column Upper.
Definition: ClpModel.hpp:759
unsigned int specialOptions() const
Get special options.
void setLogLevel(int value)
Set log level (will also set underlying solver's log level)
virtual void setColBounds(int elementIndex, double lower, double upper)
Set a single column lower and upper bound.
virtual std::vector< double * > getPrimalRays(int maxNumRays) const
Get as many primal rays as the solver can provide.
CoinPackedMatrix * matrix() const
Matrix (if not ClpPackedmatrix be careful about memory leak.
Definition: ClpModel.hpp:768
virtual int getIterationCount() const
Get how many iterations it took to solve the problem (whatever "iteration" mean to the solver.
ClpSimplex * baseModel_
Copy of model when option 131072 set.
virtual void getBasics(int *index) const
Get basic indices (order of indices corresponds to the order of elements in a vector retured by getBI...
virtual void disableSimplexInterface()
Undo setting changes made by enableSimplexInterface.
void generateCpp(FILE *fp)
Create C++ lines to get to current state.
virtual bool check() const
Checks if disaster.
virtual const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
virtual void solveFromHotStart()
Optimize starting from the hotstart.
double largestAway() const
Get largest amount continuous away from bound.
OsiClpDisasterHandler * disasterHandler_
Possible disaster handler.
void crossover(int options, int basis)
Solve when primal column and dual row solutions are near-optimal options - 0 no presolve (use primal ...
ClpFactorization * factorization_
factorization for hot starts
void setIntegerType(int colIndex, int value)
Set integer type (0,1,2=optional,3=sc,4=scint)
OsiClpSolverInterface()
Default Constructor.
virtual void restoreBaseModel(int numberRows)
Strip off rows to get to this number of rows.
virtual int dualPivotResult(int &colIn, int &sign, int colOut, int outStatus, double &t, CoinPackedVector *dx)
Obtain a result of the dual pivot (similar to the previous method) Differences: entering variable and...
virtual int writeMpsNative(const char *filename, const char **rowNames, const char **columnNames, int formatType=0, int numberAcross=2, double objSense=0.0) const
Write the problem into an mps file of the given filename, names may be null.
virtual int findIntegersAndSOS(bool justCount)
Identify integer variables and SOS and create corresponding objects.
virtual void setRowSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of rows simultaneously The default implementation just invokes setRowLowe...
double smallestElementInCut() const
Get smallest allowed element in cut.
virtual const char * getColType(bool refresh=false) const
Return array of column length 0 - continuous 1 - binary (may get fixed later) 2 - general integer (ma...
char * spareArrays_
Arrays for hot starts.
void setBasis()
Just puts current basis_ into ClpSimplex model.
virtual void deleteRows(const int num, const int *rowIndices)
virtual const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
virtual const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
virtual const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
virtual void setObjective(const double *array)
Set the objective coefficients for all columns array [getNumCols()] is an array of values for the obj...
double smallestChangeInCut_
Smallest change in cut.
int cleanupScaling_
Scaling option When scaling is on it is possible that the scaled problem is feasible but the unscaled...
bool setStrParam(OsiStrParam key, const std::string &value)
virtual const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
virtual void addCol(const CoinPackedVectorBase &vec, const double collb, const double colub, const double obj)
virtual const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
double * rhs_
Pointer to dense vector of row right-hand side values.
double smallestChangeInCut() const
Get smallest change in cut.
virtual void addRow(const CoinPackedVectorBase &vec, const double rowlb, const double rowub)
int numberSOS() const
Number of SOS sets.
void setCleanupScaling(int value)
Set Scaling option When scaling is on it is possible that the scaled problem is feasible but the unsc...
bool OsiClpHasNDEBUG()
virtual void setColUpper(int elementIndex, double elementValue)
Set a single column upper bound Use DBL_MAX for infinity.
bool notOwned_
To say if destructor should delete underlying model.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:106
virtual CoinBigIndex getSizeL() const
Return number of entries in L part of current factorization.
void setOptimizationDirection(double value)
ClpDataSave saveData_
To save data in OsiSimplex stuff.
void setSolveOptions(const ClpSolve &options)
Pass in initial solve options.
virtual const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
void gutsOfDestructor()
The real work of a copy constructor (used by copy and assignment)
int infeasibleOtherWay(char *whichWay)
See if any integer variables make infeasible other way.
CoinBigIndex getNumElements() const
virtual void setColName(int colIndex, std::string name)
Set name of column.
OsiStrParam
void freeCachedResults1() const
Deletes all mutable stuff for matrix etc.
virtual void setRowUpper(int elementIndex, double elementValue)
Set a single row upper bound Use DBL_MAX for infinity.
virtual void setRowType(int index, char sense, double rightHandSide, double range)
Set the type of a single row
void passInRanges(int *array)
Pass in range array.
virtual void intoSimplex()
Into simplex.
OsiClpDisasterHandler(OsiClpSolverInterface *model=NULL)
Default constructor.
void crunch()
Crunch down problem a bit.
virtual CoinWarmStart * getEmptyWarmStart() const
Get an empty warm start object.
int * whichRange_
Pointer to variables for which we want range information The number is in [0] memory is not owned by ...
virtual const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
virtual double getInfinity() const
Get solver's value for infinity.
virtual CoinBigIndex getSizeU() const
Return number of entries in U part of current factorization.
CoinSet * setInfo_
SOS set info.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
virtual void setColSetBounds(const int *indexFirst, const int *indexLast, const double *boundList)
Set the bounds on a number of columns simultaneously The default implementation just invokes setColL...
virtual ~OsiClpDisasterHandler()
Destructor.
virtual void replaceMatrix(const CoinPackedMatrix &matrix)
And if it does matter (not used at present)
virtual void setRowName(int rowIndex, std::string name)
Set name of row.
void setFakeObjective(ClpLinearObjective *fakeObjective)
Set fake objective (and take ownership)
int itlimOrig_
The original iteration limit before hotstarts started.
This is a tiny class where data can be saved round calls.
Definition: ClpModel.hpp:1397
void setLastAlgorithm(int value)
Set last algorithm used , 1 = primal, 2 = dual other unknown.
void stopFastDual()
Stop fast dual.
virtual void setContinuous(int index)
Set the index-th variable to be a continuous variable.
virtual bool setHintParam(OsiHintParam key, bool yesNo=true, OsiHintStrength strength=OsiHintTry, void *otherInformation=NULL)
virtual bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
OsiRowCut * modelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from model If type is 0 then genuine cut, if 1 then only partially pro...
OsiClpSolverInterface & operator=(const OsiClpSolverInterface &rhs)
Assignment operator.
virtual int setBasisStatus(const int *cstat, const int *rstat)
Set the status of structural/artificial variables and factorize, update solution etc.
bool inTrouble_
Are we in trouble.
virtual void reset()
Resets as if default constructor.
CoinPackedMatrix * matrixByRow_
Pointer to row-wise copy of problem matrix coefficients.
bool isOptionalInteger(int colIndex) const
Return true if column is integer but does not have to be declared as such.
virtual const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
CoinWarmStartBasis getBasis(ClpSimplex *model) const
Warm start.
ClpNodeStuff stuff_
Stuff for fast dual.
double * rowrange_
Pointer to dense vector of slack upper bounds for range constraints (undefined for non-range rows)
double * rowUpper() const
Row upper.
Definition: ClpModel.hpp:544
int lastAlgorithm() const
Last algorithm used , 1 = primal, 2 = dual other unknown.
virtual bool isProvenPrimalInfeasible() const
Is primal infeasiblity proven?
virtual void applyRowCut(const OsiRowCut &rc)
Apply a row cut (append to constraint matrix).
Linear Objective Class.
virtual void setRowPrice(const double *rowprice)
Set dual solution vector.
CoinPackedMatrix * matrixByRowAtContinuous_
Pointer to row-wise copy of continuous problem matrix coefficients.
const CoinSet * setInfo() const
SOS set info.
virtual void setRowBounds(int elementIndex, double lower, double upper)
Set a single row lower and upper bound.
virtual bool isIterationLimitReached() const
Iteration limit reached?
bool fakeMinInSimplex_
Faking min to get proper dual solution signs in simplex API.
static const double OsiClpInfinity
ClpLinearObjective * fakeObjective_
Fake objective.
virtual OsiSolverInterface * clone(bool copyData=true) const
Clone.
virtual int readMps(const char *filename, const char *extension="mps")
Read an mps file from the given filename (defaults to Osi reader) - returns number of errors (see Osi...
virtual void addCols(const int numcols, const CoinPackedVectorBase *const *cols, const double *collb, const double *colub, const double *obj)
CoinWarmStartBasis * getPointerToWarmStart()
Get warmstarting information.
virtual ApplyCutsReturnCode applyCuts(const OsiCuts &cs, double effectivenessLb=0.0)
Apply a collection of cuts.
ClpSolve solveOptions_
Options for initialSolve.
void OsiClpSolverInterfaceUnitTest(const std::string &mpsDir, const std::string &netlibDir)
A function that tests the methods in the OsiClpSolverInterface class.
bool getIntParam(OsiIntParam key, int &value) const
OsiHintTry
virtual void setColLower(int elementIndex, double elementValue)
Set a single column lower bound Use -DBL_MAX for -infinity.
virtual std::string getColName(int colIndex, unsigned maxLen=static_cast< unsigned >(std::string::npos)) const
Return name of column if one exists or Cnnnnnnn maxLen is currently ignored and only there to match t...
void setOsiModel(OsiClpSolverInterface *model)
set model.
void copyEnabledStuff(ClpSimplex &rhs)
Copy across enabled stuff from one solver to another.
virtual void resolveGub(int needed)
Resolve an LP relaxation after problem modification (try GUB)
ClpSimplex * getContinuousModel() const
Get continuous model.
void modifyCoefficient(int row, int column, double newElement, bool keepZero=false)
Modify one element of a matrix.
Definition: ClpModel.hpp:230
double largestAway_
Largest amount continuous away from bound.
void extractSenseRhsRange() const
A method that fills up the rowsense_, rhs_ and rowrange_ arrays.
virtual const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
OsiClpSolverInterface * osiModel() const
Get model.
void setSpecialOptionsMutable(unsigned int value) const
Set special options in underlying clp solver.
int CoinBigIndex
virtual void replaceMatrixOptional(const CoinPackedMatrix &matrix)
I (JJF) am getting annoyed because I can't just replace a matrix.
virtual bool isDualObjectiveLimitReached() const
Is the given dual objective limit reached?
CoinWarmStartBasis basis_
Warmstart information to be used in resolves.
OsiHintParam
void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0)
Set up solver for repeated use by Osi interface.
OsiRowCut * smallModelCut(const double *originalLower, const double *originalUpper, int numberRowsAtContinuous, const int *whichGenerator, int typeCut=0)
Return a conflict analysis cut from small model.
int numberIterations() const
Number of iterations.
Definition: ClpModel.hpp:374
int numberRows() const
Number of rows.
Definition: ClpModel.hpp:315
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 double getObjValue() const
Get objective function value.
virtual void setRowLower(int elementIndex, double elementValue)
Set a single row lower bound Use -DBL_MAX for -infinity.
virtual const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
void setSOSData(int numberSOS, const char *type, const int *start, const int *indices, const double *weights=NULL)
Pass in sos stuff from AMPl.
int whereFrom_
Where from 0 dual (resolve) 1 crunch 2 primal (resolve) 4 dual (initialSolve) 6 primal (initialSolve)
virtual void resolve()
Resolve an LP relaxation after problem modification.
virtual void setInteger(int index)
Set the index-th variable to be an integer variable.
virtual void getReducedGradient(double *columnReducedCosts, double *duals, const double *c) const
Get the reduced gradient for the cost vector c.
virtual void unmarkHotStart()
Delete the snapshot.
virtual void getBasisStatus(int *cstat, int *rstat) const
The following two methods may be replaced by the methods of OsiSolverInterface using OsiWarmStartBasi...
virtual bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
void setContinuousModel(ClpSimplex *model)
Set continuous model.
void setSmallestChangeInCut(double value)
Set smallest change in cut.
const double * upRange() const
If doing fast hot start then ranges are computed.
void passInDisasterHandler(OsiClpDisasterHandler *handler)
Pass in disaster handler.
virtual int tightenBounds(int lightweight=0)
Tighten bounds - lightweight or very lightweight 0 - normal, 1 lightweight but just integers,...
CoinWarmStartBasis * ws_
A pointer to the warmstart information to be used in the hotstarts.
virtual void getBInvRow(int row, double *z) const
Get a row of the basis inverse.
virtual int canDoSimplexInterface() const
Simplex API capability.
virtual void setColSolution(const double *colsol)
Set the primal solution column values.
virtual const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
virtual CoinWarmStart * getWarmStart() const
Get warmstarting information.
void setLanguage(CoinMessages::Language language)
virtual void deleteCols(const int num, const int *colIndices)
virtual bool isAbandoned() const
Are there a numerical difficulties?
OsiIntParam
void deleteScaleFactors()
Delete all scale factor stuff and reset option.
OsiClpDisasterHandler & operator=(const OsiClpDisasterHandler &)
int whereFrom() const
Get where from.
void computeLargestAway()
Compute largest amount any at continuous away from bound.
virtual void addRows(const int numrows, const CoinPackedVectorBase *const *rows, const double *rowlb, const double *rowub)
virtual bool isPrimalObjectiveLimitReached() const
Is the given primal objective limit reached?
void setColumnStatus(int iColumn, ClpSimplex::Status status)
Set column status in ClpSimplex and warmStart.
const OsiClpDisasterHandler * disasterHandler() const
Get disaster handler.
const double COIN_DBL_MAX
virtual const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
virtual void enableFactorization() const
Enables simplex mode 1 (tableau access)
virtual int getNumCols() const
Get number of columns.
bool setIntParam(OsiIntParam key, int value)
CoinDoubleArrayWithLength rowScale_
Row scale factors (has inverse at end)
virtual bool basisIsAvailable() const
Returns true if a basis is available AND problem is optimal.
virtual void saveInfo()
saves information for next attempt
void setOptionalInteger(int index)
Set the index-th variable to be an optional integer variable.
virtual void setObjCoeff(int elementIndex, double elementValue)
Set an objective function coefficient.
virtual bool isBinary(int colIndex) const
Return true if variable is binary.
bool inTrouble() const
are we in trouble
virtual int getNumRows() const
Get number of rows.
ClpSimplex * getModelPtr() const
Get pointer to Clp model.
const double * downRange() const
char * rowsense_
Pointer to dense vector of row sense indicators.
OsiClpSolverInterface * osiModel_
Pointer to model.
virtual int loadFromCoinModel(CoinModel &modelObject, bool keepSolution=false)
This loads a model from a coinModel object - returns number of errors.
virtual bool setWarmStart(const CoinWarmStart *warmstart)
Set warmstarting information.
int startFastDual(int options)
Start faster dual - returns negative if problems 1 if infeasible, Options to pass to solver 1 - creat...
virtual bool isProvenDualInfeasible() const
Is dual infeasiblity proven?
void releaseClp()
Releases so won't error.
CoinWarmStartDiff * getBasisDiff(const unsigned char *statusArray) const
Warm start difference from basis_ to statusArray.
virtual std::vector< double * > getDualRays(int maxNumRays, bool fullRay=false) const
Get as many dual rays as the solver can provide.
virtual CoinPackedMatrix * getMutableMatrixByCol() const
Get pointer to mutable column-wise copy of matrix.
virtual void saveBaseModel()
If solver wants it can save a copy of "base" (continuous) model here.