Cbc  2.10.7
CbcModel.hpp
Go to the documentation of this file.
1 /* $Id$ */
2 // Copyright (C) 2002, 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 CbcModel_H
7 #define CbcModel_H
8 #include <string>
9 #include <vector>
10 #include "CoinMessageHandler.hpp"
11 #include "OsiSolverInterface.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiCuts.hpp"
14 #include "CoinWarmStartBasis.hpp"
15 #include "CbcCompareBase.hpp"
16 #include "CbcCountRowCut.hpp"
17 #include "CbcMessage.hpp"
18 #include "CbcEventHandler.hpp"
19 #include "ClpDualRowPivot.hpp"
20 
21 class CbcCutGenerator;
22 class CbcBaseModel;
23 class OsiRowCut;
24 class OsiBabSolver;
25 class OsiRowCutDebugger;
26 class CglCutGenerator;
27 class CglStored;
28 class CbcCutModifier;
29 class CglTreeProbingInfo;
30 class CbcHeuristic;
31 class OsiObject;
32 class CbcThread;
33 class CbcTree;
34 class CbcStrategy;
35 class CbcSymmetry;
36 class CbcFeasibilityBase;
37 class CbcStatistics;
38 class CbcFullNodeInfo;
39 class CbcEventHandler;
40 class CglPreProcess;
41 class OsiClpSolverInterface;
42 class ClpNodeStuff;
43 
44 // #define CBC_CHECK_BASIS 1
45 
46 //#############################################################################
47 
100 class CbcModel {
101 
102 public:
103  enum CbcIntParam {
127  };
128 
129  enum CbcDblParam {
193  };
194 
195  //---------------------------------------------------------------------------
196 
197 public:
199 
200 
204  void initialSolve();
205 
216  void branchAndBound(int doStatistics = 0);
217 
218 private:
226  bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node);
234  int serialCuts(OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
242  int parallelCuts(CbcBaseModel *master, OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
249  CbcNode **solveOneNode(int whichSolver, CbcNode *node,
250  int &numberNodesOutput, int &status);
252  void resizeWhichGenerator(int numberNow, int numberAfter);
253 
254 public:
255 #ifdef CBC_KEEP_DEPRECATED
256  // See if anyone is using these any more!!
261  CbcModel *cleanModel(const double *lower, const double *upper);
278  int subBranchAndBound(CbcModel *model2,
279  CbcModel *presolvedModel,
280  int maximumNodes);
296  int subBranchAndBound(const double *lower, const double *upper,
297  int maximumNodes);
298 
305  OsiSolverInterface *strengthenedModel();
315  CglPreProcess *preProcess(int makeEquality = 0, int numberPasses = 5,
316  int tuning = 5);
319  void postProcess(CglPreProcess *process);
320 #endif
322  inline CglPreProcess *preProcess() const
323  {
324  return preProcess_;
325  }
327  inline void setPreProcess(CglPreProcess *preProcess)
328  {
330  }
339  int doOneNode(CbcModel *baseModel, CbcNode *&node, CbcNode *&newNode);
340 
341 public:
355  int resolve(CbcNodeInfo *parent, int whereFrom,
356  double *saveSolution = NULL,
357  double *saveLower = NULL,
358  double *saveUpper = NULL);
360  void makeGlobalCuts(int numberRows, const int *which);
362  int makeGlobalCut(const OsiRowCut *cut);
364  int makeGlobalCut(const OsiRowCut &cut);
366  void makeGlobalCut(const OsiColCut *cut);
368  void makeGlobalCut(const OsiColCut &cut);
370  void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver = NULL);
374  inline const int *whichGenerator() const
375  {
376  return whichGenerator_;
377  }
379 
382 
394  CbcModel *findCliques(bool makeEquality, int atLeastThisMany,
395  int lessThanThis, int defaultValue = 1000);
396 
405  CbcModel *integerPresolve(bool weak = false);
406 
411  bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak = false);
412 
414  void originalModel(CbcModel *presolvedModel, bool weak);
415 
436  bool tightenVubs(int type, bool allowMultipleBinary = false,
437  double useCutoff = 1.0e50);
438 
444  bool tightenVubs(int numberVubs, const int *which,
445  double useCutoff = 1.0e50);
454  const OsiSolverInterface *postProcessedSolver(int solutionType = 1);
455 
459  void AddIntegers();
463  void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible);
467  void flipModel();
481  int cleanBounds(OsiSolverInterface *solver, char *cleanVariables);
485 
491 
493  inline int numberObjects() const
494  {
495  return numberObjects_;
496  }
498  inline void setNumberObjects(int number)
499  {
500  numberObjects_ = number;
501  }
502 
504  inline OsiObject **objects() const
505  {
506  return object_;
507  }
508 
510  const inline OsiObject *object(int which) const
511  {
512  return object_[which];
513  }
515  inline OsiObject *modifiableObject(int which) const
516  {
517  return object_[which];
518  }
519 
520  void setOptionalInteger(int index);
521 
523  void deleteObjects(bool findIntegers = true);
524 
529  void addObjects(int numberObjects, OsiObject **objects);
530 
536 
539 
549  void findIntegers(bool startAgain, int type = 0);
555 
556 #ifdef SWITCH_VARIABLES
558  int findSwitching();
560  int fixAssociated(OsiSolverInterface *solver, int cleanBasis);
562  int checkAssociated(const OsiSolverInterface *solver,
563  const double *solution, int printLevel);
564 #endif
566 
567  //---------------------------------------------------------------------------
568 
579  inline bool setIntParam(CbcIntParam key, int value)
580  {
581  intParam_[key] = value;
582  return true;
583  }
585  inline bool setDblParam(CbcDblParam key, double value)
586  {
587  dblParam_[key] = value;
588  return true;
589  }
591  inline int getIntParam(CbcIntParam key) const
592  {
593  return intParam_[key];
594  }
596  inline double getDblParam(CbcDblParam key) const
597  {
598  return dblParam_[key];
599  }
605  void setCutoff(double value);
606 
608  inline double getCutoff() const
609  { //double value ;
610  //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
611  //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
612  return dblParam_[CbcCurrentCutoff];
613  }
614 
616  inline bool setMaximumNodes(int value)
617  {
618  return setIntParam(CbcMaxNumNode, value);
619  }
620 
622  inline int getMaximumNodes() const
623  {
624  return getIntParam(CbcMaxNumNode);
625  }
626 
631  inline bool setMaximumSolutions(int value)
632  {
633  return setIntParam(CbcMaxNumSol, value);
634  }
639  inline int getMaximumSolutions() const
640  {
641  return getIntParam(CbcMaxNumSol);
642  }
644  inline bool setPrintingMode(int value)
645  {
646  return setIntParam(CbcPrinting, value);
647  }
648 
650  inline int getPrintingMode() const
651  {
652  return getIntParam(CbcPrinting);
653  }
654 
659  inline bool setMaximumSeconds(double value)
660  {
661  return setDblParam(CbcMaximumSeconds, value);
662  }
667  inline double getMaximumSeconds() const
668  {
670  }
672  double getCurrentSeconds() const;
673 
675  bool maximumSecondsReached() const;
676 
680  inline bool setIntegerTolerance(double value)
681  {
682  return setDblParam(CbcIntegerTolerance, value);
683  }
687  inline double getIntegerTolerance() const
688  {
690  }
691 
696  inline bool setInfeasibilityWeight(double value)
697  {
698  return setDblParam(CbcInfeasibilityWeight, value);
699  }
704  inline double getInfeasibilityWeight() const
705  {
707  }
708 
712  inline bool setAllowableGap(double value)
713  {
714  return setDblParam(CbcAllowableGap, value);
715  }
719  inline double getAllowableGap() const
720  {
722  }
723 
727  inline bool setAllowableFractionGap(double value)
728  {
729  return setDblParam(CbcAllowableFractionGap, value);
730  }
734  inline double getAllowableFractionGap() const
735  {
737  }
741  inline bool setAllowablePercentageGap(double value)
742  {
743  return setDblParam(CbcAllowableFractionGap, value * 0.01);
744  }
748  inline double getAllowablePercentageGap() const
749  {
750  return 100.0 * getDblParam(CbcAllowableFractionGap);
751  }
755  inline bool setHeuristicGap(double value)
756  {
757  return setDblParam(CbcHeuristicGap, value);
758  }
762  inline double getHeuristicGap() const
763  {
765  }
766 
770  inline bool setHeuristicFractionGap(double value)
771  {
772  return setDblParam(CbcHeuristicFractionGap, value);
773  }
777  inline double getHeuristicFractionGap() const
778  {
780  }
785  inline bool setCutoffIncrement(double value)
786  {
787  return setDblParam(CbcCutoffIncrement, value);
788  }
793  inline double getCutoffIncrement() const
794  {
796  }
798  bool canStopOnGap() const;
799 
804  void setHotstartSolution(const double *solution, const int *priorities = NULL);
805 
807  inline void setMinimumDrop(double value)
808  {
809  minimumDrop_ = value;
810  }
812  inline double getMinimumDrop() const
813  {
814  return minimumDrop_;
815  }
816 
819  inline void setMaximumCutPassesAtRoot(int value)
820  {
821  maximumCutPassesAtRoot_ = value;
822  }
824  inline int getMaximumCutPassesAtRoot() const
825  {
827  }
828 
831  inline void setMaximumCutPasses(int value)
832  {
833  maximumCutPasses_ = value;
834  }
836  inline int getMaximumCutPasses() const
837  {
838  return maximumCutPasses_;
839  }
842  inline int getCurrentPassNumber() const
843  {
844  return currentPassNumber_;
845  }
848  inline void setCurrentPassNumber(int value)
849  {
850  currentPassNumber_ = value;
851  }
852 
858  void setNumberStrong(int number);
862  inline int numberStrong() const
863  {
864  return numberStrong_;
865  }
868  inline void setPreferredWay(int value)
869  {
870  preferredWay_ = value;
871  }
873  inline int getPreferredWay() const
874  {
875  return preferredWay_;
876  }
878  inline int whenCuts() const
879  {
880  return whenCuts_;
881  }
883  inline void setWhenCuts(int value)
884  {
885  whenCuts_ = value;
886  }
892  bool doCutsNow(int allowForTopOfTree) const;
893 
899  void setNumberBeforeTrust(int number);
902  inline int numberBeforeTrust() const
903  {
904  return numberBeforeTrust_;
905  }
911  void setNumberPenalties(int number);
914  inline int numberPenalties() const
915  {
916  return numberPenalties_;
917  }
919  inline const CbcFullNodeInfo *topOfTree() const
920  {
921  return topOfTree_;
922  }
924  inline void setNumberAnalyzeIterations(int number)
925  {
926  numberAnalyzeIterations_ = number;
927  }
928  inline int numberAnalyzeIterations() const
929  {
931  }
934  inline double penaltyScaleFactor() const
935  {
936  return penaltyScaleFactor_;
937  }
940  void setPenaltyScaleFactor(double value);
948  void inline setProblemType(int number)
949  {
950  problemType_ = number;
951  }
952  inline int problemType() const
953  {
954  return problemType_;
955  }
957  inline int currentDepth() const
958  {
959  return currentDepth_;
960  }
961 
963  void setHowOftenGlobalScan(int number);
965  inline int howOftenGlobalScan() const
966  {
967  return howOftenGlobalScan_;
968  }
970  inline int *originalColumns() const
971  {
972  return originalColumns_;
973  }
976  int numberGood = COIN_INT_MAX);
978  OsiRowCut *conflictCut(const OsiSolverInterface *solver, bool &localCuts);
979 
987  inline void setPrintFrequency(int number)
988  {
989  printFrequency_ = number;
990  }
992  inline int printFrequency() const
993  {
994  return printFrequency_;
995  }
997 
998  //---------------------------------------------------------------------------
1000 
1001  bool isAbandoned() const;
1004  bool isProvenOptimal() const;
1006  bool isProvenInfeasible() const;
1012  bool isNodeLimitReached() const;
1018  inline int getIterationCount() const
1019  {
1020  return numberIterations_;
1021  }
1023  inline void incrementIterationCount(int value)
1024  {
1025  numberIterations_ += value;
1026  }
1028  inline int getNodeCount() const
1029  {
1030  return numberNodes_;
1031  }
1033  inline void incrementNodeCount(int value)
1034  {
1035  numberNodes_ += value;
1036  }
1038  inline int getExtraNodeCount() const
1039  {
1040  return numberExtraNodes_;
1041  }
1043  inline int getFathomCount() const
1044  {
1045  return numberFathoms_;
1046  }
1056  inline int status() const
1057  {
1058  return status_;
1059  }
1060  inline void setProblemStatus(int value)
1061  {
1062  status_ = value;
1063  }
1076  inline int secondaryStatus() const
1077  {
1078  return secondaryStatus_;
1079  }
1080  inline void setSecondaryStatus(int value)
1081  {
1082  secondaryStatus_ = value;
1083  }
1092 
1094 
1095  //---------------------------------------------------------------------------
1108  inline int numberRowsAtContinuous() const
1110  {
1111  return numberRowsAtContinuous_;
1112  }
1113 
1115  inline int getNumCols() const
1116  {
1117  return solver_->getNumCols();
1118  }
1119 
1121  inline int getNumRows() const
1122  {
1123  return solver_->getNumRows();
1124  }
1125 
1127  inline CoinBigIndex getNumElements() const
1128  {
1129  return solver_->getNumElements();
1130  }
1131 
1133  inline int numberIntegers() const
1134  {
1135  return numberIntegers_;
1136  }
1137  // Integer variables
1138  inline const int *integerVariable() const
1139  {
1140  return integerVariable_;
1141  }
1143  inline char integerType(int i) const
1144  {
1145  assert(integerInfo_);
1146  assert(integerInfo_[i] == 0 || integerInfo_[i] == 1);
1147  return integerInfo_[i];
1148  }
1150  inline const char *integerType() const
1151  {
1152  return integerInfo_;
1153  }
1154 
1156  inline const double *getColLower() const
1157  {
1158  return solver_->getColLower();
1159  }
1160 
1162  inline const double *getColUpper() const
1163  {
1164  return solver_->getColUpper();
1165  }
1166 
1176  inline const char *getRowSense() const
1177  {
1178  return solver_->getRowSense();
1179  }
1180 
1189  inline const double *getRightHandSide() const
1190  {
1191  return solver_->getRightHandSide();
1192  }
1193 
1202  inline const double *getRowRange() const
1203  {
1204  return solver_->getRowRange();
1205  }
1206 
1208  inline const double *getRowLower() const
1209  {
1210  return solver_->getRowLower();
1211  }
1212 
1214  inline const double *getRowUpper() const
1215  {
1216  return solver_->getRowUpper();
1217  }
1218 
1220  inline const double *getObjCoefficients() const
1221  {
1222  return solver_->getObjCoefficients();
1223  }
1224 
1226  inline double getObjSense() const
1227  {
1228  //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
1230  }
1231 
1233  inline bool isContinuous(int colIndex) const
1234  {
1235  return solver_->isContinuous(colIndex);
1236  }
1237 
1239  inline bool isBinary(int colIndex) const
1240  {
1241  return solver_->isBinary(colIndex);
1242  }
1243 
1248  inline bool isInteger(int colIndex) const
1249  {
1250  return solver_->isInteger(colIndex);
1251  }
1252 
1254  inline bool isIntegerNonBinary(int colIndex) const
1255  {
1256  return solver_->isIntegerNonBinary(colIndex);
1257  }
1258 
1260  inline bool isFreeBinary(int colIndex) const
1261  {
1262  return solver_->isFreeBinary(colIndex);
1263  }
1264 
1266  inline const CoinPackedMatrix *getMatrixByRow() const
1267  {
1268  return solver_->getMatrixByRow();
1269  }
1270 
1272  inline const CoinPackedMatrix *getMatrixByCol() const
1273  {
1274  return solver_->getMatrixByCol();
1275  }
1276 
1278  inline double getInfinity() const
1279  {
1280  return solver_->getInfinity();
1281  }
1283  inline const double *getCbcColLower() const
1284  {
1285  return cbcColLower_;
1286  }
1288  inline const double *getCbcColUpper() const
1289  {
1290  return cbcColUpper_;
1291  }
1293  inline const double *getCbcRowLower() const
1294  {
1295  return cbcRowLower_;
1296  }
1298  inline const double *getCbcRowUpper() const
1299  {
1300  return cbcRowUpper_;
1301  }
1303  inline const double *getCbcColSolution() const
1304  {
1305  return cbcColSolution_;
1306  }
1308  inline const double *getCbcRowPrice() const
1309  {
1310  return cbcRowPrice_;
1311  }
1313  inline const double *getCbcReducedCost() const
1314  {
1315  return cbcReducedCost_;
1316  }
1318  inline const double *getCbcRowActivity() const
1319  {
1320  return cbcRowActivity_;
1321  }
1323 
1327  inline double *continuousSolution() const
1328  {
1329  return continuousSolution_;
1330  }
1335  inline int *usedInSolution() const
1336  {
1337  return usedInSolution_;
1338  }
1340  void incrementUsed(const double *solution);
1343  double &objectiveValue, const double *solution,
1344  int fixVariables = 0);
1346  void setBestObjectiveValue(double objectiveValue);
1349  double objValue,
1350  const double *solution);
1351 
1359  virtual double checkSolution(double cutoff, double *solution,
1360  int fixVariables, double originalObjValue);
1367  bool feasibleSolution(int &numberIntegerInfeasibilities,
1368  int &numberObjectInfeasibilities) const;
1369 
1375  inline double *currentSolution() const
1376  {
1377  return currentSolution_;
1378  }
1382  inline const double *testSolution() const
1383  {
1384  return testSolution_;
1385  }
1386  inline void setTestSolution(const double *solution)
1387  {
1388  testSolution_ = solution;
1389  }
1391  void reserveCurrentSolution(const double *solution = NULL);
1392 
1394  inline const double *getColSolution() const
1395  {
1396  return solver_->getColSolution();
1397  }
1398 
1400  inline const double *getRowPrice() const
1401  {
1402  return solver_->getRowPrice();
1403  }
1404 
1406  inline const double *getReducedCost() const
1407  {
1408  return solver_->getReducedCost();
1409  }
1410 
1412  inline const double *getRowActivity() const
1413  {
1414  return solver_->getRowActivity();
1415  }
1416 
1418  inline double getCurrentObjValue() const
1419  {
1421  }
1423  inline double getCurrentMinimizationObjValue() const
1424  {
1426  }
1427 
1429  inline double getMinimizationObjValue() const
1430  {
1431  return bestObjective_;
1432  }
1434  inline void setMinimizationObjValue(double value)
1435  {
1436  bestObjective_ = value;
1437  }
1438 
1440  inline double getObjValue() const
1441  {
1442  return bestObjective_ * solver_->getObjSense();
1443  }
1449  double getBestPossibleObjValue() const;
1451  inline void setObjValue(double value)
1452  {
1453  bestObjective_ = value * solver_->getObjSense();
1454  }
1456  inline double getSolverObjValue() const
1457  {
1458  return solver_->getObjValue() * solver_->getObjSense();
1459  }
1460 
1467  inline double *bestSolution() const
1468  {
1469  return bestSolution_;
1470  }
1477  void setBestSolution(const double *solution, int numberColumns,
1478  double objectiveValue, bool check = false);
1479 
1481  inline int getSolutionCount() const
1482  {
1483  return numberSolutions_;
1484  }
1485 
1487  inline void setSolutionCount(int value)
1488  {
1489  numberSolutions_ = value;
1490  }
1494  inline int maximumSavedSolutions() const
1495  {
1496  return maximumSavedSolutions_;
1497  }
1499  void setMaximumSavedSolutions(int value);
1501  const double *savedSolution(int which) const;
1503  double savedSolutionObjective(int which) const;
1505  void deleteSavedSolution(int which);
1506 
1515  inline int phase() const
1516  {
1517  return phase_;
1518  }
1519 
1521  inline int getNumberHeuristicSolutions() const
1522  {
1524  }
1526  inline void setNumberHeuristicSolutions(int value)
1527  {
1528  numberHeuristicSolutions_ = value;
1529  }
1530 
1532  inline void setObjSense(double s)
1533  {
1535  solver_->setObjSense(s);
1536  }
1537 
1539  inline double getContinuousObjective() const
1540  {
1542  }
1543  inline void setContinuousObjective(double value)
1544  {
1546  }
1548  inline int getContinuousInfeasibilities() const
1549  {
1551  }
1552  inline void setContinuousInfeasibilities(int value)
1553  {
1555  }
1557  inline double rootObjectiveAfterCuts() const
1558  {
1559  return continuousObjective_;
1560  }
1562  inline double sumChangeObjective() const
1563  {
1564  return sumChangeObjective1_;
1565  }
1568  inline int numberGlobalViolations() const
1569  {
1570  return numberGlobalViolations_;
1571  }
1573  {
1575  }
1577  inline bool resolveAfterTakeOffCuts() const
1578  {
1579  return resolveAfterTakeOffCuts_;
1580  }
1581  inline void setResolveAfterTakeOffCuts(bool yesNo)
1582  {
1583  resolveAfterTakeOffCuts_ = yesNo;
1584  }
1586  inline int maximumRows() const
1587  {
1588  return maximumRows_;
1589  }
1591  inline CoinWarmStartBasis &workingBasis()
1592  {
1593  return workingBasis_;
1594  }
1596  inline int getStopNumberIterations() const
1597  {
1598  return stopNumberIterations_;
1599  }
1601  inline void setStopNumberIterations(int value)
1602  {
1603  stopNumberIterations_ = value;
1604  }
1606  inline CbcModel *heuristicModel() const
1607  {
1608  return heuristicModel_;
1609  }
1611  inline void setHeuristicModel(CbcModel *model)
1612  {
1613  heuristicModel_ = model;
1614  }
1616 
1619  // Comparison functions (which may be overridden by inheritance)
1621  {
1622  return nodeCompare_;
1623  }
1627 
1630  // Feasibility functions (which may be overridden by inheritance)
1632  {
1633  return problemFeasibility_;
1634  }
1638 
1642  inline CbcTree *tree() const
1643  {
1644  return tree_;
1645  }
1656  CbcModel *subTreeModel(OsiSolverInterface *solver = NULL) const;
1658  inline int numberStoppedSubTrees() const
1659  {
1660  return numberStoppedSubTrees_;
1661  }
1664  {
1666  }
1672  inline int typePresolve() const
1673  {
1674  return presolve_;
1675  }
1676  inline void setTypePresolve(int value)
1677  {
1678  presolve_ = value;
1679  }
1680 
1682 
1688 
1691  {
1692  return branchingMethod_;
1693  }
1696  {
1697  delete branchingMethod_;
1698  branchingMethod_ = method->clone();
1699  }
1705  {
1706  delete branchingMethod_;
1707  branchingMethod_ = method.clone();
1708  }
1710  inline CbcCutModifier *cutModifier() const
1711  {
1712  return cutModifier_;
1713  }
1722 
1725 
1732  inline int stateOfSearch() const
1733  {
1734  return stateOfSearch_;
1735  }
1736  inline void setStateOfSearch(int state)
1737  {
1738  stateOfSearch_ = state;
1739  }
1741  inline int searchStrategy() const
1742  {
1743  return searchStrategy_;
1744  }
1746  inline void setSearchStrategy(int value)
1747  {
1748  searchStrategy_ = value;
1749  }
1751  inline int strongStrategy() const
1752  {
1753  return strongStrategy_;
1754  }
1756  inline void setStrongStrategy(int value)
1757  {
1758  strongStrategy_ = value;
1759  }
1760 
1762  inline int numberCutGenerators() const
1763  {
1764  return numberCutGenerators_;
1765  }
1768  {
1769  return generator_;
1770  }
1772  inline CbcCutGenerator *cutGenerator(int i) const
1773  {
1774  return generator_[i];
1775  }
1778  {
1779  return virginGenerator_[i];
1780  }
1789  void addCutGenerator(CglCutGenerator *generator,
1790  int howOften = 1, const char *name = NULL,
1791  bool normal = true, bool atSolution = false,
1792  bool infeasible = false, int howOftenInSub = -100,
1793  int whatDepth = -1, int whatDepthInSub = -1);
1795 
1800 
1802  inline CbcStrategy *strategy() const
1803  {
1804  return strategy_;
1805  }
1810  {
1811  strategy_ = strategy;
1812  }
1814  inline CbcModel *parentModel() const
1815  {
1816  return parentModel_;
1817  }
1820  {
1822  }
1824 
1831  void addHeuristic(CbcHeuristic *generator, const char *name = NULL,
1832  int before = -1);
1834  inline CbcHeuristic *heuristic(int i) const
1835  {
1836  return heuristic_[i];
1837  }
1839  inline int numberHeuristics() const
1840  {
1841  return numberHeuristics_;
1842  }
1844  inline void setNumberHeuristics(int value)
1845  {
1846  numberHeuristics_ = value;
1847  }
1849  inline CbcHeuristic *lastHeuristic() const
1850  {
1851  return lastHeuristic_;
1852  }
1854  inline void setLastHeuristic(CbcHeuristic *last)
1855  {
1856  lastHeuristic_ = last;
1857  }
1858 
1877  void passInPriorities(const int *priorities, bool ifNotSimpleIntegers);
1878 
1880  inline int priority(int sequence) const
1881  {
1882  return object_[sequence]->priority();
1883  }
1884 
1889  void passInEventHandler(const CbcEventHandler *eventHandler);
1890 
1893  {
1894  return (eventHandler_);
1895  }
1896 
1898 
1908  void setApplicationData(void *appData);
1909 
1911  void *getApplicationData() const;
1926  inline const OsiBabSolver *solverCharacteristics() const
1927  {
1928  return solverCharacteristics_;
1929  }
1931 
1932  //---------------------------------------------------------------------------
1933 
1937  void passInMessageHandler(CoinMessageHandler *handler);
1939  void newLanguage(CoinMessages::Language language);
1940  inline void setLanguage(CoinMessages::Language language)
1941  {
1942  newLanguage(language);
1943  }
1945  inline CoinMessageHandler *messageHandler() const
1946  {
1947  return handler_;
1948  }
1950  inline CoinMessages &messages()
1951  {
1952  return messages_;
1953  }
1955  inline CoinMessages *messagesPointer()
1956  {
1957  return &messages_;
1958  }
1960  void setLogLevel(int value);
1962  inline int logLevel() const
1963  {
1964  return handler_->logLevel();
1965  }
1971  inline void setDefaultHandler(bool yesNo)
1972  {
1973  defaultHandler_ = yesNo;
1974  }
1976  inline bool defaultHandler() const
1977  {
1978  return defaultHandler_;
1979  }
1981  //---------------------------------------------------------------------------
1983 
1984 
2014  inline void setSpecialOptions(int value)
2015  {
2016  specialOptions_ = value;
2017  }
2019  inline int specialOptions() const
2020  {
2021  return specialOptions_;
2022  }
2024  inline void setRandomSeed(int value)
2025  {
2026  randomSeed_ = value;
2027  }
2029  inline int getRandomSeed() const
2030  {
2031  return randomSeed_;
2032  }
2034  inline void setMultipleRootTries(int value)
2035  {
2036  multipleRootTries_ = value;
2037  }
2039  inline int getMultipleRootTries() const
2040  {
2041  return multipleRootTries_;
2042  }
2044  inline void sayEventHappened()
2045  {
2046  eventHappened_ = true;
2047  }
2049  inline bool normalSolver() const
2050  {
2051  return (specialOptions_ & 16) == 0;
2052  }
2057  inline bool waitingForMiniBranchAndBound() const
2058  {
2059  return (specialOptions_ & 1048576) != 0;
2060  }
2084  inline void setMoreSpecialOptions(int value)
2085  {
2086  moreSpecialOptions_ = value;
2087  }
2089  inline int moreSpecialOptions() const
2090  {
2091  return moreSpecialOptions_;
2092  }
2108  inline void setMoreSpecialOptions2(int value)
2109  {
2110  moreSpecialOptions2_ = value;
2111  }
2113  inline int moreSpecialOptions2() const
2114  {
2115  return moreSpecialOptions2_;
2116  }
2118  inline void setCutoffAsConstraint(bool yesNo)
2119  {
2120  cutoffRowNumber_ = (yesNo) ? -2 : -1;
2121  }
2123  inline void setUseElapsedTime(bool yesNo)
2124  {
2125  if (yesNo)
2126  moreSpecialOptions_ |= 131072;
2127  else
2128  moreSpecialOptions_ &= ~131072;
2129  }
2131  inline bool useElapsedTime() const
2132  {
2133  return (moreSpecialOptions_ & 131072) != 0;
2134  }
2136  inline void *temporaryPointer() const
2137  {
2138  return temporaryPointer_;
2139  }
2141  inline void setTemporaryPointer(void *pointer)
2142  {
2143  temporaryPointer_ = pointer;
2144  }
2146  void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod);
2148  inline bool ownObjects() const
2149  {
2150  return ownObjects_;
2151  }
2153  void checkModel();
2155  //---------------------------------------------------------------------------
2156 
2158 
2159  CbcModel();
2161 
2163  CbcModel(const OsiSolverInterface &);
2164 
2173  void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
2174 
2186  inline void setModelOwnsSolver(bool ourSolver)
2187  {
2188  ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000));
2189  }
2190 
2196  inline bool modelOwnsSolver()
2197  {
2198  return ((ownership_ & 0x80000000) != 0);
2199  }
2200 
2204  CbcModel(const CbcModel &rhs, bool cloneHandler = false);
2205 
2207  virtual CbcModel *clone(bool cloneHandler);
2208 
2211 
2213  virtual ~CbcModel();
2214 
2216  inline OsiSolverInterface *solver() const
2217  {
2218  return solver_;
2219  }
2220 
2222  inline OsiSolverInterface *swapSolver(OsiSolverInterface *solver)
2223  {
2224  OsiSolverInterface *returnSolver = solver_;
2225  solver_ = solver;
2226  return returnSolver;
2227  }
2228 
2230  inline OsiSolverInterface *continuousSolver() const
2231  {
2232  return continuousSolver_;
2233  }
2234 
2237  {
2238  continuousSolver_ = solver_->clone();
2239  }
2242  {
2243  delete continuousSolver_;
2244  continuousSolver_ = NULL;
2245  }
2246 
2248  inline OsiSolverInterface *referenceSolver() const
2249  {
2250  return referenceSolver_;
2251  }
2252 
2255 
2262 
2270  void resetModel();
2276  void gutsOfCopy(const CbcModel &rhs, int mode = 0);
2278  void moveInfo(const CbcModel &rhs);
2280 
2282 
2283  static bool haveMultiThreadSupport();
2287  {
2288  return masterThread_;
2289  }
2292  {
2293  return walkback_;
2294  }
2296  inline int getNumberThreads() const
2297  {
2298  return numberThreads_;
2299  }
2301  inline void setNumberThreads(int value)
2302  {
2303  numberThreads_ = value;
2304  }
2306  inline int getThreadMode() const
2307  {
2308  return threadMode_;
2309  }
2319  inline void setThreadMode(int value)
2320  {
2321  threadMode_ = value;
2322  }
2329  inline int parallelMode() const
2330  {
2331  if (!numberThreads_) {
2332  if ((threadMode_ & 1) == 0)
2333  return 0;
2334  else
2335  return -1;
2336  return 0;
2337  } else {
2338  if ((threadMode_ & 1) == 0)
2339  return 1;
2340  else
2341  return -2;
2342  }
2343  }
2345  inline CbcBaseModel *master() const
2346  {
2347  return master_;
2348  }
2351  bool isLocked() const;
2356  void lockThread();
2368  void setInfoInChild(int type, CbcThread *info);
2375  void moveToModel(CbcModel *baseModel, int mode);
2377  int splitModel(int numberModels, CbcModel **model,
2378  int numberNodes);
2380  void startSplitModel(int numberIterations);
2382  void mergeModels(int numberModel, CbcModel **model,
2383  int numberNodes);
2385 
2387 
2388  int getNodeCount2() const
2390  {
2391  return numberNodes2_;
2392  }
2394  void setPointers(const OsiSolverInterface *solver);
2404  void synchronizeHandlers(int makeDefault);
2406  void saveExtraSolution(const double *solution, double objectiveValue);
2408  void saveBestSolution(const double *solution, double objectiveValue);
2412  int resolve(OsiSolverInterface *solver);
2413 #ifdef CLP_RESOLVE
2415  int resolveClp(OsiClpSolverInterface *solver, int type);
2416 #endif
2417 
2421  int chooseBranch(CbcNode *&newNode, int numberPassesLeft,
2422  CbcNode *oldNode, OsiCuts &cuts,
2423  bool &resolved, CoinWarmStartBasis *lastws,
2424  const double *lowerBefore, const double *upperBefore,
2425  OsiSolverBranch *&branches);
2426 
2433  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const;
2434 
2446  int takeOffCuts(OsiCuts &cuts,
2447  bool allowResolve, OsiCuts *saveCuts,
2448  int numberNewCuts = 0, const OsiRowCut **newCuts = NULL);
2449 
2462  int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws);
2463 
2480  bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws);
2484  void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn,
2485  double &lower, double &upper, int force);
2490  void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const;
2491 
2497  void synchronizeNumberBeforeTrust(int type = 0);
2499  void zapIntegerInformation(bool leaveObjects = true);
2501  void pseudoShadow(int type);
2508  void fillPseudoCosts(double *downCosts, double *upCosts,
2509  int *priority = NULL,
2510  int *numberDown = NULL, int *numberUp = NULL,
2511  int *numberDownInfeasible = NULL,
2512  int *numberUpInfeasible = NULL) const;
2518  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
2522  inline const double *hotstartSolution() const
2523  {
2524  return hotstartSolution_;
2525  }
2527  inline const int *hotstartPriorities() const
2528  {
2529  return hotstartPriorities_;
2530  }
2531 
2533  inline CbcCountRowCut **addedCuts() const
2534  {
2535  return addedCuts_;
2536  }
2538  inline int currentNumberCuts() const
2539  {
2540  return currentNumberCuts_;
2541  }
2544  {
2545  return &globalCuts_;
2546  }
2548  inline void zapGlobalCuts()
2549  {
2550  globalCuts_ = CbcRowCuts();
2551  }
2553  void setNextRowCut(const OsiRowCut &cut);
2555  inline CbcNode *currentNode() const
2556  {
2557  return currentNode_;
2558  }
2560  void deleteNode(CbcNode * node);
2562  inline CglTreeProbingInfo *probingInfo() const
2563  {
2564  return probingInfo_;
2565  }
2567  inline CoinThreadRandom *randomNumberGenerator()
2568  {
2569  return &randomNumberGenerator_;
2570  }
2572  inline void setNumberStrongIterations(int number)
2573  {
2574  numberStrongIterations_ = number;
2575  }
2577  inline int numberStrongIterations() const
2578  {
2579  return numberStrongIterations_;
2580  }
2582  inline int maximumNumberIterations() const
2583  {
2584  return maximumNumberIterations_;
2585  }
2587  inline void setMaximumNumberIterations(int value)
2588  {
2589  maximumNumberIterations_ = value;
2590  }
2591 #ifdef COIN_HAS_NTY
2593  inline CbcSymmetry *symmetryInfo() const
2594  {
2595  return symmetryInfo_;
2596  }
2598  void zapSymmetry();
2599 #endif
2601  inline void setFastNodeDepth(int value)
2602  {
2603  fastNodeDepth_ = value;
2604  }
2606  inline int fastNodeDepth() const
2607  {
2608  return fastNodeDepth_;
2609  }
2611  inline int continuousPriority() const
2612  {
2613  return continuousPriority_;
2614  }
2616  inline void setContinuousPriority(int value)
2617  {
2618  continuousPriority_ = value;
2619  }
2620  inline void incrementExtra(int nodes, int iterations, int fathoms = 1)
2621  {
2622  numberExtraNodes_ += nodes;
2623  numberExtraIterations_ += iterations;
2624  numberFathoms_ += fathoms;
2625  }
2627  inline void zeroExtra()
2628  {
2629  numberExtraNodes_ = 0;
2631  numberFathoms_ = 0;
2632  }
2634  inline int numberExtraIterations() const
2635  {
2636  return numberExtraIterations_;
2637  }
2639  void incrementStrongInfo(int numberTimes, int numberIterations,
2640  int numberFixed, bool ifInfeasible);
2642  inline const int *strongInfo() const
2643  {
2644  return strongInfo_;
2645  }
2646 
2648  inline int *mutableStrongInfo()
2649  {
2650  return strongInfo_;
2651  }
2653  CglStored *storedRowCuts() const
2654  {
2655  return storedRowCuts_;
2656  }
2658  void setStoredRowCuts(CglStored *cuts)
2659  {
2660  storedRowCuts_ = cuts;
2661  }
2663  inline bool allDynamic() const
2664  {
2665  return ((ownership_ & 0x40000000) != 0);
2666  }
2668  void generateCpp(FILE *fp, int options);
2670  OsiBranchingInformation usefulInformation() const;
2677  inline void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
2678  {
2679  bestSolutionBasis_ = bestSolutionBasis;
2680  }
2684 
2685  void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
2686  {
2687  this->mipStart_ = mipstart;
2688  }
2689 
2692  void setKeepNamesPreproc( bool _keep )
2693  {
2694  this->keepNamesPreproc = _keep;
2695  }
2696 
2697  bool getKeepNamesPreproc() const
2698  {
2699  return keepNamesPreproc;
2700  }
2701 
2704  void setMIPStart(int count, const char **colNames, const double colValues[]);
2705 
2706 
2707  const std::vector< std::pair< std::string, double > > &getMIPStart()
2708  {
2709  return this->mipStart_;
2710  }
2711 
2712  //---------------------------------------------------------------------------
2713 
2714 private:
2716 
2717 
2719  OsiSolverInterface *solver_;
2720 
2726  unsigned int ownership_;
2727 
2729  OsiSolverInterface *continuousSolver_;
2730 
2732  OsiSolverInterface *referenceSolver_;
2733 
2735  CoinMessageHandler *handler_;
2736 
2743 
2745  CoinMessages messages_;
2746 
2749 
2752 
2761  mutable CoinWarmStart *emptyWarmStart_;
2762 
2771 
2773  double *bestSolution_;
2776 
2785  mutable const double *testSolution_;
2789  std::vector< std::pair< std::string, double > > mipStart_;
2790 
2796 
2803  CoinWarmStartBasis bestSolutionBasis_;
2808 
2843  int status_;
2875  int phase_;
2876 
2879 
2892  CglPreProcess *preProcess_;
2894  const OsiRowCut **lastCut_;
2899 
2908 
2912  OsiRowCut *nextRowCut_;
2913 
2916 
3010  const double *cbcColLower_;
3012  const double *cbcColUpper_;
3014  const double *cbcRowLower_;
3016  const double *cbcRowUpper_;
3018  const double *cbcColSolution_;
3020  const double *cbcRowPrice_;
3022  const double *cbcReducedCost_;
3024  const double *cbcRowActivity_;
3026  void *appData_;
3067  // Cut generators
3069  // Cut generators before any changes
3080 #ifdef CBC_ONLY_CLP
3081  ClpEventHandler *eventHandler_;
3082 #else
3084 #endif
3089 
3100  OsiObject **object_;
3103 
3145  mutable CoinThreadRandom randomNumberGenerator_;
3147  CoinWarmStartBasis workingBasis_;
3159  CglTreeProbingInfo *probingInfo_;
3167  mutable bool eventHappened_;
3192  int strongInfo_[7];
3199  OsiBabSolver *solverCharacteristics_;
3213  CglStored *storedRowCuts_;
3237 };
3239 void getIntegerInformation(const OsiObject *object, double &originalLower,
3240  double &originalUpper);
3241 // So we can call from other programs
3242 // Real main program
3243 class OsiClpSolverInterface;
3244 int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
3245 // four ways of calling
3246 int callCbc(const char *input2, OsiClpSolverInterface &solver1);
3247 int callCbc(const char *input2);
3248 int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
3249 int callCbc(const std::string input2);
3250 // When we want to load up CbcModel with options first
3251 void CbcMain0(CbcModel &babSolver);
3252 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
3253 // two ways of calling
3254 int callCbc(const char *input2, CbcModel &babSolver);
3255 int callCbc(const std::string input2, CbcModel &babSolver);
3256 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
3257 int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3258 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3259 // For uniform setting of cut and heuristic options
3261 #endif
3262 
3263 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
3264 */
Event handling for cbc.
CBC_Message
This deals with Cbc messages (as against Clp messages etc).
Definition: CbcMessage.hpp:24
int CbcMain(int argc, const char *argv[], CbcModel &babSolver)
int CbcMain1(int argc, const char *argv[], CbcModel &babSolver)
int callCbc(const char *input2, OsiClpSolverInterface &solver1)
void setCutAndHeuristicOptions(CbcModel &model)
int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom))
void CbcMain0(CbcModel &babSolver)
void getIntegerInformation(const OsiObject *object, double &originalLower, double &originalUpper)
So we can use osiObject or CbcObject during transition.
Base model.
Definition: CbcThread.hpp:475
virtual CbcBranchDecision * clone() const =0
Clone.
OsiRowCut augmented with bookkeeping.
Interface between Cbc and Cut Generation Library.
Abstract cut modifier base class.
Base class for Cbc event handling.
CbcAction
Action codes returned by the event handler.
CbcEvent
Events known to cbc.
Information required to recreate the subproblem at this node.
Heuristic base class.
Simple Branch and bound class.
Definition: CbcModel.hpp:100
void setNumberStrongIterations(int number)
Set the number of iterations done in strong branching.
Definition: CbcModel.hpp:2572
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
Definition: CbcModel.hpp:1202
void setPointers(const OsiSolverInterface *solver)
Set pointers for speed.
void gutsOfDestructor2()
Clears out enough to reset CbcModel as if no branch and bound done.
void setCutoff(double value)
Set cutoff bound on the objective function.
int printFrequency_
Print frequency.
Definition: CbcModel.hpp:3064
void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0)
Do heuristics at root.
bool isProvenInfeasible() const
Is infeasiblity proven (or none better than cutoff)?
double continuousObjective_
Value of objective at continuous (Well actually after initial round of cuts)
Definition: CbcModel.hpp:3120
const double * cbcColLower_
Whether to automatically do presolve before branch and bound.
Definition: CbcModel.hpp:3010
const double * testSolution_
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
Definition: CbcModel.hpp:2785
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
Definition: CbcModel.hpp:1772
double getMinimumDrop() const
Get the minimum drop to continue cuts.
Definition: CbcModel.hpp:812
char * setupCleanVariables()
Sets up cleanVariables array (i.e. ones to be careful about)
void saveBestSolution(const double *solution, double objectiveValue)
Save a solution to best and move current to saved.
double penaltyScaleFactor() const
Get scale factor to make penalties match strong.
Definition: CbcModel.hpp:934
virtual ~CbcModel()
Destructor.
void setParentModel(CbcModel &parentModel)
Set the parent model.
Definition: CbcModel.hpp:1819
CbcModel * heuristicModel_
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:2993
int numberHeuristics_
Number of heuristics.
Definition: CbcModel.hpp:3072
void setProblemFeasibility(CbcFeasibilityBase &feasibility)
CoinMessages * messagesPointer()
Return pointer to messages.
Definition: CbcModel.hpp:1955
void assignSolver(OsiSolverInterface *&solver, bool deleteSolver=true)
Assign a solver to the model (model assumes ownership)
int currentDepth() const
Current depth.
Definition: CbcModel.hpp:957
@ CbcFathomDiscipline
Fathoming discipline.
Definition: CbcModel.hpp:117
@ CbcPrinting
Adjusts printout 1 does different node message with number unsatisfied on last branch.
Definition: CbcModel.hpp:121
@ CbcMaxNumSol
The maximum number of solutions before terminating.
Definition: CbcModel.hpp:107
@ CbcLastIntParam
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:126
@ CbcNumberBranches
Number of branches (may be more than number of nodes as may include strong branching)
Definition: CbcModel.hpp:124
@ CbcMaxNumNode
The maximum number of nodes before terminating.
Definition: CbcModel.hpp:105
void passInPriorities(const int *priorities, bool ifNotSimpleIntegers)
Pass in branching priorities.
CbcHeuristic ** heuristic_
Heuristic solvers.
Definition: CbcModel.hpp:3074
int moreSpecialOptions_
More special options at present bottom 6 bits used for shadow price mode 1024 for experimental hotsta...
Definition: CbcModel.hpp:2967
void setResolveAfterTakeOffCuts(bool yesNo)
Definition: CbcModel.hpp:1581
CbcHeuristic * lastHeuristic_
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:3076
CoinWarmStartBasis workingBasis_
Work basis for temporary use.
Definition: CbcModel.hpp:3147
bool tightenVubs(int type, bool allowMultipleBinary=false, double useCutoff=1.0e50)
For variables involved in VUB constraints, see if we can tighten bounds by solving lp's.
unsigned int ownership_
Ownership of objects and other stuff.
Definition: CbcModel.hpp:2726
int continuousInfeasibilities_
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:3125
bool tightenVubs(int numberVubs, const int *which, double useCutoff=1.0e50)
For variables involved in VUB constraints, see if we can tighten bounds by solving lp's.
bool ownObjects_
Now we may not own objects - just point to solver's objects.
Definition: CbcModel.hpp:3102
double penaltyScaleFactor_
Scale factor to make penalties match strong.
Definition: CbcModel.hpp:3047
double getInfinity() const
Get solver's value for infinity.
Definition: CbcModel.hpp:1278
int numberPenalties_
The number of variables for which to compute penalties in dynamic strong branching.
Definition: CbcModel.hpp:3042
void setMultipleRootTries(int value)
Set multiple root tries.
Definition: CbcModel.hpp:2034
int * integerVariable_
Indices of integer variables.
Definition: CbcModel.hpp:2918
double * currentSolution() const
Solution to the most recent lp relaxation.
Definition: CbcModel.hpp:1375
void createContinuousSolver()
Create solver with continuous state.
Definition: CbcModel.hpp:2236
void setOptionalInteger(int index)
int secondaryStatus() const
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
Definition: CbcModel.hpp:1076
int numberPenalties() const
get the number of variables for which to compute penalties in dynamic strong branching.
Definition: CbcModel.hpp:914
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
Definition: CbcModel.hpp:1767
double getContinuousObjective() const
Value of objective at continuous.
Definition: CbcModel.hpp:1539
OsiBabSolver * solverCharacteristics_
For advanced applications you may wish to modify the behavior of Cbc e.g.
Definition: CbcModel.hpp:3199
double * bestSolution() const
The best solution to the integer programming problem.
Definition: CbcModel.hpp:1467
double getInfeasibilityWeight() const
Get the weight per integer infeasibility .
Definition: CbcModel.hpp:704
const double * cbcReducedCost_
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:3022
int numberBeforeTrust() const
get the number of branches before pseudo costs believed in dynamic strong branching.
Definition: CbcModel.hpp:902
int getNumberThreads() const
Get number of threads.
Definition: CbcModel.hpp:2296
void incrementSubTreeStopped()
Says a sub tree was stopped.
Definition: CbcModel.hpp:1663
virtual CbcModel * clone(bool cloneHandler)
Clone.
void setMoreSpecialOptions(int value)
Set more special options at present bottom 6 bits used for shadow price mode 1024 for experimental ho...
Definition: CbcModel.hpp:2084
const int * integerVariable() const
Definition: CbcModel.hpp:1138
int maximumStatistics_
Maximum number of statistics.
Definition: CbcModel.hpp:3151
int getCurrentPassNumber() const
Get current cut pass number in this round of cuts.
Definition: CbcModel.hpp:842
int getNodeCount2() const
Get how many Nodes it took to solve the problem.
Definition: CbcModel.hpp:2389
bool allDynamic() const
Says whether all dynamic integers.
Definition: CbcModel.hpp:2663
CoinWarmStart * emptyWarmStart_
Pointer to an empty warm start object.
Definition: CbcModel.hpp:2761
void setNodeComparison(CbcCompareBase *compare)
int logLevel() const
Get log level.
Definition: CbcModel.hpp:1962
int phase() const
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:1515
void setNumberObjects(int number)
Set the number of objects.
Definition: CbcModel.hpp:498
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
Definition: CbcModel.hpp:1690
int numberStrongIterations_
Number of iterations in strong branching.
Definition: CbcModel.hpp:3189
int lastDepth_
Definition: CbcModel.hpp:2895
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
CbcFeasibilityBase * problemFeasibility_
User feasibility function (see CbcFeasibleBase.hpp)
Definition: CbcModel.hpp:2985
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:1732
int moreSpecialOptions2_
More more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective until...
Definition: CbcModel.hpp:2981
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: CbcModel.hpp:1532
const OsiSolverInterface * postProcessedSolver(int solutionType=1)
Returns postProcessed solution in solver(called from event handler) Normally used for integer solutio...
CbcFeasibilityBase * problemFeasibility() const
Definition: CbcModel.hpp:1631
OsiSolverInterface * solver() const
Returns solver - has current state.
Definition: CbcModel.hpp:2216
bool setHeuristicFractionGap(double value)
Set the fraction heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:770
void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const
Set objective value in a node.
@ CbcInfeasibilityWeight
The objective is assumed to worsen by this amount for each integer infeasibility.
Definition: CbcModel.hpp:135
@ CbcIntegerTolerance
The maximum amount the value of an integer variable can vary from integer and still be considered fea...
Definition: CbcModel.hpp:132
@ CbcAllowableGap
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
Definition: CbcModel.hpp:145
@ CbcSumChange
Sum of non-zero changes on a branch.
Definition: CbcModel.hpp:186
@ CbcHeuristicFractionGap
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
Definition: CbcModel.hpp:182
@ CbcHeuristicGap
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
Definition: CbcModel.hpp:174
@ CbcStartSeconds
The time at start of model.
Definition: CbcModel.hpp:166
@ CbcCutoffIncrement
The amount by which to tighten the objective function cutoff when a new solution is discovered.
Definition: CbcModel.hpp:138
@ CbcSmallChange
Small non-zero change on a branch to be used as guess.
Definition: CbcModel.hpp:190
@ CbcCurrentObjectiveValue
Current objective value.
Definition: CbcModel.hpp:161
@ CbcAllowableFractionGap
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
Definition: CbcModel.hpp:152
@ CbcOptimizationDirection
Optimization direction - stored for speed.
Definition: CbcModel.hpp:159
@ CbcLargestChange
Largest non-zero change on a branch.
Definition: CbcModel.hpp:188
@ CbcSmallestChange
Smallest non-zero change on a branch.
Definition: CbcModel.hpp:184
@ CbcCurrentCutoff
Cutoff - stored for speed.
Definition: CbcModel.hpp:157
@ CbcCurrentMinimizationObjectiveValue
Current minimization objective value.
Definition: CbcModel.hpp:163
@ CbcMaximumSeconds
The maximum number of seconds before terminating.
Definition: CbcModel.hpp:155
@ CbcLastDblParam
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:192
const double * cbcRowPrice_
Pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:3020
int numberNodes2_
Cumulative number of nodes for statistics.
Definition: CbcModel.hpp:2837
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
Definition: CbcModel.hpp:1189
int maximumWhich_
Maximum number of cuts (for whichGenerator_)
Definition: CbcModel.hpp:3135
int lastNumberCuts2_
Definition: CbcModel.hpp:2896
void * getApplicationData() const
Get application data.
void setNumberPenalties(int number)
Set the number of variables for which to compute penalties in dynamic strong branching.
void addSOSEtcToSolver()
Add SOS info to solver - Overwrites SOS information in solver with information in CbcModel.
void setProblemFeasibility(CbcFeasibilityBase *feasibility)
int numberUpdateItems_
Number of outstanding update information items.
Definition: CbcModel.hpp:3207
OsiSolverInterface * solver_
The solver associated with this model.
Definition: CbcModel.hpp:2719
CbcNodeInfo ** walkback() const
Get pointer to walkback.
Definition: CbcModel.hpp:2291
CbcThread * masterThread_
Pointer to masterthread.
Definition: CbcModel.hpp:3235
void zapGlobalCuts()
Get rid of global cuts.
Definition: CbcModel.hpp:2548
int numberHeuristicSolutions_
Number of heuristic solutions.
Definition: CbcModel.hpp:2831
OsiSolverInterface * continuousSolver_
A copy of the solver, taken at the continuous (root) node.
Definition: CbcModel.hpp:2729
OsiRowCut * nextRowCut_
A pointer to a row cut which will be added instead of normal branching.
Definition: CbcModel.hpp:2912
int fastNodeDepth() const
Get depth for fast nodes.
Definition: CbcModel.hpp:2606
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
int numberExtraNodes_
Number of extra nodes in fast lp.
Definition: CbcModel.hpp:3114
void makeGlobalCuts()
Make partial cuts into global cuts.
void newLanguage(CoinMessages::Language language)
Set language.
int currentNumberCuts() const
Number of entries in the list returned by addedCuts()
Definition: CbcModel.hpp:2538
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1611
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
Definition: CbcModel.hpp:1710
CbcFullNodeInfo * topOfTree_
Pointer to top of tree.
Definition: CbcModel.hpp:2989
CbcObjectUpdateData * updateItems_
Update items.
Definition: CbcModel.hpp:3211
CoinBigIndex getNumElements() const
Get number of nonzero elements.
Definition: CbcModel.hpp:1127
void checkModel()
Check original model before it gets messed up.
const char * integerType() const
Whether or not integer.
Definition: CbcModel.hpp:1150
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
Definition: CbcModel.hpp:2319
void incrementUsed(const double *solution)
Increases usedInSolution for nonzeros.
bool waitingForMiniBranchAndBound() const
Says if model is sitting there waiting for mini branch and bound to finish This is because an event h...
Definition: CbcModel.hpp:2057
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
Definition: CbcModel.hpp:2567
double bestObjective_
Best objective.
Definition: CbcModel.hpp:2764
int stateOfSearch_
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:2823
static bool haveMultiThreadSupport()
Indicates whether Cbc library has been compiled with multithreading support.
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
Definition: CbcModel.hpp:1382
bool getKeepNamesPreproc() const
Definition: CbcModel.hpp:2697
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2582
bool canStopOnGap() const
See if can stop on gap.
double * hotstartSolution_
Hotstart solution.
Definition: CbcModel.hpp:2827
int maximumSavedSolutions_
Maximum number of saved solutions.
Definition: CbcModel.hpp:2816
int numberSavedSolutions_
Number of saved solutions.
Definition: CbcModel.hpp:2814
int numberIntegers_
Number of integers in problem.
Definition: CbcModel.hpp:2856
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
int stopNumberIterations_
For threads - stop after this many "iterations".
Definition: CbcModel.hpp:3044
CbcModel * parentModel() const
Get the current parent model.
Definition: CbcModel.hpp:1814
void setPreProcess(CglPreProcess *preProcess)
Set CglPreProcess used before branch and bound.
Definition: CbcModel.hpp:327
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
Definition: CbcModel.hpp:1591
bool normalSolver() const
Says if normal solver i.e. has well defined CoinPackedMatrix.
Definition: CbcModel.hpp:2049
int howOftenGlobalScan_
How often to scan global cuts.
Definition: CbcModel.hpp:3107
int cutoffRowNumber_
-1 - cutoff as constraint not activated -2 - waiting to activate >=0 - activated
Definition: CbcModel.hpp:2864
CbcThread * masterThread() const
Get pointer to masterthread.
Definition: CbcModel.hpp:2286
void startSplitModel(int numberIterations)
Start threads.
void setPreferredWay(int value)
Set global preferred way to branch -1 down, +1 up, 0 no preference.
Definition: CbcModel.hpp:868
bool isSolutionLimitReached() const
Solution limit reached?
void setStrategy(CbcStrategy &strategy)
Set the strategy. Clones.
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:1288
CbcNode * currentNode_
Current node so can be used elsewhere.
Definition: CbcModel.hpp:2915
char integerType(int i) const
Whether or not integer.
Definition: CbcModel.hpp:1143
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
Definition: CbcModel.hpp:1266
void setNextRowCut(const OsiRowCut &cut)
Copy and set a pointer to a row cut which will be added instead of normal branching.
void setSearchStrategy(int value)
Set strategy worked out - mainly at root node for use by CbcNode.
Definition: CbcModel.hpp:1746
int getMultipleRootTries() const
Get multiple root tries.
Definition: CbcModel.hpp:2039
int numberGlobalCutsIn_
Number of global cuts on entry to a node.
Definition: CbcModel.hpp:3231
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
Definition: CbcModel.hpp:919
const OsiObject * object(int which) const
Get the specified object.
Definition: CbcModel.hpp:510
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:793
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
Definition: CbcModel.hpp:1557
CoinMessageHandler * handler_
Message handler.
Definition: CbcModel.hpp:2735
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
Definition: CbcModel.hpp:579
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:1849
CbcModel * findCliques(bool makeEquality, int atLeastThisMany, int lessThanThis, int defaultValue=1000)
Identify cliques and construct corresponding objects.
CglTreeProbingInfo * probingInfo_
Probing info.
Definition: CbcModel.hpp:3159
int numberSavedSolutions() const
Number of saved solutions (including best)
int numberInfeasibleNodes_
Number of nodes infeasible by normal branching (before cuts)
Definition: CbcModel.hpp:3055
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2658
int doOneNode(CbcModel *baseModel, CbcNode *&node, CbcNode *&newNode)
Do one node - broken out for clarity? also for parallel (when baseModel!=this) Returns 1 if solution ...
void clearNumberGlobalViolations()
Definition: CbcModel.hpp:1572
void AddIntegers()
Add additional integers.
double * continuousSolution_
Holds solution at continuous (after cuts)
Definition: CbcModel.hpp:2922
int maximumRows() const
Maximum number of rows.
Definition: CbcModel.hpp:1586
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
Definition: CbcModel.hpp:1880
double dblParam_[CbcLastDblParam]
Array for double parameters.
Definition: CbcModel.hpp:2751
int * whichGenerator_
Which cut generator generated this cut.
Definition: CbcModel.hpp:3149
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
int maximumDepth_
Current limit on search tree depth.
Definition: CbcModel.hpp:2884
void setNumberAnalyzeIterations(int number)
Number of analyze iterations to do.
Definition: CbcModel.hpp:924
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
Definition: CbcModel.hpp:1521
int fastNodeDepth_
Depth for fast nodes.
Definition: CbcModel.hpp:3078
int preferredWay_
Preferred way of branching.
Definition: CbcModel.hpp:3131
void setMIPStart(int count, const char **colNames, const double colValues[])
may be safer to use this overload method: c++ string libraries implementation may not be binary compa...
int secondaryStatus_
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
Definition: CbcModel.hpp:2854
int status() const
Final status of problem Some of these can be found out by is......
Definition: CbcModel.hpp:1056
void synchronizeHandlers(int makeDefault)
Makes all handlers same.
bool isInitialSolveAbandoned() const
Are there numerical difficulties (for initialSolve) ?
bool resolveAfterTakeOffCuts_
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:3201
void setInfoInChild(int type, CbcThread *info)
Set information in a child -3 pass pointer to child thread info -2 just stop -1 delete simple child s...
void setBestObjectiveValue(double objectiveValue)
Just update objectiveValue.
int currentDepth_
Current depth.
Definition: CbcModel.hpp:3143
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
Definition: CbcModel.hpp:1487
CbcEventHandler * eventHandler_
Pointer to the event handler.
Definition: CbcModel.hpp:3083
int * lastNumberCuts_
Definition: CbcModel.hpp:2898
CbcRowCuts globalCuts_
Global cuts.
Definition: CbcModel.hpp:2805
bool keepNamesPreproc
keepNamesPreproc if variables names will be preserved in the pre-processed problem (usefull in callba...
Definition: CbcModel.hpp:2795
void makeGlobalCuts(int numberRows, const int *which)
Make given rows (L or G) into global cuts and remove from lp.
double bestPossibleObjective_
Best possible objective.
Definition: CbcModel.hpp:2766
bool setInfeasibilityWeight(double value)
Set the weight per integer infeasibility .
Definition: CbcModel.hpp:696
void setSpecialOptions(int value)
Set special options 0 bit (1) - check if cuts valid (if on debugger list) 1 bit (2) - use current bas...
Definition: CbcModel.hpp:2014
void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver=NULL)
Make partial cut into a global cut and save.
bool setMaximumSolutions(int value)
Set the maximum number of solutions desired.
Definition: CbcModel.hpp:631
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
Definition: CbcModel.hpp:1926
bool doCutsNow(int allowForTopOfTree) const
Return true if we want to do cuts If allowForTopOfTree zero then just does on multiples of depth if 1...
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:970
int numberOldActiveCuts_
Number of old active cuts.
Definition: CbcModel.hpp:3171
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
int numberIterations_
Cumulative number of iterations.
Definition: CbcModel.hpp:2839
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
Definition: CbcModel.hpp:1526
int maximumNumberIterations_
Maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:3203
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
Definition: CbcModel.hpp:1327
const OsiRowCut ** lastCut_
Definition: CbcModel.hpp:2894
void setMaximumCutPasses(int value)
Set the maximum number of cut passes at other nodes (default 10) Minimum drop can also be used for fi...
Definition: CbcModel.hpp:831
int threadMode_
thread mode always use numberThreads for branching 1 set then deterministic 2 set then use numberThre...
Definition: CbcModel.hpp:3229
int numberGlobalViolations_
Number of times global cuts violated.
Definition: CbcModel.hpp:3110
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
int numberThreads_
Parallel 0 - off 1 - testing 2-99 threads other special meanings.
Definition: CbcModel.hpp:3221
const double * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:1298
bool isContinuousUnbounded() const
Was continuous solution unbounded.
void zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
void setNumberThreads(int value)
Set number of threads.
Definition: CbcModel.hpp:2301
void setProblemType(int number)
Problem type as set by user or found by analysis.
Definition: CbcModel.hpp:948
bool isInteger(int colIndex) const
Return true if column is integer.
Definition: CbcModel.hpp:1248
void addCutGenerator(CglCutGenerator *generator, int howOften=1, const char *name=NULL, bool normal=true, bool atSolution=false, bool infeasible=false, int howOftenInSub=-100, int whatDepth=-1, int whatDepthInSub=-1)
Add one generator - up to user to delete generators.
int status_
Status of problem - 0 finished, 1 stopped, 2 difficulties.
Definition: CbcModel.hpp:2843
std::vector< std::pair< std::string, double > > mipStart_
MIPstart values values for integer variables which will be converted to a complete integer initial fe...
Definition: CbcModel.hpp:2789
double getAllowableGap() const
Get the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:719
bool isInitialSolveProvenOptimal() const
Is optimality proven (for initialSolve) ?
int numberNewCuts_
Number of new cuts.
Definition: CbcModel.hpp:3173
double sumChangeObjective1_
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:2768
void passInSolverCharacteristics(OsiBabSolver *solverCharacteristics)
For advanced applications you may wish to modify the behavior of Cbc e.g.
void addObjects(int numberObjects, CbcObject **objects)
Add in object information.
void setFastNodeDepth(int value)
Set depth for fast nodes.
Definition: CbcModel.hpp:2601
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
Definition: CbcModel.hpp:1412
double getAllowableFractionGap() const
Get the fraction allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:734
double minimumDrop_
Minimum degradation in objective value to continue cut generation.
Definition: CbcModel.hpp:2810
int * mutableStrongInfo()
Return mutable strong info.
Definition: CbcModel.hpp:2648
CbcRowCuts * globalCuts()
Global cuts.
Definition: CbcModel.hpp:2543
int maximumCutPasses_
Maximum number of cut passes.
Definition: CbcModel.hpp:3129
CbcCompareBase * nodeComparison() const
Definition: CbcModel.hpp:1620
double getMinimizationObjValue() const
Get best objective function value as minimization.
Definition: CbcModel.hpp:1429
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
Definition: CbcModel.hpp:1423
CbcStrategy * strategy_
Strategy.
Definition: CbcModel.hpp:3001
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
Definition: CbcModel.hpp:1971
void makeGlobalCut(const OsiColCut *cut)
Make given column cut into a global cut.
int getThreadMode() const
Get thread mode.
Definition: CbcModel.hpp:2306
CoinThreadRandom randomNumberGenerator_
Thread specific random number generator.
Definition: CbcModel.hpp:3145
bool isBinary(int colIndex) const
Return true if variable is binary.
Definition: CbcModel.hpp:1239
bool isProvenOptimal() const
Is optimality proven?
int getExtraNodeCount() const
Get how many Nodes were enumerated in complete fathoming B&B inside CLP.
Definition: CbcModel.hpp:1038
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
Definition: CbcModel.hpp:1394
int numberObjects_
Total number of objects.
Definition: CbcModel.hpp:3088
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:785
void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
Definition: CbcModel.hpp:2685
OsiSolverInterface * swapSolver(OsiSolverInterface *solver)
Returns current solver - sets new one.
Definition: CbcModel.hpp:2222
void resetModel()
Clears out enough to reset CbcModel cutoff etc.
int getNodeCount() const
Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP...
Definition: CbcModel.hpp:1028
void setMaximumCutPassesAtRoot(int value)
Set the maximum number of cut passes at root node (default 20) Minimum drop can also be used for fine...
Definition: CbcModel.hpp:819
double getAllowablePercentageGap() const
Get the percentage allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:748
CbcBaseModel * master() const
Thread stuff for master.
Definition: CbcModel.hpp:2345
int numberLongStrong_
Number of long strong goes.
Definition: CbcModel.hpp:3169
void deleteNode(CbcNode *node)
Delete a node and possibly null out currentNode_.
void setCutModifier(CbcCutModifier &modifier)
Set the cut modifier method.
int printFrequency() const
Get the print frequency.
Definition: CbcModel.hpp:992
CbcCountRowCut ** addedCuts_
The list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2907
bool setAllowablePercentageGap(double value)
Set the percentage allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:741
CbcModel * subTreeModel_
A pointer to model to be used for subtrees.
Definition: CbcModel.hpp:2991
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1606
OsiSolverInterface * referenceSolver_
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2732
void incrementStrongInfo(int numberTimes, int numberIterations, int numberFixed, bool ifInfeasible)
Increment strong info.
int serialCuts(OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts)
Generate one round of cuts - serial mode returns - 0 - normal 1 - must keep going 2 - set numberTries...
bool setPrintingMode(int value)
Set the printing mode.
Definition: CbcModel.hpp:644
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
double savedSolutionObjective(int which) const
Return a saved solution objective (0==best) - COIN_DBL_MAX if off end.
void findIntegers(bool startAgain, int type=0)
Identify integer variables and create corresponding objects.
int numberFixedAtRoot_
Number of fixed by analyze at root.
Definition: CbcModel.hpp:3161
int problemType_
Problem type as set by user or found by analysis.
Definition: CbcModel.hpp:3062
CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, double objValue, const double *solution)
Deals with event handler and solution.
const int * hotstartPriorities() const
Get the hotstart priorities.
Definition: CbcModel.hpp:2527
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
Definition: CbcModel.hpp:1695
bool isSecondsLimitReached() const
Time limit reached?
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
Definition: CbcModel.hpp:1254
void setSecondaryStatus(int value)
Definition: CbcModel.hpp:1080
int moreSpecialOptions2() const
Get more special options2.
Definition: CbcModel.hpp:2113
double ** savedSolutions_
Arrays holding other solutions.
Definition: CbcModel.hpp:2775
int numberIntegers() const
Number of integers in problem.
Definition: CbcModel.hpp:1133
const double * cbcColUpper_
Pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:3012
int numberSolutions_
Number of solutions.
Definition: CbcModel.hpp:2812
double getHeuristicFractionGap() const
Get the fraction heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:777
int multipleRootTries_
Multiple root tries.
Definition: CbcModel.hpp:3141
const double * savedSolution(int which) const
Return a saved solution (0==best) - NULL if off end.
CoinMessages & messages()
Return messages.
Definition: CbcModel.hpp:1950
void setWhenCuts(int value)
Set at which depths to do cuts.
Definition: CbcModel.hpp:883
CbcStatistics ** statistics_
statistics
Definition: CbcModel.hpp:3153
bool setDblParam(CbcDblParam key, double value)
Set a double parameter.
Definition: CbcModel.hpp:585
CbcModel(const OsiSolverInterface &)
Constructor from solver.
double getMaximumSeconds() const
Get the maximum number of seconds desired.
Definition: CbcModel.hpp:667
void setCutModifier(CbcCutModifier *modifier)
Set the cut modifier method.
int numberRowsAtContinuous_
Number of rows at continuous.
Definition: CbcModel.hpp:2858
bool setHeuristicGap(double value)
Set the heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:755
int howOftenGlobalScan() const
Get how often to scan global cuts.
Definition: CbcModel.hpp:965
bool feasibleSolution(int &numberIntegerInfeasibilities, int &numberObjectInfeasibilities) const
Test the current solution for feasiblility.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
Definition: CbcModel.hpp:1156
double * analyzeResults_
Arrays with analysis results.
Definition: CbcModel.hpp:3051
CbcRowCuts * globalConflictCuts_
Global conflict cuts.
Definition: CbcModel.hpp:2807
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
Definition: CbcModel.hpp:1406
void * temporaryPointer_
Useful temporary pointer.
Definition: CbcModel.hpp:3053
bool isNodeLimitReached() const
Node limit reached?
void moveToModel(CbcModel *baseModel, int mode)
Move/copy information from one model to another -1 - initialization 0 - from base model 1 - to base m...
int makeGlobalCut(const OsiRowCut *cut)
Make given cut into a global cut.
int maximumRows_
Maximum number of rows.
Definition: CbcModel.hpp:3137
void setTestSolution(const double *solution)
Definition: CbcModel.hpp:1386
CbcTree * tree_
Tree.
Definition: CbcModel.hpp:2987
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
Definition: CbcModel.hpp:1777
void flipModel()
Flip direction of optimization on all models.
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
Definition: CbcModel.hpp:2186
const double * hotstartSolution() const
Get the hotstart solution.
Definition: CbcModel.hpp:2522
int maximumNumberCuts_
Maximum number of cuts.
Definition: CbcModel.hpp:2866
int numberObjects() const
Get the number of objects.
Definition: CbcModel.hpp:493
const std::vector< std::pair< std::string, double > > & getMIPStart()
Definition: CbcModel.hpp:2707
void setBestSolution(const double *solution, int numberColumns, double objectiveValue, bool check=false)
User callable setBestSolution.
void incrementExtra(int nodes, int iterations, int fathoms=1)
Definition: CbcModel.hpp:2620
int getMaximumCutPasses() const
Get the maximum number of cut passes at other nodes (default 10)
Definition: CbcModel.hpp:836
void setMaximumNumberIterations(int value)
Set maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2587
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Definition: CbcModel.hpp:1220
CbcNodeInfo ** lastNodeInfo_
Definition: CbcModel.hpp:2893
void passInTreeHandler(CbcTree &tree)
For modifying tree handling (original is cloned)
int getRandomSeed() const
Get random seed.
Definition: CbcModel.hpp:2029
int maximumCuts_
Definition: CbcModel.hpp:2897
bool isContinuous(int colIndex) const
Return true if variable is continuous.
Definition: CbcModel.hpp:1233
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
char * integerInfo_
Whether of not integer.
Definition: CbcModel.hpp:2920
void incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1023
double getCurrentSeconds() const
Current time since start of branchAndbound.
int getSolutionCount() const
Get number of solutions.
Definition: CbcModel.hpp:1481
bool isInitialSolveProvenDualInfeasible() const
Is dual infeasiblity proven (for initialSolve) ?
bool isInitialSolveProvenPrimalInfeasible() const
Is primal infeasiblity proven (for initialSolve) ?
void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn, double &lower, double &upper, int force)
Returns bounds just before where - initially original bounds.
int getNumCols() const
Get number of columns.
Definition: CbcModel.hpp:1115
int numberFixedNow_
Number fixed by analyze so far.
Definition: CbcModel.hpp:3163
double sumChangeObjective() const
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:1562
CbcCompareBase * nodeCompare_
User node comparison function.
Definition: CbcModel.hpp:2983
void * temporaryPointer() const
Get useful temporary pointer.
Definition: CbcModel.hpp:2136
bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws)
Traverse the tree from node to root and prep the model.
OsiBranchingInformation usefulInformation() const
Generate an OsiBranchingInformation object.
bool setAllowableGap(double value)
Set the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:712
int numberStrong() const
Get the maximum number of candidates to be evaluated for strong branching.
Definition: CbcModel.hpp:862
bool defaultHandler() const
Check default handler.
Definition: CbcModel.hpp:1976
void makeGlobalCut(const OsiColCut &cut)
Make given column cut into a global cut.
void setMaximumSavedSolutions(int value)
Set maximum number of extra saved solutions.
int getIntParam(CbcIntParam key) const
Get an integer parameter.
Definition: CbcModel.hpp:591
void setStopNumberIterations(int value)
Set number of "iterations" to stop after.
Definition: CbcModel.hpp:1601
CbcNode * currentNode() const
Get a pointer to current node (be careful)
Definition: CbcModel.hpp:2555
int whenCuts() const
Get at which depths to do cuts.
Definition: CbcModel.hpp:878
OsiRowCut * conflictCut(const OsiSolverInterface *solver, bool &localCuts)
Create conflict cut (well - most of)
void incrementNodeCount(int value)
Increment how many nodes it took to solve the problem.
Definition: CbcModel.hpp:1033
int getPreferredWay() const
Get the preferred way to branch (default 0)
Definition: CbcModel.hpp:873
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
Definition: CbcModel.hpp:1162
int getFathomCount() const
Get how many times complete fathoming B&B was done.
Definition: CbcModel.hpp:1043
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:1577
void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible)
Save copy of the model.
void setCurrentPassNumber(int value)
Set current cut pass number in this round of cuts.
Definition: CbcModel.hpp:848
int moreSpecialOptions() const
Get more special options.
Definition: CbcModel.hpp:2089
void redoWalkBack()
Redo walkback arrays.
int randomSeed_
Random seed.
Definition: CbcModel.hpp:3139
int numberNodes_
Cumulative number of nodes.
Definition: CbcModel.hpp:2833
bool isAbandoned() const
Are there a numerical difficulties?
int * originalColumns_
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:3105
void setObjValue(double value)
Set best objective function value.
Definition: CbcModel.hpp:1451
int resolve(OsiSolverInterface *solver)
Encapsulates solver resolve.
void addObjects(int numberObjects, OsiObject **objects)
Add in object information.
void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2677
int getStopNumberIterations() const
Get number of "iterations" to stop after.
Definition: CbcModel.hpp:1596
int getMaximumNodes() const
Get the maximum node limit .
Definition: CbcModel.hpp:622
int numberStrong_
Maximum number of candidates to consider for strong branching.
Definition: CbcModel.hpp:3032
bool setAllowableFractionGap(double value)
Set the fraction allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:727
void addHeuristic(CbcHeuristic *generator, const char *name=NULL, int before=-1)
Add one heuristic - up to user to delete.
void originalModel(CbcModel *presolvedModel, bool weak)
Put back information into the original model after integer presolve.
int numberBeforeTrust_
The number of branches before pseudo costs believed in dynamic strong branching.
Definition: CbcModel.hpp:3038
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
Definition: CbcModel.hpp:1260
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
Definition: CbcModel.hpp:824
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2248
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:1318
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
Definition: CbcModel.hpp:1335
int currentNumberCuts_
Number of entries in addedCuts_.
Definition: CbcModel.hpp:2878
void resizeWhichGenerator(int numberNow, int numberAfter)
Update size of whichGenerator.
void setNumberStrong(int number)
Set the maximum number of candidates to be evaluated for strong branching.
void setLastHeuristic(CbcHeuristic *last)
set last heuristic which found a solution
Definition: CbcModel.hpp:1854
void setProblemStatus(int value)
Definition: CbcModel.hpp:1060
int * hotstartPriorities_
Hotstart priorities.
Definition: CbcModel.hpp:2829
CglStored * storedRowCuts_
Stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:3213
const double * cbcColSolution_
Pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:3018
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
int specialOptions() const
Get special options.
Definition: CbcModel.hpp:2019
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: CbcModel.hpp:1214
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:1308
int whenCuts_
At which depths to do cuts.
Definition: CbcModel.hpp:2825
void setNumberHeuristics(int value)
Set the number of heuristics.
Definition: CbcModel.hpp:1844
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
bool isLocked() const
From here to end of section - code in CbcThread.cpp until class changed Returns true if locked.
int numberGlobalViolations() const
Number of times global cuts violated.
Definition: CbcModel.hpp:1568
void * appData_
Pointer to user-defined data structure.
Definition: CbcModel.hpp:3026
int numberExtraIterations_
Number of extra iterations in fast lp.
Definition: CbcModel.hpp:3112
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:1313
const double * cbcRowUpper_
Pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:3016
int takeOffCuts(OsiCuts &cuts, bool allowResolve, OsiCuts *saveCuts, int numberNewCuts=0, const OsiRowCut **newCuts=NULL)
Remove inactive cuts from the model.
void synchronizeModel()
Ensure attached objects point to this model.
int strongStrategy() const
Stong branching strategy.
Definition: CbcModel.hpp:1751
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
Definition: CbcModel.hpp:2230
double getDblParam(CbcDblParam key) const
Get a double parameter.
Definition: CbcModel.hpp:596
void convertToDynamic()
If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
Definition: CbcModel.hpp:608
double sumChangeObjective2_
Sum of Changes to objective by subsequent solves.
Definition: CbcModel.hpp:2770
bool setIntegerTolerance(double value)
Set the integrality tolerance .
Definition: CbcModel.hpp:680
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
Definition: CbcModel.hpp:1109
CbcModel(const CbcModel &rhs, bool cloneHandler=false)
Copy constructor .
virtual double checkSolution(double cutoff, double *solution, int fixVariables, double originalObjValue)
Call this to really test if a valid solution can be feasible Solution is number columns in size.
int continuousPriority_
Anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:3205
int parallelCuts(CbcBaseModel *master, OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts)
Generate one round of cuts - parallel mode returns - 0 - normal 1 - must keep going 2 - set numberTri...
int numberCutGenerators() const
Get the number of cut generators.
Definition: CbcModel.hpp:1762
bool setMaximumNodes(int value)
Set the maximum node limit .
Definition: CbcModel.hpp:616
int splitModel(int numberModels, CbcModel **model, int numberNodes)
Split up nodes.
int numberExtraIterations() const
Number of extra iterations.
Definition: CbcModel.hpp:2634
bool stoppedOnGap_
Whether stopping on gap.
Definition: CbcModel.hpp:3165
int getPrintingMode() const
Get the printing mode.
Definition: CbcModel.hpp:650
int getMaximumSolutions() const
Get the maximum number of solutions desired.
Definition: CbcModel.hpp:639
bool setMaximumSeconds(double value)
Set the maximum number of seconds desired.
Definition: CbcModel.hpp:659
double * currentSolution_
Array holding the current solution.
Definition: CbcModel.hpp:2781
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
Definition: CbcModel.hpp:1226
int maximumDepthActual_
Maximum depth reached.
Definition: CbcModel.hpp:3155
void setLanguage(CoinMessages::Language language)
Definition: CbcModel.hpp:1940
void branchAndBound(int doStatistics=0)
Invoke the branch & cut algorithm.
void setBestSolution(CBC_Message how, double &objectiveValue, const double *solution, int fixVariables=0)
Record a new incumbent solution and update objectiveValue.
int getContinuousInfeasibilities() const
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:1548
void setMinimumDrop(double value)
Set the minimum drop to continue cuts.
Definition: CbcModel.hpp:807
void deleteSolutions()
Delete best and saved solutions.
int numberAnalyzeIterations_
Number of analyze iterations to do.
Definition: CbcModel.hpp:3049
void setMoreSpecialOptions2(int value)
Set more more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective u...
Definition: CbcModel.hpp:2108
CbcModel()
Default Constructor.
void moveInfo(const CbcModel &rhs)
Move status, nodes etc etc across.
double getBestPossibleObjValue() const
Get best possible objective function value.
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
Definition: CbcModel.hpp:1642
void sayEventHappened()
Tell model to stop on event.
Definition: CbcModel.hpp:2044
int strongStrategy_
Strategy for strong branching 0 - normal when to do all fractional 1 - root node 2 - depth less than ...
Definition: CbcModel.hpp:3187
void setNumberBeforeTrust(int number)
Set the number of branches before pseudo costs believed in dynamic strong branching.
bool maximumSecondsReached() const
Return true if maximum time reached.
int typePresolve() const
Whether to automatically do presolve before branch and bound (subTrees).
Definition: CbcModel.hpp:1672
bool modelOwnsSolver()
Get ownership of solver.
Definition: CbcModel.hpp:2196
void zeroExtra()
Zero extra.
Definition: CbcModel.hpp:2627
void clearContinuousSolver()
Clear solver with continuous state.
Definition: CbcModel.hpp:2241
OsiObject * modifiableObject(int which) const
Get the specified object.
Definition: CbcModel.hpp:515
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
int numberFathoms_
Number of times fast lp entered.
Definition: CbcModel.hpp:3116
void lockThread()
Locks a thread if parallel so that stuff like cut pool can be updated and/or used.
int specialOptions_
Special options 0 bit (1) - check if cuts valid (if on debugger list) 1 bit (2) - use current basis t...
Definition: CbcModel.hpp:2952
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: CbcModel.hpp:1208
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
void setContinuousInfeasibilities(int value)
Definition: CbcModel.hpp:1552
CglPreProcess * preProcess_
preProcess used before branch and bound (optional)
Definition: CbcModel.hpp:2892
void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod)
Go to dantzig pivot selection if easy problem (clp only)
const double * cbcRowActivity_
Pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:3024
CbcCutModifier * cutModifier_
Cut modifier function.
Definition: CbcModel.hpp:2999
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2611
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
Definition: CbcModel.hpp:1741
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:1303
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:1293
const int * strongInfo() const
Return strong info.
Definition: CbcModel.hpp:2642
bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node)
Evaluate a subproblem using cutting planes and heuristics.
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
Definition: CbcModel.hpp:2329
int maximumNumberUpdateItems_
Maximum number of outstanding update information items.
Definition: CbcModel.hpp:3209
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2616
bool isProvenDualInfeasible() const
Was continuous solution unbounded.
double getHeuristicGap() const
Get the heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:762
bool ownObjects() const
Now we may not own objects - just point to solver's objects.
Definition: CbcModel.hpp:2148
int getNumRows() const
Get number of rows.
Definition: CbcModel.hpp:1121
double originalContinuousObjective_
Value of objective before root node cuts added.
Definition: CbcModel.hpp:3123
void initialSolve()
Solve the initial LP relaxation.
int problemType() const
Definition: CbcModel.hpp:952
double getObjValue() const
Get best objective function value.
Definition: CbcModel.hpp:1440
int numberSolves_
Cumulative number of solves.
Definition: CbcModel.hpp:2841
CglPreProcess * preProcess() const
Returns CglPreProcess used before branch and bound.
Definition: CbcModel.hpp:322
void setMinimizationObjValue(double value)
Set best objective function value as minimization.
Definition: CbcModel.hpp:1434
int numberStrongIterations() const
Get the number of iterations done in strong branching.
Definition: CbcModel.hpp:2577
OsiObject ** objects() const
Get the array of objects.
Definition: CbcModel.hpp:504
void gutsOfDestructor()
Clears out as much as possible (except solver)
void adjustHeuristics()
Adjust heuristics based on model.
void setTemporaryPointer(void *pointer)
Set useful temporary pointer.
Definition: CbcModel.hpp:2141
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
Definition: CbcModel.hpp:1400
CoinWarmStartBasis bestSolutionBasis_
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2803
const int * whichGenerator() const
Which cut generator generated this cut.
Definition: CbcModel.hpp:374
const double * cbcRowLower_
Pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:3014
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
Definition: CbcModel.hpp:1272
CbcModel * parentModel_
Parent model.
Definition: CbcModel.hpp:3003
int searchStrategy_
Strategy worked out - mainly at root node.
Definition: CbcModel.hpp:3175
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
Definition: CbcModel.hpp:2692
CoinMessageHandler * messageHandler() const
Return handler.
Definition: CbcModel.hpp:1945
CbcNode ** solveOneNode(int whichSolver, CbcNode *node, int &numberNodesOutput, int &status)
Input one node output N nodes to put on tree and optional solution update This should be able to oper...
int numberStoppedSubTrees_
Number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:2995
CbcNodeInfo ** walkback_
Array used to assemble the path between a node and the search tree root.
Definition: CbcModel.hpp:2890
CbcCutGenerator ** generator_
Definition: CbcModel.hpp:3068
void setRandomSeed(int value)
Set random seed.
Definition: CbcModel.hpp:2024
CglTreeProbingInfo * probingInfo() const
Get a pointer to probing info.
Definition: CbcModel.hpp:2562
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
Definition: CbcModel.hpp:1834
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
CbcSymmetry * symmetryInfo_
Symmetry information.
Definition: CbcModel.hpp:3086
int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws)
Determine and install the active cuts that need to be added for the current subproblem.
int presolve_
Presolve for CbcTreeLocal.
Definition: CbcModel.hpp:3028
int getIterationCount() const
Get how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1018
void setStateOfSearch(int state)
Definition: CbcModel.hpp:1736
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
Definition: CbcModel.hpp:1809
CbcCutGenerator ** virginGenerator_
Definition: CbcModel.hpp:3070
CbcBaseModel * master_
Thread stuff for master.
Definition: CbcModel.hpp:3233
CoinMessages messages_
Cbc messages.
Definition: CbcModel.hpp:2745
int numberHeuristics() const
Get the number of heuristics.
Definition: CbcModel.hpp:1839
double getIntegerTolerance() const
Get the integrality tolerance .
Definition: CbcModel.hpp:687
int chooseBranch(CbcNode *&newNode, int numberPassesLeft, CbcNode *oldNode, OsiCuts &cuts, bool &resolved, CoinWarmStartBasis *lastws, const double *lowerBefore, const double *upperBefore, OsiSolverBranch *&branches)
Encapsulates choosing a variable - anyAction -2, infeasible (-1 round again), 0 done.
int numberAnalyzeIterations() const
Definition: CbcModel.hpp:928
int phase_
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:2875
double getCurrentObjValue() const
Get current objective function value.
Definition: CbcModel.hpp:1418
void resetToReferenceSolver()
Uses a copy of reference solver to be current solver.
int makeGlobalCut(const OsiRowCut &cut)
Make given cut into a global cut.
int maximumSavedSolutions() const
Maximum number of extra saved solutions.
Definition: CbcModel.hpp:1494
int maximumCutPassesAtRoot_
Maximum number of cut passes at root.
Definition: CbcModel.hpp:3127
void setApplicationData(void *appData)
Set application data.
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
Definition: CbcModel.hpp:1283
void setNodeComparison(CbcCompareBase &compare)
void gutsOfCopy(const CbcModel &rhs, int mode=0)
Most of copy constructor mode - 0 copy but don't delete before 1 copy and delete before 2 copy and de...
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
Definition: CbcModel.hpp:1892
CbcBranchDecision * branchingMethod_
Variable selection function.
Definition: CbcModel.hpp:2997
void pseudoShadow(int type)
Fill in useful estimates.
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2653
void setPrintFrequency(int number)
Set the print frequency.
Definition: CbcModel.hpp:987
double * bestSolution_
Array holding the incumbent (best) solution.
Definition: CbcModel.hpp:2773
void setContinuousObjective(double value)
Definition: CbcModel.hpp:1543
CoinWarmStartBasis * getEmptyBasis(int ns=0, int na=0) const
Return an empty basis object of the specified size.
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2533
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
bool defaultHandler_
Flag to say if handler_ is the default handler.
Definition: CbcModel.hpp:2742
void setBranchingMethod(CbcBranchDecision &method)
Set the branching method.
Definition: CbcModel.hpp:1704
CbcStrategy * strategy() const
Get the current strategy.
Definition: CbcModel.hpp:1802
double getSolverObjValue() const
Get solver objective function value (as minimization)
Definition: CbcModel.hpp:1456
void unlockThread()
Unlocks a thread if parallel to say cut pool stuff not needed.
bool eventHappened_
Whether event happened.
Definition: CbcModel.hpp:3167
double numberDJFixed_
Number of reduced cost fixings.
Definition: CbcModel.hpp:3157
void setStrongStrategy(int value)
Set strong branching strategy.
Definition: CbcModel.hpp:1756
bool useElapsedTime() const
Get time method.
Definition: CbcModel.hpp:2131
void analyzeObjective()
Analyze problem to find a minimum change in the objective function.
void fillPseudoCosts(double *downCosts, double *upCosts, int *priority=NULL, int *numberDown=NULL, int *numberUp=NULL, int *numberDownInfeasible=NULL, int *numberUpInfeasible=NULL) const
Return pseudo costs If not all integers or not pseudo costs - returns all zero Length of arrays are n...
int * usedInSolution_
Array marked whenever a solution is found if non-zero.
Definition: CbcModel.hpp:2924
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
Definition: CbcModel.hpp:1176
void setLogLevel(int value)
Set log level.
void setUseElapsedTime(bool yesNo)
Set time method.
Definition: CbcModel.hpp:2123
int reducedCostFix()
Perform reduced cost fixing.
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
void reserveCurrentSolution(const double *solution=NULL)
Make sure region there and optionally copy solution.
int numberStoppedSubTrees() const
Returns number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:1658
int intParam_[CbcLastIntParam]
Array for integer parameters.
Definition: CbcModel.hpp:2748
OsiObject ** object_
Integer and Clique and ...
Definition: CbcModel.hpp:3100
void setTypePresolve(int value)
Definition: CbcModel.hpp:1676
void passInSubTreeModel(CbcModel &model)
For passing in an CbcModel to do a sub Tree (with derived tree handlers).
int strongInfo_[7]
0 - number times strong branching done, 1 - number fixed, 2 - number infeasible Second group of three...
Definition: CbcModel.hpp:3192
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
Definition: CbcModel.hpp:2118
int currentPassNumber_
Current cut pass number.
Definition: CbcModel.hpp:3133
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
int numberCutGenerators_
Number of cut generators.
Definition: CbcModel.hpp:3066
int resolve(CbcNodeInfo *parent, int whereFrom, double *saveSolution=NULL, double *saveLower=NULL, double *saveUpper=NULL)
Reoptimise an LP relaxation.
Information required to recreate the subproblem at this node.
Definition: CbcNodeInfo.hpp:68
Information required while the node is live.
Definition: CbcNode.hpp:49
For gathering statistics.
Strategy base class.
Definition: CbcStrategy.hpp:18
Class to deal with symmetry.
Definition: CbcSymmetry.hpp:66
A class to encapsulate thread stuff.
Definition: CbcThread.hpp:466
Using MS heap implementation.
Definition: CbcTree.hpp:52
void saveSolution(const OsiSolverInterface *osi, std::string fileName)