Cbc 2.10.5
Loading...
Searching...
No Matches
CbcModel.hpp
Go to the documentation of this file.
1/* $Id: CbcModel.hpp 2699 2019-10-03 14:05:25Z stefan $ */
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
21class CbcCutGenerator;
22class CbcBaseModel;
23class OsiRowCut;
24class OsiBabSolver;
25class OsiRowCutDebugger;
26class CglCutGenerator;
27class CglStored;
28class CbcCutModifier;
29class CglTreeProbingInfo;
30class CbcHeuristic;
31class OsiObject;
32class CbcThread;
33class CbcTree;
34class CbcStrategy;
35class CbcSymmetry;
37class CbcStatistics;
38class CbcFullNodeInfo;
39class CbcEventHandler;
40class CglPreProcess;
41class OsiClpSolverInterface;
42class ClpNodeStuff;
43
44// #define CBC_CHECK_BASIS 1
45
46//#############################################################################
47
100class CbcModel {
101
102public:
127 };
128
193 };
194
195 //---------------------------------------------------------------------------
196
197public:
199
200
205
216 void branchAndBound(int doStatistics = 0);
217
218private:
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
254public:
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
341public:
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
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());
613 }
614
616 inline bool setMaximumNodes(int value)
617 {
618 return setIntParam(CbcMaxNumNode, value);
619 }
620
622 inline int getMaximumNodes() const
623 {
625 }
626
631 inline bool setMaximumSolutions(int value)
632 {
633 return setIntParam(CbcMaxNumSol, value);
634 }
639 inline int getMaximumSolutions() const
640 {
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
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 {
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 {
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 {
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 {
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
1002 bool isAbandoned() const;
1004 bool isProvenOptimal() 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
1109 inline int numberRowsAtContinuous() const
1110 {
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 }
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 }
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 {
1497 }
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
1522 {
1524 }
1526 inline void setNumberHeuristicSolutions(int value)
1527 {
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 }
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 {
1571 }
1573 {
1575 }
1577 inline bool resolveAfterTakeOffCuts() const
1578 {
1580 }
1581 inline void setResolveAfterTakeOffCuts(bool yesNo)
1582 {
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 {
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 }
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 {
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 }
1850 {
1851 return lastHeuristic_;
1852 }
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 {
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 }
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 }
2155 //---------------------------------------------------------------------------
2156
2158
2159
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
2276 void gutsOfCopy(const CbcModel &rhs, int mode = 0);
2278 void moveInfo(const CbcModel &rhs);
2280
2282
2283
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;
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
2389 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
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 {
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 {
2580 }
2582 inline int maximumNumberIterations() const
2583 {
2585 }
2587 inline void setMaximumNumberIterations(int value)
2588 {
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 {
2631 numberFathoms_ = 0;
2632 }
2634 inline int numberExtraIterations() const
2635 {
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
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
2714private:
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
2776
2785 mutable const double *testSolution_;
2789 std::vector< std::pair< std::string, double > > mipStart_;
2790
2796
2803 CoinWarmStartBasis bestSolutionBasis_;
2808
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_;
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_;
3213 CglStored *storedRowCuts_;
3237};
3239void getIntegerInformation(const OsiObject *object, double &originalLower,
3240 double &originalUpper);
3241// So we can call from other programs
3242// Real main program
3243class OsiClpSolverInterface;
3244int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
3245// four ways of calling
3246int callCbc(const char *input2, OsiClpSolverInterface &solver1);
3247int callCbc(const char *input2);
3248int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
3249int callCbc(const std::string input2);
3250// When we want to load up CbcModel with options first
3251void CbcMain0(CbcModel &babSolver);
3252int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
3253// two ways of calling
3254int callCbc(const char *input2, CbcModel &babSolver);
3255int callCbc(const std::string input2, CbcModel &babSolver);
3256// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
3257int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3258int 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).
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.
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.
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.
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
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)
const double * cbcColLower_
Whether to automatically do presolve before branch and bound.
const double * testSolution_
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
double getMinimumDrop() const
Get the minimum drop to continue cuts.
Definition CbcModel.hpp:812
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
CglTreeProbingInfo * probingInfo() const
Get a pointer to probing info.
virtual ~CbcModel()
Destructor.
void setParentModel(CbcModel &parentModel)
Set the parent model.
CbcModel * heuristicModel_
A pointer to model from CbcHeuristic.
int numberHeuristics_
Number of heuristics.
void setProblemFeasibility(CbcFeasibilityBase &feasibility)
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.
virtual CbcModel * clone(bool cloneHandler)
Clone.
int moreSpecialOptions_
More special options at present bottom 6 bits used for shadow price mode 1024 for experimental hotsta...
void setResolveAfterTakeOffCuts(bool yesNo)
CbcHeuristic * lastHeuristic_
Pointer to heuristic solver which found last solution (or NULL)
CoinWarmStartBasis workingBasis_
Work basis for temporary use.
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.
int continuousInfeasibilities_
Number of infeasibilities at continuous.
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.
double penaltyScaleFactor_
Scale factor to make penalties match strong.
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
double getInfinity() const
Get solver's value for infinity.
int numberPenalties_
The number of variables for which to compute penalties in dynamic strong branching.
void setMultipleRootTries(int value)
Set multiple root tries.
int * integerVariable_
Indices of integer variables.
void createContinuousSolver()
Create solver with continuous state.
void setOptionalInteger(int index)
CbcFeasibilityBase * problemFeasibility() const
int secondaryStatus() const
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
int numberPenalties() const
get the number of variables for which to compute penalties in dynamic strong branching.
Definition CbcModel.hpp:914
const char * integerType() const
Whether or not integer.
double getContinuousObjective() const
Value of objective at continuous.
OsiBabSolver * solverCharacteristics_
For advanced applications you may wish to modify the behavior of Cbc e.g.
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.
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.
void incrementSubTreeStopped()
Says a sub tree was stopped.
void setMoreSpecialOptions(int value)
Set more special options at present bottom 6 bits used for shadow price mode 1024 for experimental ho...
int maximumStatistics_
Maximum number of statistics.
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.
bool allDynamic() const
Says whether all dynamic integers.
CoinWarmStart * emptyWarmStart_
Pointer to an empty warm start object.
void setNodeComparison(CbcCompareBase *compare)
int logLevel() const
Get log level.
int phase() const
Current phase (so heuristics etc etc can find out).
void setNumberObjects(int number)
Set the number of objects.
Definition CbcModel.hpp:498
CbcCompareBase * nodeComparison() const
const double * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
int numberStrongIterations_
Number of iterations in strong branching.
int lastDepth_
CoinMessages * messagesPointer()
Return pointer to messages.
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
CbcFeasibilityBase * problemFeasibility_
User feasibility function (see CbcFeasibleBase.hpp)
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
int moreSpecialOptions2_
More more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective until...
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
bool setHeuristicFractionGap(double value)
Set the fraction heuristic gap between the best known solution and the best possible solution.
Definition CbcModel.hpp:770
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
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.
int numberNodes2_
Cumulative number of nodes for statistics.
int maximumWhich_
Maximum number of cuts (for whichGenerator_)
int lastNumberCuts2_
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
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.
OsiSolverInterface * solver_
The solver associated with this model.
CbcThread * masterThread_
Pointer to masterthread.
void zapGlobalCuts()
Get rid of global cuts.
void * temporaryPointer() const
Get useful temporary pointer.
int numberHeuristicSolutions_
Number of heuristic solutions.
OsiSolverInterface * continuousSolver_
A copy of the solver, taken at the continuous (root) node.
OsiRowCut * nextRowCut_
A pointer to a row cut which will be added instead of normal branching.
int fastNodeDepth() const
Get depth for fast nodes.
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
int numberExtraNodes_
Number of extra nodes in fast lp.
CoinMessageHandler * messageHandler() const
Return handler.
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()
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
CbcFullNodeInfo * topOfTree_
Pointer to top of tree.
CbcObjectUpdateData * updateItems_
Update items.
CoinBigIndex getNumElements() const
Get number of nonzero elements.
CglPreProcess * preProcess() const
Returns CglPreProcess used before branch and bound.
Definition CbcModel.hpp:322
CbcModel * findCliques(bool makeEquality, int atLeastThisMany, int lessThanThis, int defaultValue=1000)
Identify cliques and construct corresponding objects.
void checkModel()
Check original model before it gets messed up.
CbcStrategy * strategy() const
Get the current strategy.
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
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...
const int * whichGenerator() const
Which cut generator generated this cut.
Definition CbcModel.hpp:374
double bestObjective_
Best objective.
int stateOfSearch_
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
static bool haveMultiThreadSupport()
Indicates whether Cbc library has been compiled with multithreading support.
bool getKeepNamesPreproc() const
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
CbcModel * parentModel() const
Get the current parent model.
bool canStopOnGap() const
See if can stop on gap.
double * hotstartSolution_
Hotstart solution.
int maximumSavedSolutions_
Maximum number of saved solutions.
int numberSavedSolutions_
Number of saved solutions.
int numberIntegers_
Number of integers in problem.
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
int stopNumberIterations_
For threads - stop after this many "iterations".
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
void setPreProcess(CglPreProcess *preProcess)
Set CglPreProcess used before branch and bound.
Definition CbcModel.hpp:327
bool normalSolver() const
Says if normal solver i.e. has well defined CoinPackedMatrix.
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
int howOftenGlobalScan_
How often to scan global cuts.
int cutoffRowNumber_
-1 - cutoff as constraint not activated -2 - waiting to activate >=0 - activated
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.
CbcNode * currentNode_
Current node so can be used elsewhere.
const double * savedSolution(int which) const
Return a saved solution (0==best) - NULL if off end.
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
char integerType(int i) const
Whether or not integer.
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.
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
int getMultipleRootTries() const
Get multiple root tries.
int numberGlobalCutsIn_
Number of global cuts on entry to a node.
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
Definition CbcModel.hpp:793
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
CoinMessageHandler * handler_
Message handler.
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
Definition CbcModel.hpp:579
CglTreeProbingInfo * probingInfo_
Probing info.
int numberSavedSolutions() const
Number of saved solutions (including best)
int numberInfeasibleNodes_
Number of nodes infeasible by normal branching (before cuts)
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
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()
void AddIntegers()
Add additional integers.
double * continuousSolution_
Holds solution at continuous (after cuts)
int maximumRows() const
Maximum number of rows.
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
double dblParam_[CbcLastDblParam]
Array for double parameters.
int * whichGenerator_
Which cut generator generated this cut.
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
int maximumDepth_
Current limit on search tree depth.
void setNumberAnalyzeIterations(int number)
Number of analyze iterations to do.
Definition CbcModel.hpp:924
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
CbcRowCuts * globalCuts()
Global cuts.
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
int fastNodeDepth_
Depth for fast nodes.
int preferredWay_
Preferred way of branching.
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...
int status() const
Final status of problem Some of these can be found out by is...... functions -1 before branchAndBound...
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
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.
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.
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
CbcEventHandler * eventHandler_
Pointer to the event handler.
int * lastNumberCuts_
CbcRowCuts globalCuts_
Global cuts.
double * bestSolution() const
The best solution to the integer programming problem.
bool keepNamesPreproc
keepNamesPreproc if variables names will be preserved in the pre-processed problem (usefull in callba...
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.
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...
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
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...
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
int numberOldActiveCuts_
Number of old active cuts.
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
int numberIterations_
Cumulative number of iterations.
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
int maximumNumberIterations_
Maximum number of iterations (designed to be used in heuristics)
double * currentSolution() const
Solution to the most recent lp relaxation.
const OsiRowCut ** lastCut_
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
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
int threadMode_
thread mode always use numberThreads for branching 1 set then deterministic 2 set then use numberThre...
int numberGlobalViolations_
Number of times global cuts violated.
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
CoinMessages & messages()
Return messages.
int numberThreads_
Parallel 0 - off 1 - testing 2-99 threads other special meanings.
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
Definition CbcModel.hpp:970
bool isContinuousUnbounded() const
Was continuous solution unbounded.
OsiObject ** objects() const
Get the array of objects.
Definition CbcModel.hpp:504
void zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
void setNumberThreads(int value)
Set number of threads.
void setProblemType(int number)
Problem type as set by user or found by analysis.
Definition CbcModel.hpp:948
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
bool isInteger(int colIndex) const
Return true if column is integer.
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.
std::vector< std::pair< std::string, double > > mipStart_
MIPstart values values for integer variables which will be converted to a complete integer initial fe...
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.
double sumChangeObjective1_
Sum of Changes to objective by first solve.
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.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
void setFastNodeDepth(int value)
Set depth for fast nodes.
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.
OsiSolverInterface * solver() const
Returns solver - has current state.
int maximumCutPasses_
Maximum number of cut passes.
double getMinimizationObjValue() const
Get best objective function value as minimization.
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
CbcStrategy * strategy_
Strategy.
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
void makeGlobalCut(const OsiColCut *cut)
Make given column cut into a global cut.
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
int getThreadMode() const
Get thread mode.
CoinThreadRandom randomNumberGenerator_
Thread specific random number generator.
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
bool isBinary(int colIndex) const
Return true if variable is binary.
bool isProvenOptimal() const
Is optimality proven?
int getExtraNodeCount() const
Get how many Nodes were enumerated in complete fathoming B&B inside CLP.
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
int numberObjects_
Total number of objects.
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
Definition CbcModel.hpp:785
void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
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...
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
int numberLongStrong_
Number of long strong goes.
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.
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.
OsiSolverInterface * referenceSolver_
A copy of the solver, taken at constructor or by saveReferenceSolver.
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
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
CbcThread * masterThread() const
Get pointer to masterthread.
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
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.
int problemType_
Problem type as set by user or found by analysis.
CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, double objValue, const double *solution)
Deals with event handler and solution.
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
bool isSecondsLimitReached() const
Time limit reached?
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
void setSecondaryStatus(int value)
int moreSpecialOptions2() const
Get more special options2.
double ** savedSolutions_
Arrays holding other solutions.
int numberIntegers() const
Number of integers in problem.
const double * cbcColUpper_
Pointer to array[getNumCols()] (for speed) of column upper bounds.
CbcNode * currentNode() const
Get a pointer to current node (be careful)
int numberSolutions_
Number of solutions.
double getHeuristicFractionGap() const
Get the fraction heuristic gap between the best known solution and the best possible solution.
Definition CbcModel.hpp:777
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
int multipleRootTries_
Multiple root tries.
void setWhenCuts(int value)
Set at which depths to do cuts.
Definition CbcModel.hpp:883
CbcStatistics ** statistics_
statistics
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.
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.
double * analyzeResults_
Arrays with analysis results.
CbcRowCuts * globalConflictCuts_
Global conflict cuts.
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
CbcNodeInfo ** walkback() const
Get pointer to walkback.
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
void * temporaryPointer_
Useful temporary pointer.
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.
void setTestSolution(const double *solution)
CbcTree * tree_
Tree.
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
void flipModel()
Flip direction of optimization on all models.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
int maximumNumberCuts_
Maximum number of cuts.
int numberObjects() const
Get the number of objects.
Definition CbcModel.hpp:493
void setBestSolution(const double *solution, int numberColumns, double objectiveValue, bool check=false)
User callable setBestSolution.
void incrementExtra(int nodes, int iterations, int fathoms=1)
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)
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
CbcNodeInfo ** lastNodeInfo_
void passInTreeHandler(CbcTree &tree)
For modifying tree handling (original is cloned)
int getRandomSeed() const
Get random seed.
OsiRowCut * conflictCut(const OsiSolverInterface *solver, bool &localCuts)
Create conflict cut (well - most of)
int maximumCuts_
bool isContinuous(int colIndex) const
Return true if variable is continuous.
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
char * integerInfo_
Whether of not integer.
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
void incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
double getCurrentSeconds() const
Current time since start of branchAndbound.
int getSolutionCount() const
Get number of solutions.
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.
int numberFixedNow_
Number fixed by analyze so far.
double sumChangeObjective() const
Sum of Changes to objective by first solve.
CbcCompareBase * nodeCompare_
User node comparison function.
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
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
bool defaultHandler() const
Check default handler.
void makeGlobalCut(const OsiColCut &cut)
Make given column cut into a global cut.
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
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.
OsiSolverInterface * swapSolver(OsiSolverInterface *solver)
Returns current solver - sets new one.
const int * integerVariable() const
int whenCuts() const
Get at which depths to do cuts.
Definition CbcModel.hpp:878
void incrementNodeCount(int value)
Increment how many nodes it took to solve the problem.
int getPreferredWay() const
Get the preferred way to branch (default 0)
Definition CbcModel.hpp:873
int getFathomCount() const
Get how many times complete fathoming B&B was done.
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
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.
void redoWalkBack()
Redo walkback arrays.
int randomSeed_
Random seed.
int numberNodes_
Cumulative number of nodes.
bool isAbandoned() const
Are there a numerical difficulties?
int * originalColumns_
Original columns as created by integerPresolve or preprocessing.
void setObjValue(double value)
Set best objective function value.
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.
int getStopNumberIterations() const
Get number of "iterations" to stop after.
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
int getMaximumNodes() const
Get the maximum node limit .
Definition CbcModel.hpp:622
int numberStrong_
Maximum number of candidates to consider for strong branching.
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.
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
Definition CbcModel.hpp:824
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
int currentNumberCuts_
Number of entries in addedCuts_.
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
void setProblemStatus(int value)
int * hotstartPriorities_
Hotstart priorities.
CglStored * storedRowCuts_
Stored row cuts for donor/recipient CbcModel.
const double * cbcColSolution_
Pointer to array[getNumCols()] (for speed) of primal solution vector.
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
int specialOptions() const
Get special options.
const OsiObject * object(int which) const
Get the specified object.
Definition CbcModel.hpp:510
int whenCuts_
At which depths to do cuts.
void setNumberHeuristics(int value)
Set the number of heuristics.
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.
void * appData_
Pointer to user-defined data structure.
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
int numberExtraIterations_
Number of extra iterations in fast lp.
const double * cbcRowUpper_
Pointer to array[getNumRows()] (for speed) of row upper bounds.
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.
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
int strongStrategy() const
Stong branching strategy.
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.
bool setIntegerTolerance(double value)
Set the integrality tolerance .
Definition CbcModel.hpp:680
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
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.
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.
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.
bool stoppedOnGap_
Whether stopping on gap.
int getPrintingMode() const
Get the printing mode.
Definition CbcModel.hpp:650
const int * strongInfo() const
Return strong info.
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.
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
int maximumDepthActual_
Maximum depth reached.
void setLanguage(CoinMessages::Language language)
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.
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.
void setMoreSpecialOptions2(int value)
Set more more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective u...
CbcModel()
Default Constructor.
void moveInfo(const CbcModel &rhs)
Move status, nodes etc etc across.
double getBestPossibleObjValue() const
Get best possible objective function value.
void sayEventHappened()
Tell model to stop on event.
int strongStrategy_
Strategy for strong branching 0 - normal when to do all fractional 1 - root node 2 - depth less than ...
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).
bool modelOwnsSolver()
Get ownership of solver.
void zeroExtra()
Zero extra.
void clearContinuousSolver()
Clear solver with continuous state.
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
const std::vector< std::pair< std::string, double > > & getMIPStart()
int numberFathoms_
Number of times fast lp entered.
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...
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
void setContinuousInfeasibilities(int value)
CglPreProcess * preProcess_
preProcess used before branch and bound (optional)
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.
CbcCutModifier * cutModifier_
Cut modifier function.
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
OsiObject * modifiableObject(int which) const
Get the specified object.
Definition CbcModel.hpp:515
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
const double * hotstartSolution() const
Get the hotstart solution.
bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node)
Evaluate a subproblem using cutting planes and heuristics.
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
int maximumNumberUpdateItems_
Maximum number of outstanding update information items.
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
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.
int getNumRows() const
Get number of rows.
double originalContinuousObjective_
Value of objective before root node cuts added.
void initialSolve()
Solve the initial LP relaxation.
int problemType() const
Definition CbcModel.hpp:952
double getObjValue() const
Get best objective function value.
int numberSolves_
Cumulative number of solves.
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...
void setMinimizationObjValue(double value)
Set best objective function value as minimization.
int numberStrongIterations() const
Get the number of iterations done in strong branching.
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.
CoinWarmStartBasis bestSolutionBasis_
Warm start object produced by heuristic or strong branching.
const double * cbcRowLower_
Pointer to array[getNumRows()] (for speed) of row lower bounds.
CbcModel * parentModel_
Parent model.
int searchStrategy_
Strategy worked out - mainly at root node.
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
int numberStoppedSubTrees_
Number of times any subtree stopped on nodes, time etc.
CbcNodeInfo ** walkback_
Array used to assemble the path between a node and the search tree root.
CbcCutGenerator ** generator_
const int * hotstartPriorities() const
Get the hotstart priorities.
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
Definition CbcModel.hpp:919
void setRandomSeed(int value)
Set random seed.
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
CbcSymmetry * symmetryInfo_
Symmetry information.
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.
int getIterationCount() const
Get how many iterations it took to solve the problem.
void setStateOfSearch(int state)
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
CbcCutGenerator ** virginGenerator_
CbcBaseModel * master_
Thread stuff for master.
const OsiSolverInterface * postProcessedSolver(int solutionType=1)
Returns postProcessed solution in solver(called from event handler) Normally used for integer solutio...
CoinMessages messages_
Cbc messages.
int numberHeuristics() const
Get the number of heuristics.
double getIntegerTolerance() const
Get the integrality tolerance .
Definition CbcModel.hpp:687
void * getApplicationData() const
Get application data.
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).
double getCurrentObjValue() const
Get current objective function value.
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.
int maximumCutPassesAtRoot_
Maximum number of cut passes at root.
void setApplicationData(void *appData)
Set application data.
int * mutableStrongInfo()
Return mutable strong info.
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...
CbcBranchDecision * branchingMethod_
Variable selection function.
void pseudoShadow(int type)
Fill in useful estimates.
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
void setPrintFrequency(int number)
Set the print frequency.
Definition CbcModel.hpp:987
double * bestSolution_
Array holding the incumbent (best) solution.
void setContinuousObjective(double value)
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
char * setupCleanVariables()
Sets up cleanVariables array (i.e. ones to be careful about)
bool defaultHandler_
Flag to say if handler_ is the default handler.
void setBranchingMethod(CbcBranchDecision &method)
Set the branching method.
double getSolverObjValue() const
Get solver objective function value (as minimization)
void unlockThread()
Unlocks a thread if parallel to say cut pool stuff not needed.
bool eventHappened_
Whether event happened.
double numberDJFixed_
Number of reduced cost fixings.
void setStrongStrategy(int value)
Set strong branching strategy.
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
bool useElapsedTime() const
Get time method.
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.
void setLogLevel(int value)
Set log level.
void setUseElapsedTime(bool yesNo)
Set time method.
int reducedCostFix()
Perform reduced cost fixing.
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
CbcBaseModel * master() const
Thread stuff for master.
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.
int intParam_[CbcLastIntParam]
Array for integer parameters.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
OsiObject ** object_
Integer and Clique and ... information.
void setTypePresolve(int value)
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...
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
int currentPassNumber_
Current cut pass number.
CoinWarmStartBasis * getEmptyBasis(int ns=0, int na=0) const
Return an empty basis object of the specified size.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
int numberCutGenerators_
Number of cut generators.
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.
Information required while the node is live.
Definition CbcNode.hpp:49
For gathering statistics.
Strategy base class.
Class to deal with symmetry.
A class to encapsulate thread stuff.
Using MS heap implementation.
Definition CbcTree.hpp:52