Cbc  2.10.3
CbcModel.hpp
Go to the documentation of this file.
1 /* $Id: CbcModel.hpp 2550 2019-04-22 03:46:32Z stefan $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef CbcModel_H
7 #define CbcModel_H
8 #include <string>
9 #include <vector>
10 #include "CoinMessageHandler.hpp"
11 #include "OsiSolverInterface.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiCuts.hpp"
14 #include "CoinWarmStartBasis.hpp"
15 #include "CbcCompareBase.hpp"
16 #include "CbcCountRowCut.hpp"
17 #include "CbcMessage.hpp"
18 #include "CbcEventHandler.hpp"
19 #include "ClpDualRowPivot.hpp"
20 
21 class CbcCutGenerator;
22 class CbcBaseModel;
23 class OsiRowCut;
24 class OsiBabSolver;
25 class OsiRowCutDebugger;
26 class CglCutGenerator;
27 class CglStored;
28 class CbcCutModifier;
29 class CglTreeProbingInfo;
30 class CbcHeuristic;
31 class OsiObject;
32 class CbcThread;
33 class CbcTree;
34 class CbcStrategy;
35 class CbcSymmetry;
36 class CbcFeasibilityBase;
37 class CbcStatistics;
38 class CbcFullNodeInfo;
39 class CbcEventHandler;
40 class CglPreProcess;
42 class ClpNodeStuff;
43 
44 // #define CBC_CHECK_BASIS 1
45 
46 //#############################################################################
47 
100 class CbcModel {
101 
102 public:
103  enum CbcIntParam {
127  };
128 
129  enum CbcDblParam {
193  };
194 
195  //---------------------------------------------------------------------------
196 
197 public:
199 
200 
204  void initialSolve();
205 
216  void branchAndBound(int doStatistics = 0);
217 
218 private:
226  bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node);
234  int serialCuts(OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
242  int parallelCuts(CbcBaseModel *master, OsiCuts &cuts, CbcNode *node, OsiCuts &slackCuts, int lastNumberCuts);
249  CbcNode **solveOneNode(int whichSolver, CbcNode *node,
250  int &numberNodesOutput, int &status);
252  void resizeWhichGenerator(int numberNow, int numberAfter);
253 
254 public:
255 #ifdef CBC_KEEP_DEPRECATED
256  // See if anyone is using these any more!!
261  CbcModel *cleanModel(const double *lower, const double *upper);
278  int subBranchAndBound(CbcModel *model2,
279  CbcModel *presolvedModel,
280  int maximumNodes);
296  int subBranchAndBound(const double *lower, const double *upper,
297  int maximumNodes);
298 
305  OsiSolverInterface *strengthenedModel();
315  CglPreProcess *preProcess(int makeEquality = 0, int numberPasses = 5,
316  int tuning = 5);
319  void postProcess(CglPreProcess *process);
320 #endif
321  inline CglPreProcess *preProcess() const
323  {
324  return preProcess_;
325  }
328  {
329  preProcess_ = preProcess;
330  }
332  void addUpdateInformation(const CbcObjectUpdateData &data);
339  int doOneNode(CbcModel *baseModel, CbcNode *&node, CbcNode *&newNode);
340 
341 public:
355  int resolve(CbcNodeInfo *parent, int whereFrom,
356  double *saveSolution = NULL,
357  double *saveLower = NULL,
358  double *saveUpper = NULL);
360  void makeGlobalCuts(int numberRows, const int *which);
362  int makeGlobalCut(const OsiRowCut *cut);
364  int makeGlobalCut(const OsiRowCut &cut);
366  void makeGlobalCut(const OsiColCut *cut);
368  void makeGlobalCut(const OsiColCut &cut);
370  void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver = NULL);
372  void makeGlobalCuts();
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);
449  void analyzeObjective();
454  const OsiSolverInterface *postProcessedSolver(int solutionType = 1);
455 
459  void AddIntegers();
463  void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible);
467  void flipModel();
481  int cleanBounds(OsiSolverInterface *solver, char *cleanVariables);
483  char *setupCleanVariables();
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 
530 
536 
538  void synchronizeModel();
539 
549  void findIntegers(bool startAgain, int type = 0);
554  void addSOSEtcToSolver();
555 
556 #ifdef SWITCH_VARIABLES
557  int findSwitching();
560  int fixAssociated(OsiSolverInterface *solver, int cleanBasis);
562  int checkAssociated(const OsiSolverInterface *solver,
563  const double *solution, int printLevel);
564 #endif
565 
566 
567  //---------------------------------------------------------------------------
568 
578  inline bool setIntParam(CbcIntParam key, int value)
580  {
581  intParam_[key] = value;
582  return true;
583  }
585  inline bool setDblParam(CbcDblParam key, double value)
586  {
587  dblParam_[key] = value;
588  return true;
589  }
591  inline int getIntParam(CbcIntParam key) const
592  {
593  return intParam_[key];
594  }
596  inline double getDblParam(CbcDblParam key) const
597  {
598  return dblParam_[key];
599  }
605  void setCutoff(double value);
606 
608  inline double getCutoff() const
609  { //double value ;
610  //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
611  //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
612  return dblParam_[CbcCurrentCutoff];
613  }
614 
616  inline bool setMaximumNodes(int value)
617  {
618  return setIntParam(CbcMaxNumNode, value);
619  }
620 
622  inline int getMaximumNodes() const
623  {
624  return getIntParam(CbcMaxNumNode);
625  }
626 
631  inline bool setMaximumSolutions(int value)
632  {
633  return setIntParam(CbcMaxNumSol, value);
634  }
639  inline int getMaximumSolutions() const
640  {
641  return getIntParam(CbcMaxNumSol);
642  }
644  inline bool setPrintingMode(int value)
645  {
646  return setIntParam(CbcPrinting, value);
647  }
648 
650  inline int getPrintingMode() const
651  {
652  return getIntParam(CbcPrinting);
653  }
654 
659  inline bool setMaximumSeconds(double value)
660  {
661  return setDblParam(CbcMaximumSeconds, value);
662  }
667  inline double getMaximumSeconds() const
668  {
670  }
672  double getCurrentSeconds() const;
673 
675  bool maximumSecondsReached() const;
676 
680  inline bool setIntegerTolerance(double value)
681  {
682  return setDblParam(CbcIntegerTolerance, value);
683  }
687  inline double getIntegerTolerance() const
688  {
690  }
691 
696  inline bool setInfeasibilityWeight(double value)
697  {
698  return setDblParam(CbcInfeasibilityWeight, value);
699  }
704  inline double getInfeasibilityWeight() const
705  {
707  }
708 
712  inline bool setAllowableGap(double value)
713  {
714  return setDblParam(CbcAllowableGap, value);
715  }
719  inline double getAllowableGap() const
720  {
722  }
723 
727  inline bool setAllowableFractionGap(double value)
728  {
729  return setDblParam(CbcAllowableFractionGap, value);
730  }
734  inline double getAllowableFractionGap() const
735  {
737  }
741  inline bool setAllowablePercentageGap(double value)
742  {
743  return setDblParam(CbcAllowableFractionGap, value * 0.01);
744  }
748  inline double getAllowablePercentageGap() const
749  {
750  return 100.0 * getDblParam(CbcAllowableFractionGap);
751  }
755  inline bool setHeuristicGap(double value)
756  {
757  return setDblParam(CbcHeuristicGap, value);
758  }
762  inline double getHeuristicGap() const
763  {
765  }
766 
770  inline bool setHeuristicFractionGap(double value)
771  {
772  return setDblParam(CbcHeuristicFractionGap, value);
773  }
777  inline double getHeuristicFractionGap() const
778  {
780  }
785  inline bool setCutoffIncrement(double value)
786  {
787  return setDblParam(CbcCutoffIncrement, value);
788  }
793  inline double getCutoffIncrement() const
794  {
796  }
798  bool canStopOnGap() const;
799 
804  void setHotstartSolution(const double *solution, const int *priorities = NULL);
805 
807  inline void setMinimumDrop(double value)
808  {
809  minimumDrop_ = value;
810  }
812  inline double getMinimumDrop() const
813  {
814  return minimumDrop_;
815  }
816 
819  inline void setMaximumCutPassesAtRoot(int value)
820  {
821  maximumCutPassesAtRoot_ = value;
822  }
824  inline int getMaximumCutPassesAtRoot() const
825  {
826  return maximumCutPassesAtRoot_;
827  }
828 
831  inline void setMaximumCutPasses(int value)
832  {
833  maximumCutPasses_ = value;
834  }
836  inline int getMaximumCutPasses() const
837  {
838  return maximumCutPasses_;
839  }
842  inline int getCurrentPassNumber() const
843  {
844  return currentPassNumber_;
845  }
848  inline void setCurrentPassNumber(int value)
849  {
850  currentPassNumber_ = value;
851  }
852 
858  void setNumberStrong(int number);
862  inline int numberStrong() const
863  {
864  return numberStrong_;
865  }
868  inline void setPreferredWay(int value)
869  {
870  preferredWay_ = value;
871  }
873  inline int getPreferredWay() const
874  {
875  return preferredWay_;
876  }
878  inline int whenCuts() const
879  {
880  return whenCuts_;
881  }
883  inline void setWhenCuts(int value)
884  {
885  whenCuts_ = value;
886  }
892  bool doCutsNow(int allowForTopOfTree) const;
893 
899  void setNumberBeforeTrust(int number);
902  inline int numberBeforeTrust() const
903  {
904  return numberBeforeTrust_;
905  }
911  void setNumberPenalties(int number);
914  inline int numberPenalties() const
915  {
916  return numberPenalties_;
917  }
919  inline const CbcFullNodeInfo *topOfTree() const
920  {
921  return topOfTree_;
922  }
924  inline void setNumberAnalyzeIterations(int number)
925  {
926  numberAnalyzeIterations_ = number;
927  }
928  inline int numberAnalyzeIterations() const
929  {
930  return numberAnalyzeIterations_;
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  }
975  void setOriginalColumns(const int *originalColumns,
976  int numberGood = COIN_INT_MAX);
978  OsiRowCut *conflictCut(const OsiSolverInterface *solver, bool &localCuts);
979 
987  inline void setPrintFrequency(int number)
988  {
989  printFrequency_ = number;
990  }
992  inline int printFrequency() const
993  {
994  return printFrequency_;
995  }
997 
998  //---------------------------------------------------------------------------
1000 
1001  bool isAbandoned() const;
1004  bool isProvenOptimal() const;
1006  bool isProvenInfeasible() const;
1008  bool isContinuousUnbounded() const;
1010  bool isProvenDualInfeasible() const;
1012  bool isNodeLimitReached() const;
1014  bool isSecondsLimitReached() const;
1016  bool isSolutionLimitReached() 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  }
1085  bool isInitialSolveAbandoned() const;
1087  bool isInitialSolveProvenOptimal() const;
1092 
1094 
1095  //---------------------------------------------------------------------------
1108  inline int numberRowsAtContinuous() const
1110  {
1111  return numberRowsAtContinuous_;
1112  }
1113 
1115  inline int getNumCols() const
1116  {
1117  return solver_->getNumCols();
1118  }
1119 
1121  inline int getNumRows() const
1122  {
1123  return solver_->getNumRows();
1124  }
1125 
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());
1229  return dblParam_[CbcOptimizationDirection];
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 
1326  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);
1342  void setBestSolution(CBC_Message how,
1343  double &objectiveValue, const double *solution,
1344  int fixVariables = 0);
1346  void setBestObjectiveValue(double objectiveValue);
1349  double objValue,
1350  const double *solution);
1351 
1359  virtual double checkSolution(double cutoff, double *solution,
1360  int fixVariables, double originalObjValue);
1367  bool feasibleSolution(int &numberIntegerInfeasibilities,
1368  int &numberObjectInfeasibilities) const;
1369 
1375  inline double *currentSolution() const
1376  {
1377  return currentSolution_;
1378  }
1382  inline const double *testSolution() const
1383  {
1384  return testSolution_;
1385  }
1386  inline void setTestSolution(const double *solution)
1387  {
1388  testSolution_ = solution;
1389  }
1391  void reserveCurrentSolution(const double *solution = NULL);
1392 
1394  inline const double *getColSolution() const
1395  {
1396  return solver_->getColSolution();
1397  }
1398 
1400  inline const double *getRowPrice() const
1401  {
1402  return solver_->getRowPrice();
1403  }
1404 
1406  inline const double *getReducedCost() const
1407  {
1408  return solver_->getReducedCost();
1409  }
1410 
1412  inline const double *getRowActivity() const
1413  {
1414  return solver_->getRowActivity();
1415  }
1416 
1418  inline double getCurrentObjValue() const
1419  {
1420  return dblParam_[CbcCurrentObjectiveValue];
1421  }
1423  inline double getCurrentMinimizationObjValue() const
1424  {
1425  return dblParam_[CbcCurrentMinimizationObjectiveValue];
1426  }
1427 
1429  inline double getMinimizationObjValue() const
1430  {
1431  return bestObjective_;
1432  }
1434  inline void setMinimizationObjValue(double value)
1435  {
1436  bestObjective_ = value;
1437  }
1438 
1440  inline double getObjValue() const
1441  {
1442  return bestObjective_ * solver_->getObjSense();
1443  }
1449  double getBestPossibleObjValue() const;
1451  inline void setObjValue(double value)
1452  {
1453  bestObjective_ = value * solver_->getObjSense();
1454  }
1456  inline double getSolverObjValue() const
1457  {
1458  return solver_->getObjValue() * solver_->getObjSense();
1459  }
1460 
1467  inline double *bestSolution() const
1468  {
1469  return bestSolution_;
1470  }
1477  void setBestSolution(const double *solution, int numberColumns,
1478  double objectiveValue, bool check = false);
1479 
1481  inline int getSolutionCount() const
1482  {
1483  return numberSolutions_;
1484  }
1485 
1487  inline void setSolutionCount(int value)
1488  {
1489  numberSolutions_ = value;
1490  }
1492  int numberSavedSolutions() const;
1494  inline int maximumSavedSolutions() const
1495  {
1496  return maximumSavedSolutions_;
1497  }
1499  void setMaximumSavedSolutions(int value);
1501  const double *savedSolution(int which) const;
1503  double savedSolutionObjective(int which) const;
1505  void deleteSavedSolution(int which);
1506 
1515  inline int phase() const
1516  {
1517  return phase_;
1518  }
1519 
1521  inline int getNumberHeuristicSolutions() const
1522  {
1523  return numberHeuristicSolutions_;
1524  }
1526  inline void setNumberHeuristicSolutions(int value)
1527  {
1528  numberHeuristicSolutions_ = value;
1529  }
1530 
1532  inline void setObjSense(double s)
1533  {
1534  dblParam_[CbcOptimizationDirection] = s;
1535  solver_->setObjSense(s);
1536  }
1537 
1539  inline double getContinuousObjective() const
1540  {
1541  return originalContinuousObjective_;
1542  }
1543  inline void setContinuousObjective(double value)
1544  {
1545  originalContinuousObjective_ = value;
1546  }
1548  inline int getContinuousInfeasibilities() const
1549  {
1550  return continuousInfeasibilities_;
1551  }
1552  inline void setContinuousInfeasibilities(int value)
1553  {
1554  continuousInfeasibilities_ = value;
1555  }
1557  inline double rootObjectiveAfterCuts() const
1558  {
1559  return continuousObjective_;
1560  }
1562  inline double sumChangeObjective() const
1563  {
1564  return sumChangeObjective1_;
1565  }
1568  inline int numberGlobalViolations() const
1569  {
1570  return numberGlobalViolations_;
1571  }
1573  {
1574  numberGlobalViolations_ = 0;
1575  }
1577  inline bool resolveAfterTakeOffCuts() const
1578  {
1579  return resolveAfterTakeOffCuts_;
1580  }
1581  inline void setResolveAfterTakeOffCuts(bool yesNo)
1582  {
1583  resolveAfterTakeOffCuts_ = yesNo;
1584  }
1586  inline int maximumRows() const
1587  {
1588  return maximumRows_;
1589  }
1592  {
1593  return workingBasis_;
1594  }
1596  inline int getStopNumberIterations() const
1597  {
1598  return stopNumberIterations_;
1599  }
1601  inline void setStopNumberIterations(int value)
1602  {
1603  stopNumberIterations_ = value;
1604  }
1606  inline CbcModel *heuristicModel() const
1607  {
1608  return heuristicModel_;
1609  }
1611  inline void setHeuristicModel(CbcModel *model)
1612  {
1613  heuristicModel_ = model;
1614  }
1616 
1619  // Comparison functions (which may be overridden by inheritance)
1621  {
1622  return nodeCompare_;
1623  }
1624  void setNodeComparison(CbcCompareBase *compare);
1625  void setNodeComparison(CbcCompareBase &compare);
1627 
1630  // Feasibility functions (which may be overridden by inheritance)
1632  {
1633  return problemFeasibility_;
1634  }
1635  void setProblemFeasibility(CbcFeasibilityBase *feasibility);
1636  void setProblemFeasibility(CbcFeasibilityBase &feasibility);
1638 
1641  inline CbcTree *tree() const
1643  {
1644  return tree_;
1645  }
1651  void passInSubTreeModel(CbcModel &model);
1658  inline int numberStoppedSubTrees() const
1659  {
1660  return numberStoppedSubTrees_;
1661  }
1664  {
1665  numberStoppedSubTrees_++;
1666  }
1672  inline int typePresolve() const
1673  {
1674  return presolve_;
1675  }
1676  inline void setTypePresolve(int value)
1677  {
1678  presolve_ = value;
1679  }
1680 
1682 
1688 
1691  {
1692  return branchingMethod_;
1693  }
1696  {
1697  delete branchingMethod_;
1698  branchingMethod_ = method->clone();
1699  }
1705  {
1706  delete branchingMethod_;
1707  branchingMethod_ = method.clone();
1708  }
1710  inline CbcCutModifier *cutModifier() const
1711  {
1712  return cutModifier_;
1713  }
1715  void setCutModifier(CbcCutModifier *modifier);
1720  void setCutModifier(CbcCutModifier &modifier);
1722 
1725 
1732  inline int stateOfSearch() const
1733  {
1734  return stateOfSearch_;
1735  }
1736  inline void setStateOfSearch(int state)
1737  {
1738  stateOfSearch_ = state;
1739  }
1741  inline int searchStrategy() const
1742  {
1743  return searchStrategy_;
1744  }
1746  inline void setSearchStrategy(int value)
1747  {
1748  searchStrategy_ = value;
1749  }
1751  inline int strongStrategy() const
1752  {
1753  return strongStrategy_;
1754  }
1756  inline void setStrongStrategy(int value)
1757  {
1758  strongStrategy_ = value;
1759  }
1760 
1762  inline int numberCutGenerators() const
1763  {
1764  return numberCutGenerators_;
1765  }
1768  {
1769  return generator_;
1770  }
1772  inline CbcCutGenerator *cutGenerator(int i) const
1773  {
1774  return generator_[i];
1775  }
1778  {
1779  return virginGenerator_[i];
1780  }
1789  void addCutGenerator(CglCutGenerator *generator,
1790  int howOften = 1, const char *name = NULL,
1791  bool normal = true, bool atSolution = false,
1792  bool infeasible = false, int howOftenInSub = -100,
1793  int whatDepth = -1, int whatDepthInSub = -1);
1795 
1800 
1802  inline CbcStrategy *strategy() const
1803  {
1804  return strategy_;
1805  }
1810  {
1811  strategy_ = strategy;
1812  }
1814  inline CbcModel *parentModel() const
1815  {
1816  return parentModel_;
1817  }
1820  {
1821  parentModel_ = &parentModel;
1822  }
1824 
1831  void addHeuristic(CbcHeuristic *generator, const char *name = NULL,
1832  int before = -1);
1834  inline CbcHeuristic *heuristic(int i) const
1835  {
1836  return heuristic_[i];
1837  }
1839  inline int numberHeuristics() const
1840  {
1841  return numberHeuristics_;
1842  }
1844  inline void setNumberHeuristics(int value)
1845  {
1846  numberHeuristics_ = value;
1847  }
1849  inline CbcHeuristic *lastHeuristic() const
1850  {
1851  return lastHeuristic_;
1852  }
1854  inline void setLastHeuristic(CbcHeuristic *last)
1855  {
1856  lastHeuristic_ = last;
1857  }
1858 
1877  void passInPriorities(const int *priorities, bool ifNotSimpleIntegers);
1878 
1880  inline int priority(int sequence) const
1881  {
1882  return object_[sequence]->priority();
1883  }
1884 
1889  void passInEventHandler(const CbcEventHandler *eventHandler);
1890 
1893  {
1894  return (eventHandler_);
1895  }
1896 
1898 
1908  void setApplicationData(void *appData);
1909 
1911  void *getApplicationData() const;
1926  inline const OsiBabSolver *solverCharacteristics() const
1927  {
1928  return solverCharacteristics_;
1929  }
1931 
1932  //---------------------------------------------------------------------------
1933 
1939  void newLanguage(CoinMessages::Language language);
1940  inline void setLanguage(CoinMessages::Language language)
1941  {
1942  newLanguage(language);
1943  }
1946  {
1947  return handler_;
1948  }
1951  {
1952  return messages_;
1953  }
1956  {
1957  return &messages_;
1958  }
1960  void setLogLevel(int value);
1962  inline int logLevel() const
1963  {
1964  return handler_->logLevel();
1965  }
1971  inline void setDefaultHandler(bool yesNo)
1972  {
1973  defaultHandler_ = yesNo;
1974  }
1976  inline bool defaultHandler() const
1977  {
1978  return defaultHandler_;
1979  }
1981  //---------------------------------------------------------------------------
1983 
1984 
2014  inline void setSpecialOptions(int value)
2015  {
2016  specialOptions_ = value;
2017  }
2019  inline int specialOptions() const
2020  {
2021  return specialOptions_;
2022  }
2024  inline void setRandomSeed(int value)
2025  {
2026  randomSeed_ = value;
2027  }
2029  inline int getRandomSeed() const
2030  {
2031  return randomSeed_;
2032  }
2034  inline void setMultipleRootTries(int value)
2035  {
2036  multipleRootTries_ = value;
2037  }
2039  inline int getMultipleRootTries() const
2040  {
2041  return multipleRootTries_;
2042  }
2044  inline void sayEventHappened()
2045  {
2046  eventHappened_ = true;
2047  }
2049  inline bool normalSolver() const
2050  {
2051  return (specialOptions_ & 16) == 0;
2052  }
2057  inline bool waitingForMiniBranchAndBound() const
2058  {
2059  return (specialOptions_ & 1048576) != 0;
2060  }
2084  inline void setMoreSpecialOptions(int value)
2085  {
2086  moreSpecialOptions_ = value;
2087  }
2089  inline int moreSpecialOptions() const
2090  {
2091  return moreSpecialOptions_;
2092  }
2108  inline void setMoreSpecialOptions2(int value)
2109  {
2110  moreSpecialOptions2_ = value;
2111  }
2113  inline int moreSpecialOptions2() const
2114  {
2115  return moreSpecialOptions2_;
2116  }
2118  inline void setCutoffAsConstraint(bool yesNo)
2119  {
2120  cutoffRowNumber_ = (yesNo) ? -2 : -1;
2121  }
2123  inline void setUseElapsedTime(bool yesNo)
2124  {
2125  if (yesNo)
2126  moreSpecialOptions_ |= 131072;
2127  else
2128  moreSpecialOptions_ &= ~131072;
2129  }
2131  inline bool useElapsedTime() const
2132  {
2133  return (moreSpecialOptions_ & 131072) != 0;
2134  }
2136  inline void *temporaryPointer() const
2137  {
2138  return temporaryPointer_;
2139  }
2141  inline void setTemporaryPointer(void *pointer)
2142  {
2143  temporaryPointer_ = pointer;
2144  }
2146  void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod);
2148  inline bool ownObjects() const
2149  {
2150  return ownObjects_;
2151  }
2153  void checkModel();
2155  //---------------------------------------------------------------------------
2156 
2158 
2159  CbcModel();
2161 
2163  CbcModel(const OsiSolverInterface &);
2164 
2173  void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
2174 
2186  inline void setModelOwnsSolver(bool ourSolver)
2187  {
2188  ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000));
2189  }
2190 
2196  inline bool modelOwnsSolver()
2197  {
2198  return ((ownership_ & 0x80000000) != 0);
2199  }
2200 
2204  CbcModel(const CbcModel &rhs, bool cloneHandler = false);
2205 
2207  virtual CbcModel *clone(bool cloneHandler);
2208 
2210  CbcModel &operator=(const CbcModel &rhs);
2211 
2213  virtual ~CbcModel();
2214 
2216  inline OsiSolverInterface *solver() const
2217  {
2218  return solver_;
2219  }
2220 
2223  {
2224  OsiSolverInterface *returnSolver = solver_;
2225  solver_ = solver;
2226  return returnSolver;
2227  }
2228 
2231  {
2232  return continuousSolver_;
2233  }
2234 
2237  {
2238  continuousSolver_ = solver_->clone();
2239  }
2242  {
2243  delete continuousSolver_;
2244  continuousSolver_ = NULL;
2245  }
2246 
2249  {
2250  return referenceSolver_;
2251  }
2252 
2254  void saveReferenceSolver();
2255 
2261  void resetToReferenceSolver();
2262 
2264  void gutsOfDestructor();
2267  void gutsOfDestructor2();
2270  void resetModel();
2276  void gutsOfCopy(const CbcModel &rhs, int mode = 0);
2278  void moveInfo(const CbcModel &rhs);
2280 
2282 
2283  static bool haveMultiThreadSupport();
2287  {
2288  return masterThread_;
2289  }
2292  {
2293  return walkback_;
2294  }
2296  inline int getNumberThreads() const
2297  {
2298  return numberThreads_;
2299  }
2301  inline void setNumberThreads(int value)
2302  {
2303  numberThreads_ = value;
2304  }
2306  inline int getThreadMode() const
2307  {
2308  return threadMode_;
2309  }
2319  inline void setThreadMode(int value)
2320  {
2321  threadMode_ = value;
2322  }
2329  inline int parallelMode() const
2330  {
2331  if (!numberThreads_) {
2332  if ((threadMode_ & 1) == 0)
2333  return 0;
2334  else
2335  return -1;
2336  return 0;
2337  } else {
2338  if ((threadMode_ & 1) == 0)
2339  return 1;
2340  else
2341  return -2;
2342  }
2343  }
2345  inline CbcBaseModel *master() const
2346  {
2347  return master_;
2348  }
2351  bool isLocked() const;
2352 #ifdef CBC_THREAD
2353 
2357  void lockThread();
2361  void unlockThread();
2362 #else
2363  inline void lockThread()
2364  {
2365  }
2366  inline void unlockThread() {}
2367 #endif
2368 
2375  void setInfoInChild(int type, CbcThread *info);
2382  void moveToModel(CbcModel *baseModel, int mode);
2384  int splitModel(int numberModels, CbcModel **model,
2385  int numberNodes);
2387  void startSplitModel(int numberIterations);
2389  void mergeModels(int numberModel, CbcModel **model,
2390  int numberNodes);
2392 
2394 
2395  int getNodeCount2() const
2397  {
2398  return numberNodes2_;
2399  }
2401  void setPointers(const OsiSolverInterface *solver);
2407  int reducedCostFix();
2411  void synchronizeHandlers(int makeDefault);
2413  void saveExtraSolution(const double *solution, double objectiveValue);
2415  void saveBestSolution(const double *solution, double objectiveValue);
2417  void deleteSolutions();
2420 #ifdef CLP_RESOLVE
2421  int resolveClp(OsiClpSolverInterface *solver, int type);
2423 #endif
2424 
2428  int chooseBranch(CbcNode *&newNode, int numberPassesLeft,
2429  CbcNode *oldNode, OsiCuts &cuts,
2430  bool &resolved, CoinWarmStartBasis *lastws,
2431  const double *lowerBefore, const double *upperBefore,
2432  OsiSolverBranch *&branches);
2433  int chooseBranch(CbcNode *newNode, int numberPassesLeft, bool &resolved);
2434 
2441  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const;
2442 
2454  int takeOffCuts(OsiCuts &cuts,
2455  bool allowResolve, OsiCuts *saveCuts,
2456  int numberNewCuts = 0, const OsiRowCut **newCuts = NULL);
2457 
2470  int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws);
2471 
2488  bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws);
2492  void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn,
2493  double &lower, double &upper, int force);
2498  void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const;
2499 
2503  void convertToDynamic();
2505  void synchronizeNumberBeforeTrust(int type = 0);
2507  void zapIntegerInformation(bool leaveObjects = true);
2509  int cliquePseudoCosts(int doStatistics);
2511  void pseudoShadow(int type);
2518  void fillPseudoCosts(double *downCosts, double *upCosts,
2519  int *priority = NULL,
2520  int *numberDown = NULL, int *numberUp = NULL,
2521  int *numberDownInfeasible = NULL,
2522  int *numberUpInfeasible = NULL) const;
2528  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
2530  void adjustHeuristics();
2532  inline const double *hotstartSolution() const
2533  {
2534  return hotstartSolution_;
2535  }
2537  inline const int *hotstartPriorities() const
2538  {
2539  return hotstartPriorities_;
2540  }
2541 
2543  inline CbcCountRowCut **addedCuts() const
2544  {
2545  return addedCuts_;
2546  }
2548  inline int currentNumberCuts() const
2549  {
2550  return currentNumberCuts_;
2551  }
2554  {
2555  return &globalCuts_;
2556  }
2558  inline void zapGlobalCuts()
2559  {
2560  globalCuts_ = CbcRowCuts();
2561  }
2563  void setNextRowCut(const OsiRowCut &cut);
2565  inline CbcNode *currentNode() const
2566  {
2567  return currentNode_;
2568  }
2570  void deleteNode(CbcNode * node);
2573  {
2574  return probingInfo_;
2575  }
2578  {
2579  return &randomNumberGenerator_;
2580  }
2582  inline void setNumberStrongIterations(int number)
2583  {
2584  numberStrongIterations_ = number;
2585  }
2587  inline int numberStrongIterations() const
2588  {
2589  return numberStrongIterations_;
2590  }
2592  inline int maximumNumberIterations() const
2593  {
2594  return maximumNumberIterations_;
2595  }
2597  inline void setMaximumNumberIterations(int value)
2598  {
2599  maximumNumberIterations_ = value;
2600  }
2601 #ifdef COIN_HAS_NTY
2602  inline CbcSymmetry *symmetryInfo() const
2604  {
2605  return symmetryInfo_;
2606  }
2608  void zapSymmetry();
2609 #endif
2610  inline void setFastNodeDepth(int value)
2612  {
2613  fastNodeDepth_ = value;
2614  }
2616  inline int fastNodeDepth() const
2617  {
2618  return fastNodeDepth_;
2619  }
2621  inline int continuousPriority() const
2622  {
2623  return continuousPriority_;
2624  }
2626  inline void setContinuousPriority(int value)
2627  {
2628  continuousPriority_ = value;
2629  }
2630  inline void incrementExtra(int nodes, int iterations, int fathoms = 1)
2631  {
2632  numberExtraNodes_ += nodes;
2633  numberExtraIterations_ += iterations;
2634  numberFathoms_ += fathoms;
2635  }
2637  inline void zeroExtra()
2638  {
2639  numberExtraNodes_ = 0;
2640  numberExtraIterations_ = 0;
2641  numberFathoms_ = 0;
2642  }
2644  inline int numberExtraIterations() const
2645  {
2646  return numberExtraIterations_;
2647  }
2649  void incrementStrongInfo(int numberTimes, int numberIterations,
2650  int numberFixed, bool ifInfeasible);
2652  inline const int *strongInfo() const
2653  {
2654  return strongInfo_;
2655  }
2656 
2658  inline int *mutableStrongInfo()
2659  {
2660  return strongInfo_;
2661  }
2664  {
2665  return storedRowCuts_;
2666  }
2669  {
2670  storedRowCuts_ = cuts;
2671  }
2673  inline bool allDynamic() const
2674  {
2675  return ((ownership_ & 0x40000000) != 0);
2676  }
2678  void generateCpp(FILE *fp, int options);
2687  inline void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
2688  {
2689  bestSolutionBasis_ = bestSolutionBasis;
2690  }
2692  void redoWalkBack();
2694 
2695  void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
2696  {
2697  this->mipStart_ = mipstart;
2698  }
2699 
2702  void setKeepNamesPreproc( bool _keep )
2703  {
2704  this->keepNamesPreproc = _keep;
2705  }
2706 
2707  bool getKeepNamesPreproc() const
2708  {
2709  return keepNamesPreproc;
2710  }
2711 
2714  void setMIPStart(int count, const char **colNames, const double colValues[]);
2715 
2716 
2717  const std::vector< std::pair< std::string, double > > &getMIPStart()
2718  {
2719  return this->mipStart_;
2720  }
2721 
2722  //---------------------------------------------------------------------------
2723 
2724 private:
2726 
2727 
2729  OsiSolverInterface *solver_;
2730 
2736  unsigned int ownership_;
2737 
2739  OsiSolverInterface *continuousSolver_;
2740 
2742  OsiSolverInterface *referenceSolver_;
2743 
2745  CoinMessageHandler *handler_;
2746 
2752  bool defaultHandler_;
2753 
2755  CoinMessages messages_;
2756 
2758  int intParam_[CbcLastIntParam];
2759 
2761  double dblParam_[CbcLastDblParam];
2762 
2771  mutable CoinWarmStart *emptyWarmStart_;
2772 
2774  double bestObjective_;
2776  double bestPossibleObjective_;
2778  double sumChangeObjective1_;
2780  double sumChangeObjective2_;
2781 
2783  double *bestSolution_;
2785  double **savedSolutions_;
2786 
2791  double *currentSolution_;
2795  mutable const double *testSolution_;
2799  std::vector< std::pair< std::string, double > > mipStart_;
2800 
2805  bool keepNamesPreproc;
2806 
2813  CoinWarmStartBasis bestSolutionBasis_;
2815  CbcRowCuts globalCuts_;
2817  CbcRowCuts *globalConflictCuts_;
2818 
2820  double minimumDrop_;
2822  int numberSolutions_;
2824  int numberSavedSolutions_;
2826  int maximumSavedSolutions_;
2833  int stateOfSearch_;
2835  int whenCuts_;
2837  double *hotstartSolution_;
2839  int *hotstartPriorities_;
2841  int numberHeuristicSolutions_;
2843  int numberNodes_;
2847  int numberNodes2_;
2849  int numberIterations_;
2851  int numberSolves_;
2853  int status_;
2864  int secondaryStatus_;
2866  int numberIntegers_;
2868  int numberRowsAtContinuous_;
2874  int cutoffRowNumber_;
2876  int maximumNumberCuts_;
2885  int phase_;
2886 
2888  int currentNumberCuts_;
2889 
2894  int maximumDepth_;
2900  CbcNodeInfo **walkback_;
2902  CglPreProcess *preProcess_;
2903  CbcNodeInfo **lastNodeInfo_;
2904  const OsiRowCut **lastCut_;
2905  int lastDepth_;
2906  int lastNumberCuts2_;
2907  int maximumCuts_;
2908  int *lastNumberCuts_;
2909 
2917  CbcCountRowCut **addedCuts_;
2918 
2922  OsiRowCut *nextRowCut_;
2923 
2925  CbcNode *currentNode_;
2926 
2928  int *integerVariable_;
2930  char *integerInfo_;
2932  double *continuousSolution_;
2934  int *usedInSolution_;
2962  int specialOptions_;
2977  int moreSpecialOptions_;
2991  int moreSpecialOptions2_;
2993  CbcCompareBase *nodeCompare_;
2995  CbcFeasibilityBase *problemFeasibility_;
2997  CbcTree *tree_;
2999  CbcFullNodeInfo *topOfTree_;
3001  CbcModel *subTreeModel_;
3003  CbcModel *heuristicModel_;
3005  int numberStoppedSubTrees_;
3007  CbcBranchDecision *branchingMethod_;
3009  CbcCutModifier *cutModifier_;
3011  CbcStrategy *strategy_;
3013  CbcModel *parentModel_;
3019  const double *cbcColLower_;
3022  const double *cbcColUpper_;
3024  const double *cbcRowLower_;
3026  const double *cbcRowUpper_;
3028  const double *cbcColSolution_;
3030  const double *cbcRowPrice_;
3032  const double *cbcReducedCost_;
3034  const double *cbcRowActivity_;
3036  void *appData_;
3038  int presolve_;
3042  int numberStrong_;
3048  int numberBeforeTrust_;
3052  int numberPenalties_;
3054  int stopNumberIterations_;
3057  double penaltyScaleFactor_;
3059  int numberAnalyzeIterations_;
3061  double *analyzeResults_;
3063  void *temporaryPointer_;
3065  int numberInfeasibleNodes_;
3072  int problemType_;
3074  int printFrequency_;
3076  int numberCutGenerators_;
3077  // Cut generators
3078  CbcCutGenerator **generator_;
3079  // Cut generators before any changes
3080  CbcCutGenerator **virginGenerator_;
3082  int numberHeuristics_;
3084  CbcHeuristic **heuristic_;
3086  CbcHeuristic *lastHeuristic_;
3088  int fastNodeDepth_;
3090 #ifdef CBC_ONLY_CLP
3091  ClpEventHandler *eventHandler_;
3092 #else
3093  CbcEventHandler *eventHandler_;
3094 #endif
3095  CbcSymmetry *symmetryInfo_;
3098  int numberObjects_;
3099 
3110  OsiObject **object_;
3112  bool ownObjects_;
3113 
3115  int *originalColumns_;
3117  int howOftenGlobalScan_;
3120  int numberGlobalViolations_;
3122  int numberExtraIterations_;
3124  int numberExtraNodes_;
3126  int numberFathoms_;
3130  double continuousObjective_;
3133  double originalContinuousObjective_;
3135  int continuousInfeasibilities_;
3137  int maximumCutPassesAtRoot_;
3139  int maximumCutPasses_;
3141  int preferredWay_;
3143  int currentPassNumber_;
3145  int maximumWhich_;
3147  int maximumRows_;
3149  int randomSeed_;
3151  int multipleRootTries_;
3153  int currentDepth_;
3155  mutable CoinThreadRandom randomNumberGenerator_;
3157  CoinWarmStartBasis workingBasis_;
3159  int *whichGenerator_;
3161  int maximumStatistics_;
3163  CbcStatistics **statistics_;
3165  int maximumDepthActual_;
3167  double numberDJFixed_;
3169  CglTreeProbingInfo *probingInfo_;
3171  int numberFixedAtRoot_;
3173  int numberFixedNow_;
3175  bool stoppedOnGap_;
3177  mutable bool eventHappened_;
3179  int numberLongStrong_;
3181  int numberOldActiveCuts_;
3183  int numberNewCuts_;
3185  int searchStrategy_;
3197  int strongStrategy_;
3199  int numberStrongIterations_;
3202  int strongInfo_[7];
3209  OsiBabSolver *solverCharacteristics_;
3211  bool resolveAfterTakeOffCuts_;
3213  int maximumNumberIterations_;
3215  int continuousPriority_;
3217  int numberUpdateItems_;
3219  int maximumNumberUpdateItems_;
3221  CbcObjectUpdateData *updateItems_;
3223  CglStored *storedRowCuts_;
3231  int numberThreads_;
3239  int threadMode_;
3241  int numberGlobalCutsIn_;
3243  CbcBaseModel *master_;
3245  CbcThread *masterThread_;
3247 };
3249 void getIntegerInformation(const OsiObject *object, double &originalLower,
3250  double &originalUpper);
3251 // So we can call from other programs
3252 // Real main program
3253 class OsiClpSolverInterface;
3254 int CbcMain(int argc, const char *argv[], OsiClpSolverInterface &solver, CbcModel **babSolver);
3255 int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
3256 // four ways of calling
3257 int callCbc(const char *input2, OsiClpSolverInterface &solver1);
3258 int callCbc(const char *input2);
3259 int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
3260 int callCbc(const std::string input2);
3261 // When we want to load up CbcModel with options first
3262 void CbcMain0(CbcModel &babSolver);
3263 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
3264 // two ways of calling
3265 int callCbc(const char *input2, CbcModel &babSolver);
3266 int callCbc(const std::string input2, CbcModel &babSolver);
3267 // And when CbcMain0 already called to initialize
3268 int callCbc1(const char *input2, CbcModel &babSolver);
3269 int callCbc1(const std::string input2, CbcModel &babSolver);
3270 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
3271 int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3272 int callCbc1(const std::string input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3273 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3274 // For uniform setting of cut and heuristic options
3275 void setCutAndHeuristicOptions(CbcModel &model);
3276 #endif
3277 
3278 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
3279 */
void flipModel()
Flip direction of optimization on all models.
bool isInitialSolveProvenOptimal() const
Is optimality proven (for initialSolve) ?
void passInSolverCharacteristics(OsiBabSolver *solverCharacteristics)
For advanced applications you may wish to modify the behavior of Cbc e.g.
const OsiObject * object(int which) const
Get the specified object.
Definition: CbcModel.hpp:510
void setProblemFeasibility(CbcFeasibilityBase *feasibility)
double getDblParam(CbcDblParam key) const
Get a double parameter.
Definition: CbcModel.hpp:596
The objective is assumed to worsen by this amount for each integer infeasibility. ...
Definition: CbcModel.hpp:135
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2621
void resetToReferenceSolver()
Uses a copy of reference solver to be current solver.
bool waitingForMiniBranchAndBound() const
Says if model is sitting there waiting for mini branch and bound to finish This is because an event h...
Definition: CbcModel.hpp:2057
int getMaximumCutPasses() const
Get the maximum number of cut passes at other nodes (default 10)
Definition: CbcModel.hpp:836
Number of branches (may be more than number of nodes as may include strong branching) ...
Definition: CbcModel.hpp:124
void newLanguage(CoinMessages::Language language)
Set language.
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
Definition: CbcModel.hpp:1162
virtual const double * getRowActivity() const=0
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.
void setPointers(const OsiSolverInterface *solver)
Set pointers for speed.
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1606
CbcNodeInfo ** walkback() const
Get pointer to walkback.
Definition: CbcModel.hpp:2291
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
Current objective value.
Definition: CbcModel.hpp:161
virtual CoinBigIndex getNumElements() const=0
void setLastHeuristic(CbcHeuristic *last)
set last heuristic which found a solution
Definition: CbcModel.hpp:1854
double getCurrentObjValue() const
Get current objective function value.
Definition: CbcModel.hpp:1418
Event handling for cbc.
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
Definition: CbcModel.hpp:1412
virtual OsiSolverInterface * clone(bool copyData=true) const=0
OsiBranchingInformation usefulInformation() const
Generate an OsiBranchingInformation object.
void setOptionalInteger(int index)
int logLevel() const
Get log level.
Definition: CbcModel.hpp:1962
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
Definition: CbcModel.hpp:1690
void setRandomSeed(int value)
Set random seed.
Definition: CbcModel.hpp:2024
bool setAllowableFractionGap(double value)
Set the fraction allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:727
const std::vector< std::pair< std::string, double > > & getMIPStart()
Definition: CbcModel.hpp:2717
int getMaximumNodes() const
Get the maximum node limit .
Definition: CbcModel.hpp:622
int currentNumberCuts() const
Number of entries in the list returned by addedCuts()
Definition: CbcModel.hpp:2548
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:1293
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
Definition: CbcModel.hpp:1880
void incrementStrongInfo(int numberTimes, int numberIterations, int numberFixed, bool ifInfeasible)
Increment strong info.
int CbcMain(int argc, const char *argv[], OsiClpSolverInterface &solver, CbcModel **babSolver)
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
Definition: CbcModel.hpp:2118
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:1288
CglTreeProbingInfo * probingInfo() const
Get a pointer to probing info.
Definition: CbcModel.hpp:2572
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
Definition: CbcModel.hpp:1109
The maximum number of nodes before terminating.
Definition: CbcModel.hpp:105
void setFastNodeDepth(int value)
Set depth for fast nodes.
Definition: CbcModel.hpp:2611
int getMaximumSolutions() const
Get the maximum number of solutions desired.
Definition: CbcModel.hpp:639
double * currentSolution() const
Solution to the most recent lp relaxation.
Definition: CbcModel.hpp:1375
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver–>getColSolution() ...
Definition: CbcModel.hpp:1382
void setNumberStrongIterations(int number)
Set the number of iterations done in strong branching.
Definition: CbcModel.hpp:2582
bool defaultHandler() const
Check default handler.
Definition: CbcModel.hpp:1976
double getInfinity() const
Get solver&#39;s value for infinity.
Definition: CbcModel.hpp:1278
bool setHeuristicFractionGap(double value)
Set the fraction heuristic gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:770
void setStrongStrategy(int value)
Set strong branching strategy.
Definition: CbcModel.hpp:1756
int * mutableStrongInfo()
Return mutable strong info.
Definition: CbcModel.hpp:2658
virtual CbcModel * clone(bool cloneHandler)
Clone.
CbcNode * currentNode() const
Get a pointer to current node (be careful)
Definition: CbcModel.hpp:2565
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2592
virtual const char * getRowSense() const=0
int specialOptions() const
Get special options.
Definition: CbcModel.hpp:2019
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1611
void setCurrentPassNumber(int value)
Set current cut pass number in this round of cuts.
Definition: CbcModel.hpp:848
bool isNodeLimitReached() const
Node limit reached?
void setResolveAfterTakeOffCuts(bool yesNo)
Definition: CbcModel.hpp:1581
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:1303
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: CbcModel.hpp:1214
int numberExtraIterations() const
Number of extra iterations.
Definition: CbcModel.hpp:2644
void incrementNodeCount(int value)
Increment how many nodes it took to solve the problem.
Definition: CbcModel.hpp:1033
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
Definition: CbcModel.hpp:2626
double getIntegerTolerance() const
Get the integrality tolerance .
Definition: CbcModel.hpp:687
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
Definition: CbcModel.hpp:1266
int callCbc(const char *input2, OsiClpSolverInterface &solver1)
virtual bool isFreeBinary(int colIndex) const
void lockThread()
Definition: CbcModel.hpp:2363
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:192
virtual bool isIntegerNonBinary(int colIndex) const
bool setInfeasibilityWeight(double value)
Set the weight per integer infeasibility .
Definition: CbcModel.hpp:696
void reserveCurrentSolution(const double *solution=NULL)
Make sure region there and optionally copy solution.
bool getKeepNamesPreproc() const
Definition: CbcModel.hpp:2707
bool setIntegerTolerance(double value)
Set the integrality tolerance .
Definition: CbcModel.hpp:680
double getInfeasibilityWeight() const
Get the weight per integer infeasibility .
Definition: CbcModel.hpp:704
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
Definition: CbcModel.hpp:1260
bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws)
Traverse the tree from node to root and prep the model.
bool setMaximumSolutions(int value)
Set the maximum number of solutions desired.
Definition: CbcModel.hpp:631
Cutoff - stored for speed.
Definition: CbcModel.hpp:157
int numberBeforeTrust() const
get the number of branches before pseudo costs believed in dynamic strong branching.
Definition: CbcModel.hpp:902
virtual const double * getRowPrice() const=0
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
Definition: CbcModel.hpp:1400
int getNumCols() const
Get number of columns.
Definition: CbcModel.hpp:1115
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
Definition: CbcModel.hpp:1591
int getPrintingMode() const
Get the printing mode.
Definition: CbcModel.hpp:650
virtual const CoinPackedMatrix * getMatrixByCol() const=0
char * setupCleanVariables()
Sets up cleanVariables array (i.e. ones to be careful about)
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2668
bool setDblParam(CbcDblParam key, double value)
Set a double parameter.
Definition: CbcModel.hpp:585
void clearContinuousSolver()
Clear solver with continuous state.
Definition: CbcModel.hpp:2241
CoinMessages * messagesPointer()
Return pointer to messages.
Definition: CbcModel.hpp:1955
void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver=NULL)
Make partial cut into a global cut and save.
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
Definition: CbcModel.hpp:1526
int getMultipleRootTries() const
Get multiple root tries.
Definition: CbcModel.hpp:2039
Sum of non-zero changes on a branch.
Definition: CbcModel.hpp:186
double penaltyScaleFactor() const
Get scale factor to make penalties match strong.
Definition: CbcModel.hpp:934
bool modelOwnsSolver()
Get ownership of solver.
Definition: CbcModel.hpp:2196
void setPreProcess(CglPreProcess *preProcess)
Set CglPreProcess used before branch and bound.
Definition: CbcModel.hpp:327
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
Definition: CbcModel.hpp:2702
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
Definition: CbcModel.hpp:2186
void setNumberAnalyzeIterations(int number)
Number of analyze iterations to do.
Definition: CbcModel.hpp:924
int numberAnalyzeIterations() const
Definition: CbcModel.hpp:928
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
Definition: CbcModel.hpp:2319
int takeOffCuts(OsiCuts &cuts, bool allowResolve, OsiCuts *saveCuts, int numberNewCuts=0, const OsiRowCut **newCuts=NULL)
Remove inactive cuts from the model.
void setNumberThreads(int value)
Set number of threads.
Definition: CbcModel.hpp:2301
bool isProvenInfeasible() const
Is infeasiblity proven (or none better than cutoff)?
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
Definition: CbcModel.hpp:1327
void * getApplicationData() const
Get application data.
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
void setPrintFrequency(int number)
Set the print frequency.
Definition: CbcModel.hpp:987
int problemType() const
Definition: CbcModel.hpp:952
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
Definition: CbcModel.hpp:1767
CoinMessageHandler * messageHandler() const
Return handler.
Definition: CbcModel.hpp:1945
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...
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
void setNumberStrong(int number)
Set the maximum number of candidates to be evaluated for strong branching.
void setLanguage(CoinMessages::Language language)
Definition: CbcModel.hpp:1940
OsiRowCut * conflictCut(const OsiSolverInterface *solver, bool &localCuts)
Create conflict cut (well - most of)
void passInTreeHandler(CbcTree &tree)
For modifying tree handling (original is cloned)
void incrementUsed(const double *solution)
Increases usedInSolution for nonzeros.
void unlockThread()
Definition: CbcModel.hpp:2366
void convertToDynamic()
If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:1318
bool setAllowablePercentageGap(double value)
Set the percentage allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:741
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
Definition: CbcModel.hpp:1695
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
Definition: CbcModel.hpp:1283
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
int getIterationCount() const
Get how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1018
int cliquePseudoCosts(int doStatistics)
Use cliques for pseudocost information - return nonzero if infeasible.
Adjusts printout 1 does different node message with number unsatisfied on last branch.
Definition: CbcModel.hpp:121
char integerType(int i) const
Whether or not integer.
Definition: CbcModel.hpp:1143
void setApplicationData(void *appData)
Set application data.
double getAllowablePercentageGap() const
Get the percentage allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:748
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
Definition: CbcModel.hpp:152
bool isSolutionLimitReached() const
Solution limit reached?
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:793
int getFathomCount() const
Get how many times complete fathoming B&B was done.
Definition: CbcModel.hpp:1043
void setStrategy(CbcStrategy &strategy)
Set the strategy. Clones.
void setSearchStrategy(int value)
Set strategy worked out - mainly at root node for use by CbcNode.
Definition: CbcModel.hpp:1746
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
void deleteSolutions()
Delete best and saved solutions.
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
bool canStopOnGap() const
See if can stop on gap.
double getContinuousObjective() const
Value of objective at continuous.
Definition: CbcModel.hpp:1539
virtual int getNumCols() const=0
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:1313
void makeGlobalCuts()
Make partial cuts into global cuts.
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
Definition: CbcModel.hpp:1521
void setMoreSpecialOptions(int value)
Set more special options at present bottom 6 bits used for shadow price mode 1024 for experimental ho...
Definition: CbcModel.hpp:2084
bool isContinuous(int colIndex) const
Return true if variable is continuous.
Definition: CbcModel.hpp:1233
bool setPrintingMode(int value)
Set the printing mode.
Definition: CbcModel.hpp:644
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
Definition: CbcModel.hpp:1971
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
Definition: CbcModel.hpp:608
double getObjValue() const
Get best objective function value.
Definition: CbcModel.hpp:1440
int numberStrong() const
Get the maximum number of candidates to be evaluated for strong branching.
Definition: CbcModel.hpp:862
void setCutAndHeuristicOptions(CbcModel &model)
void moveToModel(CbcModel *baseModel, int mode)
Move/copy information from one model to another -1 - initialization 0 - from base model 1 - to base m...
Fathoming discipline.
Definition: CbcModel.hpp:117
int numberSavedSolutions() const
Number of saved solutions (including best)
void incrementSubTreeStopped()
Says a sub tree was stopped.
Definition: CbcModel.hpp:1663
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
Definition: CbcModel.hpp:824
void zapGlobalCuts()
Get rid of global cuts.
Definition: CbcModel.hpp:2558
virtual bool isInteger(int colIndex) const
double getSolverObjValue() const
Get solver objective function value (as minimization)
Definition: CbcModel.hpp:1456
void gutsOfCopy(const CbcModel &rhs, int mode=0)
Most of copy constructor mode - 0 copy but don&#39;t delete before 1 copy and delete before 2 copy and de...
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...
bool isInitialSolveAbandoned() const
Are there numerical difficulties (for initialSolve) ?
int fastNodeDepth() const
Get depth for fast nodes.
Definition: CbcModel.hpp:2616
CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, double objValue, const double *solution)
Deals with event handler and solution.
void branchAndBound(int doStatistics=0)
Invoke the branch & cut algorithm.
CbcEvent
Events known to cbc.
virtual bool isContinuous(int colIndex) const=0
Current minimization objective value.
Definition: CbcModel.hpp:163
void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2687
void synchronizeHandlers(int makeDefault)
Makes all handlers same.
int numberCutGenerators() const
Get the number of cut generators.
Definition: CbcModel.hpp:1762
void setNumberPenalties(int number)
Set the number of variables for which to compute penalties in dynamic strong branching.
void setMinimizationObjValue(double value)
Set best objective function value as minimization.
Definition: CbcModel.hpp:1434
void startSplitModel(int numberIterations)
Start threads.
Using MS heap implementation.
Definition: CbcTree.hpp:52
bool isInitialSolveProvenDualInfeasible() const
Is dual infeasiblity proven (for initialSolve) ?
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
Definition: CbcModel.hpp:182
void setLogLevel(int value)
Set log level.
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:970
const char * integerType() const
Whether or not integer.
Definition: CbcModel.hpp:1150
void setWhenCuts(int value)
Set at which depths to do cuts.
Definition: CbcModel.hpp:883
void setNumberBeforeTrust(int number)
Set the number of branches before pseudo costs believed in dynamic strong branching.
Class to deal with symmetry.
Definition: CbcSymmetry.hpp:66
Base class for Cbc event handling.
int priority() const
int callCbc1(const char *input2, CbcModel &babSolver)
OsiObject * modifiableObject(int which) const
Get the specified object.
Definition: CbcModel.hpp:515
const int * hotstartPriorities() const
Get the hotstart priorities.
Definition: CbcModel.hpp:2537
int getContinuousInfeasibilities() const
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:1548
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
Definition: CbcModel.hpp:1394
int phase() const
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:1515
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
bool allDynamic() const
Says whether all dynamic integers.
Definition: CbcModel.hpp:2673
int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws)
Determine and install the active cuts that need to be added for the current subproblem.
virtual const double * getRightHandSide() const=0
void deleteNode(CbcNode *node)
Delete a node and possibly null out currentNode_.
int numberStrongIterations() const
Get the number of iterations done in strong branching.
Definition: CbcModel.hpp:2587
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:126
int getNodeCount2() const
Get how many Nodes it took to solve the problem.
Definition: CbcModel.hpp:2396
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
Definition: CbcModel.hpp:1423
void setMaximumSavedSolutions(int value)
Set maximum number of extra saved solutions.
void setUseElapsedTime(bool yesNo)
Set time method.
Definition: CbcModel.hpp:2123
int numberPenalties() const
get the number of variables for which to compute penalties in dynamic strong branching.
Definition: CbcModel.hpp:914
virtual const double * getColLower() const=0
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
Definition: CbcModel.hpp:2329
bool isBinary(int colIndex) const
Return true if variable is binary.
Definition: CbcModel.hpp:1239
void gutsOfDestructor2()
Clears out enough to reset CbcModel as if no branch and bound done.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
Definition: CbcModel.hpp:1406
void setBestObjectiveValue(double objectiveValue)
Just update objectiveValue.
void redoWalkBack()
Redo walkback arrays.
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:1732
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:1849
void setStateOfSearch(int state)
Definition: CbcModel.hpp:1736
void setNodeComparison(CbcCompareBase *compare)
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
Definition: CbcModel.hpp:174
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.
void synchronizeModel()
Ensure attached objects point to this model.
virtual int getNumRows() const=0
int resolve(CbcNodeInfo *parent, int whereFrom, double *saveSolution=NULL, double *saveLower=NULL, double *saveUpper=NULL)
Reoptimise an LP relaxation.
void setBranchingMethod(CbcBranchDecision &method)
Set the branching method.
Definition: CbcModel.hpp:1704
int printFrequency() const
Get the print frequency.
Definition: CbcModel.hpp:992
int moreSpecialOptions2() const
Get more special options2.
Definition: CbcModel.hpp:2113
The amount by which to tighten the objective function cutoff when a new solution is discovered...
Definition: CbcModel.hpp:138
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
Definition: CbcModel.hpp:1254
virtual CbcBranchDecision * clone() const =0
Clone.
void setProblemType(int number)
Problem type as set by user or found by analysis.
Definition: CbcModel.hpp:948
void saveBestSolution(const double *solution, double objectiveValue)
Save a solution to best and move current to saved.
void clearNumberGlobalViolations()
Definition: CbcModel.hpp:1572
void setCutoff(double value)
Set cutoff bound on the objective function.
bool isProvenOptimal() const
Is optimality proven?
bool isProvenDualInfeasible() const
Was continuous solution unbounded.
int getStopNumberIterations() const
Get number of "iterations" to stop after.
Definition: CbcModel.hpp:1596
void passInPriorities(const int *priorities, bool ifNotSimpleIntegers)
Pass in branching priorities.
virtual double getInfinity() const=0
OsiRowCut augmented with bookkeeping.
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2543
int numberIntegers() const
Number of integers in problem.
Definition: CbcModel.hpp:1133
int moreSpecialOptions() const
Get more special options.
Definition: CbcModel.hpp:2089
double getAllowableGap() const
Get the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:719
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&#39;s...
void setNumberObjects(int number)
Set the number of objects.
Definition: CbcModel.hpp:498
void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn, double &lower, double &upper, int force)
Returns bounds just before where - initially original bounds.
void zeroExtra()
Zero extra.
Definition: CbcModel.hpp:2637
CbcModel()
Default Constructor.
bool isAbandoned() const
Are there a numerical difficulties?
double getAllowableFractionGap() const
Get the fraction allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:734
Optimization direction - stored for speed.
Definition: CbcModel.hpp:159
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:1577
double getCurrentSeconds() const
Current time since start of branchAndbound.
Information required while the node is live.
Definition: CbcNode.hpp:49
For gathering statistics.
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2248
double savedSolutionObjective(int which) const
Return a saved solution objective (0==best) - COIN_DBL_MAX if off end.
double getMaximumSeconds() const
Get the maximum number of seconds desired.
Definition: CbcModel.hpp:667
int numberObjects() const
Get the number of objects.
Definition: CbcModel.hpp:493
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
Definition: CbcModel.hpp:1487
const double * hotstartSolution() const
Get the hotstart solution.
Definition: CbcModel.hpp:2532
bool isInitialSolveProvenPrimalInfeasible() const
Is primal infeasiblity proven (for initialSolve) ?
CbcCompareBase * nodeComparison() const
Definition: CbcModel.hpp:1620
OsiObject ** objects() const
Get the array of objects.
Definition: CbcModel.hpp:504
virtual double getObjValue() const=0
int maximumRows() const
Maximum number of rows.
Definition: CbcModel.hpp:1586
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
Definition: CbcModel.hpp:2577
bool maximumSecondsReached() const
Return true if maximum time reached.
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: CbcModel.hpp:1532
void CbcMain0(CbcModel &babSolver)
The maximum number of solutions before terminating.
Definition: CbcModel.hpp:107
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 * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:1298
void setMoreSpecialOptions2(int value)
Set more more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective u...
Definition: CbcModel.hpp:2108
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
Definition: CbcModel.hpp:1809
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
Definition: CbcModel.hpp:1741
CoinWarmStartBasis * getEmptyBasis(int ns=0, int na=0) const
Return an empty basis object of the specified size.
void incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1023
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
Definition: CbcModel.hpp:1926
CBC_Message
This deals with Cbc messages (as against Clp messages etc).
Definition: CbcMessage.hpp:24
Smallest non-zero change on a branch.
Definition: CbcModel.hpp:184
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2663
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
void checkModel()
Check original model before it gets messed up.
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 ...
double sumChangeObjective() const
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:1562
void setObjValue(double value)
Set best objective function value.
Definition: CbcModel.hpp:1451
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
Definition: CbcModel.hpp:1189
The maximum number of seconds before terminating.
Definition: CbcModel.hpp:155
CoinMessages & messages()
Return messages.
Definition: CbcModel.hpp:1950
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
Definition: CbcModel.hpp:1892
void initialSolve()
Solve the initial LP relaxation.
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
Definition: CbcModel.hpp:1226
CbcRowCuts * globalCuts()
Global cuts.
Definition: CbcModel.hpp:2553
CoinBigIndex getNumElements() const
Get number of nonzero elements.
Definition: CbcModel.hpp:1127
bool setMaximumNodes(int value)
Set the maximum node limit .
Definition: CbcModel.hpp:616
The time at start of model.
Definition: CbcModel.hpp:166
virtual const double * getColSolution() const=0
int status() const
Final status of problem Some of these can be found out by is......
Definition: CbcModel.hpp:1056
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
Definition: CbcModel.hpp:1176
double * bestSolution() const
The best solution to the integer programming problem.
Definition: CbcModel.hpp:1467
void addObjects(int numberObjects, OsiObject **objects)
Add in object information.
void incrementExtra(int nodes, int iterations, int fathoms=1)
Definition: CbcModel.hpp:2630
Heuristic base class.
int splitModel(int numberModels, CbcModel **model, int numberNodes)
Split up nodes.
const int * whichGenerator() const
Which cut generator generated this cut.
Definition: CbcModel.hpp:374
void sayEventHappened()
Tell model to stop on event.
Definition: CbcModel.hpp:2044
Abstract cut modifier base class.
Information required to recreate the subproblem at this node.
Definition: CbcNodeInfo.hpp:68
void setBestSolution(CBC_Message how, double &objectiveValue, const double *solution, int fixVariables=0)
Record a new incumbent solution and update objectiveValue.
int strongStrategy() const
Stong branching strategy.
Definition: CbcModel.hpp:1751
virtual double getObjSense() const=0
void setParentModel(CbcModel &parentModel)
Set the parent model.
Definition: CbcModel.hpp:1819
int CoinBigIndex
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 zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
Definition: CbcModel.hpp:1272
int getSolutionCount() const
Get number of solutions.
Definition: CbcModel.hpp:1481
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
int numberGlobalViolations() const
Number of times global cuts violated.
Definition: CbcModel.hpp:1568
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
Definition: CbcModel.hpp:2230
Information required to recreate the subproblem at this node.
void setSecondaryStatus(int value)
Definition: CbcModel.hpp:1080
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...
void setMaximumNumberIterations(int value)
Set maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2597
Base model.
Definition: CbcThread.hpp:475
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
Definition: CbcModel.hpp:1834
void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0)
Do heuristics at root.
int getNumRows() const
Get number of rows.
Definition: CbcModel.hpp:1121
void setContinuousObjective(double value)
Definition: CbcModel.hpp:1543
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
Definition: CbcModel.hpp:1557
void analyzeObjective()
Analyze problem to find a minimum change in the objective function.
void setProblemStatus(int value)
Definition: CbcModel.hpp:1060
bool isLocked() const
From here to end of section - code in CbcThread.cpp until class changed Returns true if locked...
const int * strongInfo() const
Return strong info.
Definition: CbcModel.hpp:2652
CbcAction
Action codes returned by the event handler.
Largest non-zero change on a branch.
Definition: CbcModel.hpp:188
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
Definition: CbcModel.hpp:1156
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:1308
static bool haveMultiThreadSupport()
Indicates whether Cbc library has been compiled with multithreading support.
int CbcMain1(int argc, const char *argv[], CbcModel &babSolver)
void createContinuousSolver()
Create solver with continuous state.
Definition: CbcModel.hpp:2236
int getRandomSeed() const
Get random seed.
Definition: CbcModel.hpp:2029
void setTestSolution(const double *solution)
Definition: CbcModel.hpp:1386
int whenCuts() const
Get at which depths to do cuts.
Definition: CbcModel.hpp:878
int getPreferredWay() const
Get the preferred way to branch (default 0)
Definition: CbcModel.hpp:873
int logLevel() const
int getIntParam(CbcIntParam key) const
Get an integer parameter.
Definition: CbcModel.hpp:591
double getMinimizationObjValue() const
Get best objective function value as minimization.
Definition: CbcModel.hpp:1429
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
int numberHeuristics() const
Get the number of heuristics.
Definition: CbcModel.hpp:1839
void setNumberHeuristics(int value)
Set the number of heuristics.
Definition: CbcModel.hpp:1844
Small non-zero change on a branch to be used as guess.
Definition: CbcModel.hpp:190
bool setAllowableGap(double value)
Set the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:712
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Definition: CbcModel.hpp:1220
const int * integerVariable() const
Definition: CbcModel.hpp:1138
int getCurrentPassNumber() const
Get current cut pass number in this round of cuts.
Definition: CbcModel.hpp:842
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
Definition: CbcModel.hpp:1777
void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
Definition: CbcModel.hpp:2695
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
CbcModel * parentModel() const
Get the current parent model.
Definition: CbcModel.hpp:1814
double getHeuristicFractionGap() const
Get the fraction heuristic gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:777
void setMinimumDrop(double value)
Set the minimum drop to continue cuts.
Definition: CbcModel.hpp:807
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: CbcModel.hpp:1208
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
Definition: CbcModel.hpp:1335
int typePresolve() const
Whether to automatically do presolve before branch and bound (subTrees).
Definition: CbcModel.hpp:1672
const double * savedSolution(int which) const
Return a saved solution (0==best) - NULL if off end.
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
void resetModel()
Clears out enough to reset CbcModel cutoff etc.
double getBestPossibleObjValue() const
Get best possible objective function value.
void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod)
Go to dantzig pivot selection if easy problem (clp only)
int getThreadMode() const
Get thread mode.
Definition: CbcModel.hpp:2306
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
Definition: CbcModel.hpp:1202
void addSOSEtcToSolver()
Add SOS info to solver - Overwrites SOS information in solver with information in CbcModel...
const OsiSolverInterface * postProcessedSolver(int solutionType=1)
Returns postProcessed solution in solver(called from event handler) Normally used for integer solutio...
virtual bool isBinary(int colIndex) const
void getIntegerInformation(const OsiObject *object, double &originalLower, double &originalUpper)
So we can use osiObject or CbcObject during transition.
void setTemporaryPointer(void *pointer)
Set useful temporary pointer.
Definition: CbcModel.hpp:2141
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
Definition: CbcModel.hpp:579
void setMultipleRootTries(int value)
Set multiple root tries.
Definition: CbcModel.hpp:2034
bool normalSolver() const
Says if normal solver i.e. has well defined CoinPackedMatrix.
Definition: CbcModel.hpp:2049
virtual const double * getObjCoefficients() const=0
void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const
Set objective value in a node.
virtual const CoinPackedMatrix * getMatrixByRow() const=0
void AddIntegers()
Add additional integers.
CglPreProcess * preProcess() const
Returns CglPreProcess used before branch and bound.
Definition: CbcModel.hpp:322
bool ownObjects() const
Now we may not own objects - just point to solver&#39;s objects.
Definition: CbcModel.hpp:2148
void setContinuousInfeasibilities(int value)
Definition: CbcModel.hpp:1552
CbcFeasibilityBase * problemFeasibility() const
Definition: CbcModel.hpp:1631
int reducedCostFix()
Perform reduced cost fixing.
bool setMaximumSeconds(double value)
Set the maximum number of seconds desired.
Definition: CbcModel.hpp:659
virtual const double * getRowUpper() const=0
CbcBaseModel * master() const
Thread stuff for master.
Definition: CbcModel.hpp:2345
Interface between Cbc and Cut Generation Library.
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
virtual const double * getReducedCost() const=0
virtual const double * getRowLower() const=0
double getMinimumDrop() const
Get the minimum drop to continue cuts.
Definition: CbcModel.hpp:812
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
Definition: CbcModel.hpp:919
void setTypePresolve(int value)
Definition: CbcModel.hpp:1676
int getNumberThreads() const
Get number of threads.
Definition: CbcModel.hpp:2296
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
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
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:785
bool setHeuristicGap(double value)
Set the heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:755
int numberStoppedSubTrees() const
Returns number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:1658
bool isInteger(int colIndex) const
Return true if column is integer.
Definition: CbcModel.hpp:1248
CbcModel * findCliques(bool makeEquality, int atLeastThisMany, int lessThanThis, int defaultValue=1000)
Identify cliques and construct corresponding objects.
The maximum amount the value of an integer variable can vary from integer and still be considered fea...
Definition: CbcModel.hpp:132
virtual const double * getRowRange() const=0
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.
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
Definition: CbcModel.hpp:145
void addHeuristic(CbcHeuristic *generator, const char *name=NULL, int before=-1)
Add one heuristic - up to user to delete.
void assignSolver(OsiSolverInterface *&solver, bool deleteSolver=true)
Assign a solver to the model (model assumes ownership)
OsiSolverInterface * swapSolver(OsiSolverInterface *solver)
Returns current solver - sets new one.
Definition: CbcModel.hpp:2222
void setPreferredWay(int value)
Set global preferred way to branch -1 down, +1 up, 0 no preference.
Definition: CbcModel.hpp:868
void gutsOfDestructor()
Clears out as much as possible (except solver)
Simple Branch and bound class.
Definition: CbcModel.hpp:100
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
bool feasibleSolution(int &numberIntegerInfeasibilities, int &numberObjectInfeasibilities) const
Test the current solution for feasiblility.
void * temporaryPointer() const
Get useful temporary pointer.
Definition: CbcModel.hpp:2136
void findIntegers(bool startAgain, int type=0)
Identify integer variables and create corresponding objects.
void setStopNumberIterations(int value)
Set number of "iterations" to stop after.
Definition: CbcModel.hpp:1601
void setCutModifier(CbcCutModifier *modifier)
Set the cut modifier method.
void setSpecialOptions(int value)
Set special options 0 bit (1) - check if cuts valid (if on debugger list) 1 bit (2) - use current bas...
Definition: CbcModel.hpp:2014
void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible)
Save copy of the model.
int makeGlobalCut(const OsiRowCut *cut)
Make given cut into a global cut.
void setNextRowCut(const OsiRowCut &cut)
Copy and set a pointer to a row cut which will be added instead of normal branching.
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
Definition: CbcModel.hpp:1710
bool useElapsedTime() const
Get time method.
Definition: CbcModel.hpp:2131
void originalModel(CbcModel *presolvedModel, bool weak)
Put back information into the original model after integer presolve.
OsiSolverInterface * solver() const
Returns solver - has current state.
Definition: CbcModel.hpp:2216
Strategy base class.
Definition: CbcStrategy.hpp:18
bool isSecondsLimitReached() const
Time limit reached?
int howOftenGlobalScan() const
Get how often to scan global cuts.
Definition: CbcModel.hpp:965
void pseudoShadow(int type)
Fill in useful estimates.
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
Definition: CbcModel.hpp:1642
void passInSubTreeModel(CbcModel &model)
For passing in an CbcModel to do a sub Tree (with derived tree handlers).
virtual ~CbcModel()
Destructor.
int maximumSavedSolutions() const
Maximum number of extra saved solutions.
Definition: CbcModel.hpp:1494
A class to encapsulate thread stuff.
Definition: CbcThread.hpp:466
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
CbcThread * masterThread() const
Get pointer to masterthread.
Definition: CbcModel.hpp:2286
void adjustHeuristics()
Adjust heuristics based on model.
virtual void setObjSense(double s)=0
bool isContinuousUnbounded() 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
void moveInfo(const CbcModel &rhs)
Move status, nodes etc etc across.
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
Definition: CbcModel.hpp:1772
virtual const double * getColUpper() const=0
CbcStrategy * strategy() const
Get the current strategy.
Definition: CbcModel.hpp:1802
int currentDepth() const
Current depth.
Definition: CbcModel.hpp:957