Cbc 2.10.10
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
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 }
1417 inline bool modelFlipped() const
1418 {
1419 return (moreSpecialOptions2_&67108864)!=0;
1420 }
1422 inline double trueObjValue(double value) const
1423 {
1424 return (moreSpecialOptions2_&67108864)==0 ? value : -value;
1425 }
1426 inline double trueBestObjValue() const
1427 {
1428 return (moreSpecialOptions2_&67108864)==0 ? bestObjective_ : -bestObjective_;
1429 }
1431 inline double trueCutoff() const
1432 {
1433 return (moreSpecialOptions2_&67108864)==0 ?
1435 }
1436
1438 inline double getCurrentObjValue() const
1439 {
1441 }
1444 {
1446 }
1447
1449 inline double getMinimizationObjValue() const
1450 {
1451 return bestObjective_;
1452 }
1454 inline void setMinimizationObjValue(double value)
1455 {
1456 bestObjective_ = value;
1457 }
1458
1460 inline double getObjValue() const
1461 {
1462 return bestObjective_ * solver_->getObjSense();
1463 }
1471 inline void setObjValue(double value)
1472 {
1473 bestObjective_ = value * solver_->getObjSense();
1474 }
1476 inline double getSolverObjValue() const
1477 {
1478 return solver_->getObjValue() * solver_->getObjSense();
1479 }
1480
1487 inline double *bestSolution() const
1488 {
1489 return bestSolution_;
1490 }
1497 void setBestSolution(const double *solution, int numberColumns,
1498 double objectiveValue, bool check = false);
1499
1501 inline int getSolutionCount() const
1502 {
1503 return numberSolutions_;
1504 }
1505
1507 inline void setSolutionCount(int value)
1508 {
1509 numberSolutions_ = value;
1510 }
1514 inline int maximumSavedSolutions() const
1515 {
1517 }
1521 const double *savedSolution(int which) const;
1523 double savedSolutionObjective(int which) const;
1525 void deleteSavedSolution(int which);
1526
1535 inline int phase() const
1536 {
1537 return phase_;
1538 }
1539
1542 {
1544 }
1546 inline void setNumberHeuristicSolutions(int value)
1547 {
1549 }
1550
1552 inline void setObjSense(double s)
1553 {
1555 solver_->setObjSense(s);
1556 }
1557
1559 inline double getContinuousObjective() const
1560 {
1562 }
1563 inline void setContinuousObjective(double value)
1564 {
1566 }
1569 {
1571 }
1572 inline void setContinuousInfeasibilities(int value)
1573 {
1575 }
1577 inline double rootObjectiveAfterCuts() const
1578 {
1579 return continuousObjective_;
1580 }
1582 inline double sumChangeObjective() const
1583 {
1584 return sumChangeObjective1_;
1585 }
1588 inline int numberGlobalViolations() const
1589 {
1591 }
1593 {
1595 }
1597 inline bool resolveAfterTakeOffCuts() const
1598 {
1600 }
1601 inline void setResolveAfterTakeOffCuts(bool yesNo)
1602 {
1604 }
1606 inline int maximumRows() const
1607 {
1608 return maximumRows_;
1609 }
1611 inline CoinWarmStartBasis &workingBasis()
1612 {
1613 return workingBasis_;
1614 }
1616 inline int getStopNumberIterations() const
1617 {
1618 return stopNumberIterations_;
1619 }
1621 inline void setStopNumberIterations(int value)
1622 {
1623 stopNumberIterations_ = value;
1624 }
1626 inline CbcModel *heuristicModel() const
1627 {
1628 return heuristicModel_;
1629 }
1631 inline void setHeuristicModel(CbcModel *model)
1632 {
1633 heuristicModel_ = model;
1634 }
1636
1639 // Comparison functions (which may be overridden by inheritance)
1641 {
1642 return nodeCompare_;
1643 }
1647
1650 // Feasibility functions (which may be overridden by inheritance)
1652 {
1653 return problemFeasibility_;
1654 }
1658
1662 inline CbcTree *tree() const
1663 {
1664 return tree_;
1665 }
1676 CbcModel *subTreeModel(OsiSolverInterface *solver = NULL) const;
1678 inline int numberStoppedSubTrees() const
1679 {
1681 }
1684 {
1686 }
1692 inline int typePresolve() const
1693 {
1694 return presolve_;
1695 }
1696 inline void setTypePresolve(int value)
1697 {
1698 presolve_ = value;
1699 }
1700
1702
1708
1711 {
1712 return branchingMethod_;
1713 }
1716 {
1717 delete branchingMethod_;
1718 branchingMethod_ = method->clone();
1719 }
1725 {
1726 delete branchingMethod_;
1727 branchingMethod_ = method.clone();
1728 }
1731 {
1732 return cutModifier_;
1733 }
1742
1745
1752 inline int stateOfSearch() const
1753 {
1754 return stateOfSearch_;
1755 }
1756 inline void setStateOfSearch(int state)
1757 {
1758 stateOfSearch_ = state;
1759 }
1761 inline int searchStrategy() const
1762 {
1763 return searchStrategy_;
1764 }
1766 inline void setSearchStrategy(int value)
1767 {
1768 searchStrategy_ = value;
1769 }
1771 inline int strongStrategy() const
1772 {
1773 return strongStrategy_;
1774 }
1776 inline void setStrongStrategy(int value)
1777 {
1778 strongStrategy_ = value;
1779 }
1780
1782 inline int numberCutGenerators() const
1783 {
1784 return numberCutGenerators_;
1785 }
1788 {
1789 return generator_;
1790 }
1792 inline CbcCutGenerator *cutGenerator(int i) const
1793 {
1794 return generator_[i];
1795 }
1798 {
1799 return virginGenerator_[i];
1800 }
1809 void addCutGenerator(CglCutGenerator *generator,
1810 int howOften = 1, const char *name = NULL,
1811 bool normal = true, bool atSolution = false,
1812 bool infeasible = false, int howOftenInSub = -100,
1813 int whatDepth = -1, int whatDepthInSub = -1);
1815
1820
1822 inline CbcStrategy *strategy() const
1823 {
1824 return strategy_;
1825 }
1830 {
1832 }
1834 inline CbcModel *parentModel() const
1835 {
1836 return parentModel_;
1837 }
1840 {
1842 }
1844
1851 void addHeuristic(CbcHeuristic *generator, const char *name = NULL,
1852 int before = -1);
1854 inline CbcHeuristic *heuristic(int i) const
1855 {
1856 return heuristic_[i];
1857 }
1859 inline int numberHeuristics() const
1860 {
1861 return numberHeuristics_;
1862 }
1864 inline void setNumberHeuristics(int value)
1865 {
1866 numberHeuristics_ = value;
1867 }
1870 {
1871 return lastHeuristic_;
1872 }
1875 {
1876 lastHeuristic_ = last;
1877 }
1878
1897 void passInPriorities(const int *priorities, bool ifNotSimpleIntegers);
1898
1900 inline int priority(int sequence) const
1901 {
1902 return object_[sequence]->priority();
1903 }
1904
1909 void passInEventHandler(const CbcEventHandler *eventHandler);
1910
1913 {
1914 return (eventHandler_);
1915 }
1916
1918
1928 void setApplicationData(void *appData);
1929
1931 void *getApplicationData() const;
1946 inline const OsiBabSolver *solverCharacteristics() const
1947 {
1949 }
1951
1952 //---------------------------------------------------------------------------
1953
1957 void passInMessageHandler(CoinMessageHandler *handler);
1959 void newLanguage(CoinMessages::Language language);
1960 inline void setLanguage(CoinMessages::Language language)
1961 {
1962 newLanguage(language);
1963 }
1965 inline CoinMessageHandler *messageHandler() const
1966 {
1967 return handler_;
1968 }
1970 inline CoinMessages &messages()
1971 {
1972 return messages_;
1973 }
1975 inline CoinMessages *messagesPointer()
1976 {
1977 return &messages_;
1978 }
1980 void setLogLevel(int value);
1982 inline int logLevel() const
1983 {
1984 return handler_->logLevel();
1985 }
1991 inline void setDefaultHandler(bool yesNo)
1992 {
1993 defaultHandler_ = yesNo;
1994 }
1996 inline bool defaultHandler() const
1997 {
1998 return defaultHandler_;
1999 }
2001 //---------------------------------------------------------------------------
2003
2004
2034 inline void setSpecialOptions(int value)
2035 {
2036 specialOptions_ = value;
2037 }
2039 inline int specialOptions() const
2040 {
2041 return specialOptions_;
2042 }
2044 inline void setRandomSeed(int value)
2045 {
2046 randomSeed_ = value;
2047 }
2049 inline int getRandomSeed() const
2050 {
2051 return randomSeed_;
2052 }
2054 inline void setMultipleRootTries(int value)
2055 {
2056 multipleRootTries_ = value;
2057 }
2059 inline int getMultipleRootTries() const
2060 {
2061 return multipleRootTries_;
2062 }
2064 inline void sayEventHappened()
2065 {
2066 eventHappened_ = true;
2067 }
2069 inline bool normalSolver() const
2070 {
2071 return (specialOptions_ & 16) == 0;
2072 }
2078 {
2079 return (specialOptions_ & 1048576) != 0;
2080 }
2104 inline void setMoreSpecialOptions(int value)
2105 {
2106 moreSpecialOptions_ = value;
2107 }
2109 inline int moreSpecialOptions() const
2110 {
2111 return moreSpecialOptions_;
2112 }
2129 inline void setMoreSpecialOptions2(int value)
2130 {
2131 moreSpecialOptions2_ = value;
2132 }
2134 inline int moreSpecialOptions2() const
2135 {
2136 return moreSpecialOptions2_;
2137 }
2139 inline void setCutoffAsConstraint(bool yesNo)
2140 {
2141 cutoffRowNumber_ = (yesNo) ? -2 : -1;
2142 }
2144 inline void setUseElapsedTime(bool yesNo)
2145 {
2146 if (yesNo)
2147 moreSpecialOptions_ |= 131072;
2148 else
2149 moreSpecialOptions_ &= ~131072;
2150 }
2152 inline bool useElapsedTime() const
2153 {
2154 return (moreSpecialOptions_ & 131072) != 0;
2155 }
2157 inline void *temporaryPointer() const
2158 {
2159 return temporaryPointer_;
2160 }
2162 inline void setTemporaryPointer(void *pointer)
2163 {
2164 temporaryPointer_ = pointer;
2165 }
2167 void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod);
2169 inline bool ownObjects() const
2170 {
2171 return ownObjects_;
2172 }
2176 //---------------------------------------------------------------------------
2177
2179
2180
2182
2184 CbcModel(const OsiSolverInterface &);
2185
2194 void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
2195
2207 inline void setModelOwnsSolver(bool ourSolver)
2208 {
2209 ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000));
2210 }
2211
2217 inline bool modelOwnsSolver()
2218 {
2219 return ((ownership_ & 0x80000000) != 0);
2220 }
2221
2225 CbcModel(const CbcModel &rhs, bool cloneHandler = false);
2226
2228 virtual CbcModel *clone(bool cloneHandler);
2229
2232
2234 virtual ~CbcModel();
2235
2237 inline OsiSolverInterface *solver() const
2238 {
2239 return solver_;
2240 }
2241
2243 inline OsiSolverInterface *swapSolver(OsiSolverInterface *solver)
2244 {
2245 OsiSolverInterface *returnSolver = solver_;
2246 solver_ = solver;
2247 return returnSolver;
2248 }
2249
2251 inline OsiSolverInterface *continuousSolver() const
2252 {
2253 return continuousSolver_;
2254 }
2255
2258 {
2259 continuousSolver_ = solver_->clone();
2260 }
2263 {
2264 delete continuousSolver_;
2265 continuousSolver_ = NULL;
2266 }
2267
2269 inline OsiSolverInterface *referenceSolver() const
2270 {
2271 return referenceSolver_;
2272 }
2273
2276
2283
2297 void gutsOfCopy(const CbcModel &rhs, int mode = 0);
2299 void moveInfo(const CbcModel &rhs);
2301
2303
2304
2308 {
2309 return masterThread_;
2310 }
2313 {
2314 return walkback_;
2315 }
2317 inline int getNumberThreads() const
2318 {
2319 return numberThreads_;
2320 }
2322 inline void setNumberThreads(int value)
2323 {
2324 numberThreads_ = value;
2325 }
2327 inline int getThreadMode() const
2328 {
2329 return threadMode_;
2330 }
2340 inline void setThreadMode(int value)
2341 {
2342 threadMode_ = value;
2343 }
2350 inline int parallelMode() const
2351 {
2352 if (!numberThreads_) {
2353 if ((threadMode_ & 1) == 0)
2354 return 0;
2355 else
2356 return -1;
2357 return 0;
2358 } else {
2359 if ((threadMode_ & 1) == 0)
2360 return 1;
2361 else
2362 return -2;
2363 }
2364 }
2366 inline CbcBaseModel *master() const
2367 {
2368 return master_;
2369 }
2372 bool isLocked() const;
2389 void setInfoInChild(int type, CbcThread *info);
2396 void moveToModel(CbcModel *baseModel, int mode);
2398 int splitModel(int numberModels, CbcModel **model,
2399 int numberNodes);
2401 void startSplitModel(int numberIterations);
2403 void mergeModels(int numberModel, CbcModel **model,
2404 int numberNodes);
2406
2408
2409
2410 int getNodeCount2() const
2411 {
2412 return numberNodes2_;
2413 }
2415 void setPointers(const OsiSolverInterface *solver);
2425 void synchronizeHandlers(int makeDefault);
2427 void saveExtraSolution(const double *solution, double objectiveValue);
2429 void saveBestSolution(const double *solution, double objectiveValue);
2433 int resolve(OsiSolverInterface *solver);
2434#ifdef CLP_RESOLVE
2436 int resolveClp(OsiClpSolverInterface *solver, int type);
2437#endif
2438
2442 int chooseBranch(CbcNode *&newNode, int numberPassesLeft,
2443 CbcNode *oldNode, OsiCuts &cuts,
2444 bool &resolved, CoinWarmStartBasis *lastws,
2445 const double *lowerBefore, const double *upperBefore,
2446 OsiSolverBranch *&branches);
2447
2454 CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const;
2455
2467 int takeOffCuts(OsiCuts &cuts,
2468 bool allowResolve, OsiCuts *saveCuts,
2469 int numberNewCuts = 0, const OsiRowCut **newCuts = NULL);
2470
2483 int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws);
2484
2501 bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws);
2505 void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn,
2506 double &lower, double &upper, int force);
2511 void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const;
2512
2520 void zapIntegerInformation(bool leaveObjects = true);
2522 void pseudoShadow(int type);
2529 void fillPseudoCosts(double *downCosts, double *upCosts,
2530 int *priority = NULL,
2531 int *numberDown = NULL, int *numberUp = NULL,
2532 int *numberDownInfeasible = NULL,
2533 int *numberUpInfeasible = NULL) const;
2539 void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
2543 inline const double *hotstartSolution() const
2544 {
2545 return hotstartSolution_;
2546 }
2548 inline const int *hotstartPriorities() const
2549 {
2550 return hotstartPriorities_;
2551 }
2552
2554 inline CbcCountRowCut **addedCuts() const
2555 {
2556 return addedCuts_;
2557 }
2559 inline int currentNumberCuts() const
2560 {
2561 return currentNumberCuts_;
2562 }
2565 {
2566 return &globalCuts_;
2567 }
2569 inline void zapGlobalCuts()
2570 {
2572 }
2574 void setNextRowCut(const OsiRowCut &cut);
2576 inline CbcNode *currentNode() const
2577 {
2578 return currentNode_;
2579 }
2581 void deleteNode(CbcNode * node);
2583 inline CglTreeProbingInfo *probingInfo() const
2584 {
2585 return probingInfo_;
2586 }
2588 inline CoinThreadRandom *randomNumberGenerator()
2589 {
2590 return &randomNumberGenerator_;
2591 }
2593 inline void setNumberStrongIterations(int number)
2594 {
2595 numberStrongIterations_ = number;
2596 }
2598 inline int numberStrongIterations() const
2599 {
2601 }
2603 inline int maximumNumberIterations() const
2604 {
2606 }
2608 inline void setMaximumNumberIterations(int value)
2609 {
2611 }
2612
2615 {
2616 return symmetryInfo_;
2617 }
2619 inline void setSymmetryInfo(CbcSymmetry * info)
2620 {
2621 symmetryInfo_ = info;
2622 }
2627 {
2628 return rootSymmetryInfo_;
2629 }
2631 inline void setFastNodeDepth(int value)
2632 {
2633 fastNodeDepth_ = value;
2634 }
2636 inline int fastNodeDepth() const
2637 {
2638 return fastNodeDepth_;
2639 }
2641 inline int continuousPriority() const
2642 {
2643 return continuousPriority_;
2644 }
2646 inline void setContinuousPriority(int value)
2647 {
2648 continuousPriority_ = value;
2649 }
2650 inline void incrementExtra(int nodes, int iterations, int fathoms = 1)
2651 {
2652 numberExtraNodes_ += nodes;
2653 numberExtraIterations_ += iterations;
2654 numberFathoms_ += fathoms;
2655 }
2657 inline void zeroExtra()
2658 {
2661 numberFathoms_ = 0;
2662 }
2664 inline int numberExtraIterations() const
2665 {
2667 }
2669 void incrementStrongInfo(int numberTimes, int numberIterations,
2670 int numberFixed, bool ifInfeasible);
2672 inline const int *strongInfo() const
2673 {
2674 return strongInfo_;
2675 }
2676
2678 inline int *mutableStrongInfo()
2679 {
2680 return strongInfo_;
2681 }
2683 CglStored *storedRowCuts() const
2684 {
2685 return storedRowCuts_;
2686 }
2688 void setStoredRowCuts(CglStored *cuts)
2689 {
2690 storedRowCuts_ = cuts;
2691 }
2693 inline bool allDynamic() const
2694 {
2695 return ((ownership_ & 0x40000000) != 0);
2696 }
2698 void generateCpp(FILE *fp, int options);
2700 OsiBranchingInformation usefulInformation() const;
2707 inline void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
2708 {
2709 bestSolutionBasis_ = bestSolutionBasis;
2710 }
2714
2715 void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
2716 {
2717 this->mipStart_ = mipstart;
2718 }
2719
2722 void setKeepNamesPreproc( bool _keep )
2723 {
2724 this->keepNamesPreproc = _keep;
2725 }
2726
2728 {
2729 return keepNamesPreproc;
2730 }
2731
2734 void setMIPStart(int count, const char **colNames, const double colValues[]);
2735
2736
2737 const std::vector< std::pair< std::string, double > > &getMIPStart()
2738 {
2739 return this->mipStart_;
2740 }
2741
2742 //---------------------------------------------------------------------------
2743
2744private:
2746
2747
2749 OsiSolverInterface *solver_;
2750
2756 unsigned int ownership_;
2757
2759 OsiSolverInterface *continuousSolver_;
2760
2762 OsiSolverInterface *referenceSolver_;
2763
2765 CoinMessageHandler *handler_;
2766
2773
2775 CoinMessages messages_;
2776
2779
2782
2791 mutable CoinWarmStart *emptyWarmStart_;
2792
2801
2806
2815 mutable const double *testSolution_;
2819 std::vector< std::pair< std::string, double > > mipStart_;
2820
2826
2833 CoinWarmStartBasis bestSolutionBasis_;
2838
2906
2909
2922 CglPreProcess *preProcess_;
2924 const OsiRowCut **lastCut_;
2929
2938
2942 OsiRowCut *nextRowCut_;
2943
2946
3040 const double *cbcColLower_;
3042 const double *cbcColUpper_;
3044 const double *cbcRowLower_;
3046 const double *cbcRowUpper_;
3048 const double *cbcColSolution_;
3050 const double *cbcRowPrice_;
3052 const double *cbcReducedCost_;
3054 const double *cbcRowActivity_;
3097 // Cut generators
3099 // Cut generators before any changes
3110#ifdef CBC_ONLY_CLP
3111 ClpEventHandler *eventHandler_;
3112#else
3114#endif
3121
3132 OsiObject **object_;
3135
3177 mutable CoinThreadRandom randomNumberGenerator_;
3179 CoinWarmStartBasis workingBasis_;
3191 CglTreeProbingInfo *probingInfo_;
3199 mutable bool eventHappened_;
3245 CglStored *storedRowCuts_;
3269};
3271void getIntegerInformation(const OsiObject *object, double &originalLower,
3272 double &originalUpper);
3273// So we can call from other programs
3274// Real main program
3275class OsiClpSolverInterface;
3276int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
3277// four ways of calling
3278int callCbc(const char *input2, OsiClpSolverInterface &solver1);
3279int callCbc(const char *input2);
3280int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
3281int callCbc(const std::string input2);
3282// When we want to load up CbcModel with options first
3283void CbcMain0(CbcModel &babSolver);
3284int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
3285// two ways of calling
3286int callCbc(const char *input2, CbcModel &babSolver);
3287int callCbc(const std::string input2, CbcModel &babSolver);
3288// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
3289int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3290int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3291// For uniform setting of cut and heuristic options
3293#endif
3294
3295/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
3296*/
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:2593
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:3094
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:1308
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:3152
const double * cbcColLower_
Whether to automatically do presolve before branch and bound.
Definition: CbcModel.hpp:3040
const double * testSolution_
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
Definition: CbcModel.hpp:2815
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.
Definition: CbcModel.hpp:2583
CbcSymmetry * symmetryInfo() const
Symmetry information.
Definition: CbcModel.hpp:2614
virtual ~CbcModel()
Destructor.
void setParentModel(CbcModel &parentModel)
Set the parent model.
Definition: CbcModel.hpp:1839
CbcModel * heuristicModel_
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:3023
int numberHeuristics_
Number of heuristics.
Definition: CbcModel.hpp:3102
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.
Definition: CbcModel.hpp:3104
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...
Definition: CbcModel.hpp:2997
void setResolveAfterTakeOffCuts(bool yesNo)
Definition: CbcModel.hpp:1601
CbcHeuristic * lastHeuristic_
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:3106
CoinWarmStartBasis workingBasis_
Work basis for temporary use.
Definition: CbcModel.hpp:3179
bool modelFlipped() const
Return true if model flipped to make minimize (for printing)
Definition: CbcModel.hpp:1417
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:2756
int continuousInfeasibilities_
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:3157
void setSymmetryInfo(CbcSymmetry *info)
Set symmetry information.
Definition: CbcModel.hpp:2619
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:3134
double penaltyScaleFactor_
Scale factor to make penalties match strong.
Definition: CbcModel.hpp:3077
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
Definition: CbcModel.hpp:1272
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:3072
void setMultipleRootTries(int value)
Set multiple root tries.
Definition: CbcModel.hpp:2054
int * integerVariable_
Indices of integer variables.
Definition: CbcModel.hpp:2948
void createContinuousSolver()
Create solver with continuous state.
Definition: CbcModel.hpp:2257
void setOptionalInteger(int index)
CbcFeasibilityBase * problemFeasibility() const
Definition: CbcModel.hpp:1651
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
const char * integerType() const
Whether or not integer.
Definition: CbcModel.hpp:1150
double getContinuousObjective() const
Value of objective at continuous.
Definition: CbcModel.hpp:1559
OsiBabSolver * solverCharacteristics_
For advanced applications you may wish to modify the behavior of Cbc e.g.
Definition: CbcModel.hpp:3231
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:3052
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:2317
void incrementSubTreeStopped()
Says a sub tree was stopped.
Definition: CbcModel.hpp:1683
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:2104
int maximumStatistics_
Maximum number of statistics.
Definition: CbcModel.hpp:3183
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:2410
bool allDynamic() const
Says whether all dynamic integers.
Definition: CbcModel.hpp:2693
CoinWarmStart * emptyWarmStart_
Pointer to an empty warm start object.
Definition: CbcModel.hpp:2791
void setNodeComparison(CbcCompareBase *compare)
int logLevel() const
Get log level.
Definition: CbcModel.hpp:1982
int phase() const
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:1535
void setNumberObjects(int number)
Set the number of objects.
Definition: CbcModel.hpp:498
CbcCompareBase * nodeComparison() const
Definition: CbcModel.hpp:1640
const double * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:1298
int numberStrongIterations_
Number of iterations in strong branching.
Definition: CbcModel.hpp:3221
int lastDepth_
Definition: CbcModel.hpp:2925
CoinMessages * messagesPointer()
Return pointer to messages.
Definition: CbcModel.hpp:1975
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
CbcFeasibilityBase * problemFeasibility_
User feasibility function (see CbcFeasibleBase.hpp)
Definition: CbcModel.hpp:3015
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:1752
int moreSpecialOptions2_
More more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective until...
Definition: CbcModel.hpp:3011
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: CbcModel.hpp:1552
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.
Definition: CbcModel.hpp:1202
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:3050
int numberNodes2_
Cumulative number of nodes for statistics.
Definition: CbcModel.hpp:2867
int maximumWhich_
Maximum number of cuts (for whichGenerator_)
Definition: CbcModel.hpp:3167
int lastNumberCuts2_
Definition: CbcModel.hpp:2926
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
Definition: CbcModel.hpp:1189
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
Definition: CbcModel.hpp:2588
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:3239
OsiSolverInterface * solver_
The solver associated with this model.
Definition: CbcModel.hpp:2749
CbcThread * masterThread_
Pointer to masterthread.
Definition: CbcModel.hpp:3267
void zapGlobalCuts()
Get rid of global cuts.
Definition: CbcModel.hpp:2569
void * temporaryPointer() const
Get useful temporary pointer.
Definition: CbcModel.hpp:2157
int numberHeuristicSolutions_
Number of heuristic solutions.
Definition: CbcModel.hpp:2861
OsiSolverInterface * continuousSolver_
A copy of the solver, taken at the continuous (root) node.
Definition: CbcModel.hpp:2759
OsiRowCut * nextRowCut_
A pointer to a row cut which will be added instead of normal branching.
Definition: CbcModel.hpp:2942
int fastNodeDepth() const
Get depth for fast nodes.
Definition: CbcModel.hpp:2636
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
int numberExtraNodes_
Number of extra nodes in fast lp.
Definition: CbcModel.hpp:3146
CoinMessageHandler * messageHandler() const
Return handler.
Definition: CbcModel.hpp:1965
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:2559
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1631
CbcFullNodeInfo * topOfTree_
Pointer to top of tree.
Definition: CbcModel.hpp:3019
CbcObjectUpdateData * updateItems_
Update items.
Definition: CbcModel.hpp:3243
CoinBigIndex getNumElements() const
Get number of nonzero elements.
Definition: CbcModel.hpp:1127
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.
Definition: CbcModel.hpp:1822
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
Definition: CbcModel.hpp:2340
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:2077
CbcSymmetry * rootSymmetryInfo_
Root symmetry information.
Definition: CbcModel.hpp:3118
const int * whichGenerator() const
Which cut generator generated this cut.
Definition: CbcModel.hpp:374
double bestObjective_
Best objective.
Definition: CbcModel.hpp:2794
int stateOfSearch_
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:2853
static bool haveMultiThreadSupport()
Indicates whether Cbc library has been compiled with multithreading support.
bool getKeepNamesPreproc() const
Definition: CbcModel.hpp:2727
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2603
CbcModel * parentModel() const
Get the current parent model.
Definition: CbcModel.hpp:1834
bool canStopOnGap() const
See if can stop on gap.
double * hotstartSolution_
Hotstart solution.
Definition: CbcModel.hpp:2857
int maximumSavedSolutions_
Maximum number of saved solutions.
Definition: CbcModel.hpp:2846
int numberSavedSolutions_
Number of saved solutions.
Definition: CbcModel.hpp:2844
int numberIntegers_
Number of integers in problem.
Definition: CbcModel.hpp:2886
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
int stopNumberIterations_
For threads - stop after this many "iterations".
Definition: CbcModel.hpp:3074
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:1318
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.
Definition: CbcModel.hpp:2069
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
Definition: CbcModel.hpp:1266
int howOftenGlobalScan_
How often to scan global cuts.
Definition: CbcModel.hpp:3139
int cutoffRowNumber_
-1 - cutoff as constraint not activated -2 - waiting to activate >=0 - activated
Definition: CbcModel.hpp:2894
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.
Definition: CbcModel.hpp:2945
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)
Definition: CbcModel.hpp:1327
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: CbcModel.hpp:1214
char integerType(int i) const
Whether or not integer.
Definition: CbcModel.hpp:1143
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:1766
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
int getMultipleRootTries() const
Get multiple root tries.
Definition: CbcModel.hpp:2059
int numberGlobalCutsIn_
Number of global cuts on entry to a node.
Definition: CbcModel.hpp:3263
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:1577
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
Definition: CbcModel.hpp:1854
CoinMessageHandler * handler_
Message handler.
Definition: CbcModel.hpp:2765
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
Definition: CbcModel.hpp:579
CglTreeProbingInfo * probingInfo_
Probing info.
Definition: CbcModel.hpp:3191
int numberSavedSolutions() const
Number of saved solutions (including best)
int numberInfeasibleNodes_
Number of nodes infeasible by normal branching (before cuts)
Definition: CbcModel.hpp:3085
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2688
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:1592
void AddIntegers()
Add additional integers.
double * continuousSolution_
Holds solution at continuous (after cuts)
Definition: CbcModel.hpp:2952
int maximumRows() const
Maximum number of rows.
Definition: CbcModel.hpp:1606
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
Definition: CbcModel.hpp:1900
double dblParam_[CbcLastDblParam]
Array for double parameters.
Definition: CbcModel.hpp:2781
int * whichGenerator_
Which cut generator generated this cut.
Definition: CbcModel.hpp:3181
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
int maximumDepth_
Current limit on search tree depth.
Definition: CbcModel.hpp:2914
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:1541
CbcRowCuts * globalCuts()
Global cuts.
Definition: CbcModel.hpp:2564
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:1313
int fastNodeDepth_
Depth for fast nodes.
Definition: CbcModel.hpp:3108
int preferredWay_
Preferred way of branching.
Definition: CbcModel.hpp:3163
void zapSymmetry()
get rid of all
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:2884
int status() const
Final status of problem Some of these can be found out by is...... functions -1 before branchAndBound...
Definition: CbcModel.hpp:1056
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:1869
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
Definition: CbcModel.hpp:1662
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:3233
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:3175
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
Definition: CbcModel.hpp:1507
CbcEventHandler * eventHandler_
Pointer to the event handler.
Definition: CbcModel.hpp:3113
int * lastNumberCuts_
Definition: CbcModel.hpp:2928
CbcRowCuts globalCuts_
Global cuts.
Definition: CbcModel.hpp:2835
double * bestSolution() const
The best solution to the integer programming problem.
Definition: CbcModel.hpp:1487
bool keepNamesPreproc
keepNamesPreproc if variables names will be preserved in the pre-processed problem (usefull in callba...
Definition: CbcModel.hpp:2825
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:2796
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:2034
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.
Definition: CbcModel.hpp:1412
int numberOldActiveCuts_
Number of old active cuts.
Definition: CbcModel.hpp:3203
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
int numberIterations_
Cumulative number of iterations.
Definition: CbcModel.hpp:2869
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
Definition: CbcModel.hpp:1546
int maximumNumberIterations_
Maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:3235
double * currentSolution() const
Solution to the most recent lp relaxation.
Definition: CbcModel.hpp:1375
const OsiRowCut ** lastCut_
Definition: CbcModel.hpp:2924
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.
Definition: CbcModel.hpp:1730
int threadMode_
thread mode always use numberThreads for branching 1 set then deterministic 2 set then use numberThre...
Definition: CbcModel.hpp:3261
int numberGlobalViolations_
Number of times global cuts violated.
Definition: CbcModel.hpp:3142
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
CoinMessages & messages()
Return messages.
Definition: CbcModel.hpp:1970
int numberThreads_
Parallel 0 - off 1 - testing 2-99 threads other special meanings.
Definition: CbcModel.hpp:3253
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.
Definition: CbcModel.hpp:2322
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.
Definition: CbcModel.hpp:1787
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:2873
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:2819
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:3205
double sumChangeObjective1_
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:2798
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.
Definition: CbcModel.hpp:1400
void setFastNodeDepth(int value)
Set depth for fast nodes.
Definition: CbcModel.hpp:2631
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:2840
OsiSolverInterface * solver() const
Returns solver - has current state.
Definition: CbcModel.hpp:2237
int maximumCutPasses_
Maximum number of cut passes.
Definition: CbcModel.hpp:3161
double getMinimizationObjValue() const
Get best objective function value as minimization.
Definition: CbcModel.hpp:1449
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
Definition: CbcModel.hpp:1443
CbcStrategy * strategy_
Strategy.
Definition: CbcModel.hpp:3031
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
Definition: CbcModel.hpp:1991
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.
Definition: CbcModel.hpp:1293
int getThreadMode() const
Get thread mode.
Definition: CbcModel.hpp:2327
CoinThreadRandom randomNumberGenerator_
Thread specific random number generator.
Definition: CbcModel.hpp:3177
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
Definition: CbcModel.hpp:1176
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
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
int numberObjects_
Total number of objects.
Definition: CbcModel.hpp:3120
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:2715
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
int numberLongStrong_
Number of long strong goes.
Definition: CbcModel.hpp:3201
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:2937
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:3021
OsiSolverInterface * referenceSolver_
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2762
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.
Definition: CbcModel.hpp:1303
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
CbcThread * masterThread() const
Get pointer to masterthread.
Definition: CbcModel.hpp:2307
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2683
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:3193
double trueObjValue(double value) const
Return objective function value with sign corrected.
Definition: CbcModel.hpp:1422
int problemType_
Problem type as set by user or found by analysis.
Definition: CbcModel.hpp:3092
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.
Definition: CbcModel.hpp:1792
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
Definition: CbcModel.hpp:1715
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:2134
double ** savedSolutions_
Arrays holding other solutions.
Definition: CbcModel.hpp:2805
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:3042
double trueCutoff() const
Return cutoff value with sign corrected.
Definition: CbcModel.hpp:1431
CbcNode * currentNode() const
Get a pointer to current node (be careful)
Definition: CbcModel.hpp:2576
int numberSolutions_
Number of solutions.
Definition: CbcModel.hpp:2842
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.
Definition: CbcModel.hpp:2251
int multipleRootTries_
Multiple root tries.
Definition: CbcModel.hpp:3173
void setWhenCuts(int value)
Set at which depths to do cuts.
Definition: CbcModel.hpp:883
CbcStatistics ** statistics_
statistics
Definition: CbcModel.hpp:3185
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:2888
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.
Definition: CbcModel.hpp:3081
CbcRowCuts * globalConflictCuts_
Global conflict cuts.
Definition: CbcModel.hpp:2837
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
Definition: CbcModel.hpp:1710
CbcNodeInfo ** walkback() const
Get pointer to walkback.
Definition: CbcModel.hpp:2312
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
Definition: CbcModel.hpp:1611
void * temporaryPointer_
Useful temporary pointer.
Definition: CbcModel.hpp:3083
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:3169
void setTestSolution(const double *solution)
Definition: CbcModel.hpp:1386
CbcTree * tree_
Tree.
Definition: CbcModel.hpp:3017
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
Definition: CbcModel.hpp:1946
void flipModel()
Flip direction of optimization on all models.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
Definition: CbcModel.hpp:1406
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
Definition: CbcModel.hpp:2207
int maximumNumberCuts_
Maximum number of cuts.
Definition: CbcModel.hpp:2896
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)
Definition: CbcModel.hpp:2650
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:2608
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.
Definition: CbcModel.hpp:1283
CbcNodeInfo ** lastNodeInfo_
Definition: CbcModel.hpp:2923
void passInTreeHandler(CbcTree &tree)
For modifying tree handling (original is cloned)
int getRandomSeed() const
Get random seed.
Definition: CbcModel.hpp:2049
OsiRowCut * conflictCut(const OsiSolverInterface *solver, bool &localCuts)
Create conflict cut (well - most of)
int maximumCuts_
Definition: CbcModel.hpp:2927
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:2950
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
Definition: CbcModel.hpp:1797
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:1501
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:3195
double sumChangeObjective() const
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:1582
CbcCompareBase * nodeCompare_
User node comparison function.
Definition: CbcModel.hpp:3013
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.
Definition: CbcModel.hpp:1162
bool defaultHandler() const
Check default handler.
Definition: CbcModel.hpp:1996
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.
Definition: CbcModel.hpp:1621
OsiSolverInterface * swapSolver(OsiSolverInterface *solver)
Returns current solver - sets new one.
Definition: CbcModel.hpp:2243
const int * integerVariable() const
Definition: CbcModel.hpp:1138
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.
Definition: CbcModel.hpp:1033
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.
Definition: CbcModel.hpp:1043
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:1597
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:2109
void redoWalkBack()
Redo walkback arrays.
int randomSeed_
Random seed.
Definition: CbcModel.hpp:3171
int numberNodes_
Cumulative number of nodes.
Definition: CbcModel.hpp:2863
bool isAbandoned() const
Are there a numerical difficulties?
int * originalColumns_
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:3137
void setObjValue(double value)
Set best objective function value.
Definition: CbcModel.hpp:1471
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:2707
int getStopNumberIterations() const
Get number of "iterations" to stop after.
Definition: CbcModel.hpp:1616
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:1288
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:3062
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:3068
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
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
Definition: CbcModel.hpp:1382
int currentNumberCuts_
Number of entries in addedCuts_.
Definition: CbcModel.hpp:2908
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:1874
void setProblemStatus(int value)
Definition: CbcModel.hpp:1060
int * hotstartPriorities_
Hotstart priorities.
Definition: CbcModel.hpp:2859
CglStored * storedRowCuts_
Stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:3245
const double * cbcColSolution_
Pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:3048
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
Definition: CbcModel.hpp:1912
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:2039
const OsiObject * object(int which) const
Get the specified object.
Definition: CbcModel.hpp:510
int whenCuts_
At which depths to do cuts.
Definition: CbcModel.hpp:2855
void setNumberHeuristics(int value)
Set the number of heuristics.
Definition: CbcModel.hpp:1864
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:1588
void * appData_
Pointer to user-defined data structure.
Definition: CbcModel.hpp:3056
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2554
double trueBestObjValue() const
Definition: CbcModel.hpp:1426
int numberExtraIterations_
Number of extra iterations in fast lp.
Definition: CbcModel.hpp:3144
const double * cbcRowUpper_
Pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:3046
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.
Definition: CbcModel.hpp:1220
int strongStrategy() const
Stong branching strategy.
Definition: CbcModel.hpp:1771
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:2800
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:3237
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:1782
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:2664
bool stoppedOnGap_
Whether stopping on gap.
Definition: CbcModel.hpp:3197
int getPrintingMode() const
Get the printing mode.
Definition: CbcModel.hpp:650
const int * strongInfo() const
Return strong info.
Definition: CbcModel.hpp:2672
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:2811
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:3187
void setLanguage(CoinMessages::Language language)
Definition: CbcModel.hpp:1960
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:1568
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:3079
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:2129
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.
Definition: CbcModel.hpp:2064
int strongStrategy_
Strategy for strong branching 0 - normal when to do all fractional 1 - root node 2 - depth less than ...
Definition: CbcModel.hpp:3219
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:1692
bool modelOwnsSolver()
Get ownership of solver.
Definition: CbcModel.hpp:2217
void zeroExtra()
Zero extra.
Definition: CbcModel.hpp:2657
void clearContinuousSolver()
Clear solver with continuous state.
Definition: CbcModel.hpp:2262
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
const std::vector< std::pair< std::string, double > > & getMIPStart()
Definition: CbcModel.hpp:2737
int numberFathoms_
Number of times fast lp entered.
Definition: CbcModel.hpp:3148
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:2982
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
void setContinuousInfeasibilities(int value)
Definition: CbcModel.hpp:1572
CglPreProcess * preProcess_
preProcess used before branch and bound (optional)
Definition: CbcModel.hpp:2922
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:3054
CbcCutModifier * cutModifier_
Cut modifier function.
Definition: CbcModel.hpp:3029
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2641
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.
Definition: CbcModel.hpp:1761
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
const double * hotstartSolution() const
Get the hotstart solution.
Definition: CbcModel.hpp:2543
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.
Definition: CbcModel.hpp:1335
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
Definition: CbcModel.hpp:2350
int maximumNumberUpdateItems_
Maximum number of outstanding update information items.
Definition: CbcModel.hpp:3241
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2646
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:2169
int getNumRows() const
Get number of rows.
Definition: CbcModel.hpp:1121
double originalContinuousObjective_
Value of objective before root node cuts added.
Definition: CbcModel.hpp:3155
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:1460
int numberSolves_
Cumulative number of solves.
Definition: CbcModel.hpp:2871
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.
Definition: CbcModel.hpp:1454
int numberStrongIterations() const
Get the number of iterations done in strong branching.
Definition: CbcModel.hpp:2598
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:2162
CoinWarmStartBasis bestSolutionBasis_
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2833
const double * cbcRowLower_
Pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:3044
CbcModel * parentModel_
Parent model.
Definition: CbcModel.hpp:3033
int searchStrategy_
Strategy worked out - mainly at root node.
Definition: CbcModel.hpp:3207
CbcSymmetry * rootSymmetryInfo() const
Root symmetry information.
Definition: CbcModel.hpp:2626
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
Definition: CbcModel.hpp:2722
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2269
int numberStoppedSubTrees_
Number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:3025
CbcNodeInfo ** walkback_
Array used to assemble the path between a node and the search tree root.
Definition: CbcModel.hpp:2920
CbcCutGenerator ** generator_
Definition: CbcModel.hpp:3098
const int * hotstartPriorities() const
Get the hotstart priorities.
Definition: CbcModel.hpp:2548
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
Definition: CbcModel.hpp:919
void setRandomSeed(int value)
Set random seed.
Definition: CbcModel.hpp:2044
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
CbcSymmetry * symmetryInfo_
Symmetry information.
Definition: CbcModel.hpp:3116
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:3058
int getIterationCount() const
Get how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1018
void setStateOfSearch(int state)
Definition: CbcModel.hpp:1756
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
Definition: CbcModel.hpp:1829
CbcCutGenerator ** virginGenerator_
Definition: CbcModel.hpp:3100
CbcBaseModel * master_
Thread stuff for master.
Definition: CbcModel.hpp:3265
const OsiSolverInterface * postProcessedSolver(int solutionType=1)
Returns postProcessed solution in solver(called from event handler) Normally used for integer solutio...
CoinMessages messages_
Cbc messages.
Definition: CbcModel.hpp:2775
int numberHeuristics() const
Get the number of heuristics.
Definition: CbcModel.hpp:1859
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).
Definition: CbcModel.hpp:2905
double getCurrentObjValue() const
Get current objective function value.
Definition: CbcModel.hpp:1438
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:1514
int maximumCutPassesAtRoot_
Maximum number of cut passes at root.
Definition: CbcModel.hpp:3159
void setApplicationData(void *appData)
Set application data.
int * mutableStrongInfo()
Return mutable strong info.
Definition: CbcModel.hpp:2678
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.
Definition: CbcModel.hpp:3027
void pseudoShadow(int type)
Fill in useful estimates.
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1626
void setPrintFrequency(int number)
Set the print frequency.
Definition: CbcModel.hpp:987
double * bestSolution_
Array holding the incumbent (best) solution.
Definition: CbcModel.hpp:2803
void setContinuousObjective(double value)
Definition: CbcModel.hpp:1563
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.
Definition: CbcModel.hpp:2772
void setBranchingMethod(CbcBranchDecision &method)
Set the branching method.
Definition: CbcModel.hpp:1724
double getSolverObjValue() const
Get solver objective function value (as minimization)
Definition: CbcModel.hpp:1476
void unlockThread()
Unlocks a thread if parallel to say cut pool stuff not needed.
bool eventHappened_
Whether event happened.
Definition: CbcModel.hpp:3199
double numberDJFixed_
Number of reduced cost fixings.
Definition: CbcModel.hpp:3189
void setStrongStrategy(int value)
Set strong branching strategy.
Definition: CbcModel.hpp:1776
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: CbcModel.hpp:1208
bool useElapsedTime() const
Get time method.
Definition: CbcModel.hpp:2152
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:2954
void setLogLevel(int value)
Set log level.
void setUseElapsedTime(bool yesNo)
Set time method.
Definition: CbcModel.hpp:2144
int reducedCostFix()
Perform reduced cost fixing.
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
CbcBaseModel * master() const
Thread stuff for master.
Definition: CbcModel.hpp:2366
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:1678
int intParam_[CbcLastIntParam]
Array for integer parameters.
Definition: CbcModel.hpp:2778
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
Definition: CbcModel.hpp:1394
OsiObject ** object_
Integer and Clique and ... information.
Definition: CbcModel.hpp:3132
void setTypePresolve(int value)
Definition: CbcModel.hpp:1696
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:3224
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
Definition: CbcModel.hpp:2139
int currentPassNumber_
Current cut pass number.
Definition: CbcModel.hpp:3165
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.
Definition: CbcModel.hpp:1156
int numberCutGenerators_
Number of cut generators.
Definition: CbcModel.hpp:3096
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:71
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)