Cbc  2.10.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CbcModel.hpp
Go to the documentation of this file.
1 /* $Id: CbcModel.hpp 2699 2019-10-03 14:05:25Z stefan $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef CbcModel_H
7 #define CbcModel_H
8 #include <string>
9 #include <vector>
10 #include "CoinMessageHandler.hpp"
11 #include "OsiSolverInterface.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiCuts.hpp"
14 #include "CoinWarmStartBasis.hpp"
15 #include "CbcCompareBase.hpp"
16 #include "CbcCountRowCut.hpp"
17 #include "CbcMessage.hpp"
18 #include "CbcEventHandler.hpp"
19 #include "ClpDualRowPivot.hpp"
20 
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  {
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  {
827  }
828 
831  inline void setMaximumCutPasses(int value)
832  {
833  maximumCutPasses_ = value;
834  }
836  inline int getMaximumCutPasses() const
837  {
838  return maximumCutPasses_;
839  }
842  inline int getCurrentPassNumber() const
843  {
844  return currentPassNumber_;
845  }
848  inline void setCurrentPassNumber(int value)
849  {
850  currentPassNumber_ = value;
851  }
852 
858  void setNumberStrong(int number);
862  inline int numberStrong() const
863  {
864  return numberStrong_;
865  }
868  inline void setPreferredWay(int value)
869  {
870  preferredWay_ = value;
871  }
873  inline int getPreferredWay() const
874  {
875  return preferredWay_;
876  }
878  inline int whenCuts() const
879  {
880  return whenCuts_;
881  }
883  inline void setWhenCuts(int value)
884  {
885  whenCuts_ = value;
886  }
892  bool doCutsNow(int allowForTopOfTree) const;
893 
899  void setNumberBeforeTrust(int number);
902  inline int numberBeforeTrust() const
903  {
904  return numberBeforeTrust_;
905  }
911  void setNumberPenalties(int number);
914  inline int numberPenalties() const
915  {
916  return numberPenalties_;
917  }
919  inline const CbcFullNodeInfo *topOfTree() const
920  {
921  return topOfTree_;
922  }
924  inline void setNumberAnalyzeIterations(int number)
925  {
926  numberAnalyzeIterations_ = number;
927  }
928  inline int numberAnalyzeIterations() const
929  {
931  }
934  inline double penaltyScaleFactor() const
935  {
936  return penaltyScaleFactor_;
937  }
940  void setPenaltyScaleFactor(double value);
948  void inline setProblemType(int number)
949  {
950  problemType_ = number;
951  }
952  inline int problemType() const
953  {
954  return problemType_;
955  }
957  inline int currentDepth() const
958  {
959  return currentDepth_;
960  }
961 
963  void setHowOftenGlobalScan(int number);
965  inline int howOftenGlobalScan() const
966  {
967  return howOftenGlobalScan_;
968  }
970  inline int *originalColumns() const
971  {
972  return originalColumns_;
973  }
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());
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  {
1421  }
1423  inline double getCurrentMinimizationObjValue() const
1424  {
1426  }
1427 
1429  inline double getMinimizationObjValue() const
1430  {
1431  return bestObjective_;
1432  }
1434  inline void setMinimizationObjValue(double value)
1435  {
1436  bestObjective_ = value;
1437  }
1438 
1440  inline double getObjValue() const
1441  {
1442  return bestObjective_ * solver_->getObjSense();
1443  }
1449  double getBestPossibleObjValue() const;
1451  inline void setObjValue(double value)
1452  {
1453  bestObjective_ = value * solver_->getObjSense();
1454  }
1456  inline double getSolverObjValue() const
1457  {
1458  return solver_->getObjValue() * solver_->getObjSense();
1459  }
1460 
1467  inline double *bestSolution() const
1468  {
1469  return bestSolution_;
1470  }
1477  void setBestSolution(const double *solution, int numberColumns,
1478  double objectiveValue, bool check = false);
1479 
1481  inline int getSolutionCount() const
1482  {
1483  return numberSolutions_;
1484  }
1485 
1487  inline void setSolutionCount(int value)
1488  {
1489  numberSolutions_ = value;
1490  }
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  {
1524  }
1526  inline void setNumberHeuristicSolutions(int value)
1527  {
1528  numberHeuristicSolutions_ = value;
1529  }
1530 
1532  inline void setObjSense(double s)
1533  {
1535  solver_->setObjSense(s);
1536  }
1537 
1539  inline double getContinuousObjective() const
1540  {
1542  }
1543  inline void setContinuousObjective(double value)
1544  {
1546  }
1548  inline int getContinuousInfeasibilities() const
1549  {
1551  }
1552  inline void setContinuousInfeasibilities(int value)
1553  {
1555  }
1557  inline double rootObjectiveAfterCuts() const
1558  {
1559  return continuousObjective_;
1560  }
1562  inline double sumChangeObjective() const
1563  {
1564  return sumChangeObjective1_;
1565  }
1568  inline int numberGlobalViolations() const
1569  {
1570  return numberGlobalViolations_;
1571  }
1573  {
1575  }
1577  inline bool resolveAfterTakeOffCuts() const
1578  {
1579  return resolveAfterTakeOffCuts_;
1580  }
1581  inline void setResolveAfterTakeOffCuts(bool yesNo)
1582  {
1583  resolveAfterTakeOffCuts_ = yesNo;
1584  }
1586  inline int maximumRows() const
1587  {
1588  return maximumRows_;
1589  }
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  {
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  {
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  {
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;
2356  void lockThread();
2360  void unlockThread();
2368  void setInfoInChild(int type, CbcThread *info);
2375  void moveToModel(CbcModel *baseModel, int mode);
2377  int splitModel(int numberModels, CbcModel **model,
2378  int numberNodes);
2380  void startSplitModel(int numberIterations);
2382  void mergeModels(int numberModel, CbcModel **model,
2383  int numberNodes);
2385 
2387 
2388  int getNodeCount2() const
2390  {
2391  return numberNodes2_;
2392  }
2394  void setPointers(const OsiSolverInterface *solver);
2400  int reducedCostFix();
2404  void synchronizeHandlers(int makeDefault);
2406  void saveExtraSolution(const double *solution, double objectiveValue);
2408  void saveBestSolution(const double *solution, double objectiveValue);
2410  void deleteSolutions();
2413 #ifdef CLP_RESOLVE
2414  int resolveClp(OsiClpSolverInterface *solver, int type);
2416 #endif
2417 
2421  int chooseBranch(CbcNode *&newNode, int numberPassesLeft,
2422  CbcNode *oldNode, OsiCuts &cuts,
2423  bool &resolved, CoinWarmStartBasis *lastws,
2424  const double *lowerBefore, const double *upperBefore,
2425  OsiSolverBranch *&branches);
2426 
2433  CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const;
2434 
2446  int takeOffCuts(OsiCuts &cuts,
2447  bool allowResolve, OsiCuts *saveCuts,
2448  int numberNewCuts = 0, const OsiRowCut **newCuts = NULL);
2449 
2462  int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws);
2463 
2480  bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws);
2484  void previousBounds(CbcNode *node, CbcNodeInfo *where, int iColumn,
2485  double &lower, double &upper, int force);
2490  void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const;
2491 
2495  void convertToDynamic();
2497  void synchronizeNumberBeforeTrust(int type = 0);
2499  void zapIntegerInformation(bool leaveObjects = true);
2501  void pseudoShadow(int type);
2508  void fillPseudoCosts(double *downCosts, double *upCosts,
2509  int *priority = NULL,
2510  int *numberDown = NULL, int *numberUp = NULL,
2511  int *numberDownInfeasible = NULL,
2512  int *numberUpInfeasible = NULL) const;
2518  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
2520  void adjustHeuristics();
2522  inline const double *hotstartSolution() const
2523  {
2524  return hotstartSolution_;
2525  }
2527  inline const int *hotstartPriorities() const
2528  {
2529  return hotstartPriorities_;
2530  }
2531 
2533  inline CbcCountRowCut **addedCuts() const
2534  {
2535  return addedCuts_;
2536  }
2538  inline int currentNumberCuts() const
2539  {
2540  return currentNumberCuts_;
2541  }
2544  {
2545  return &globalCuts_;
2546  }
2548  inline void zapGlobalCuts()
2549  {
2550  globalCuts_ = CbcRowCuts();
2551  }
2553  void setNextRowCut(const OsiRowCut &cut);
2555  inline CbcNode *currentNode() const
2556  {
2557  return currentNode_;
2558  }
2560  void deleteNode(CbcNode * node);
2563  {
2564  return probingInfo_;
2565  }
2568  {
2569  return &randomNumberGenerator_;
2570  }
2572  inline void setNumberStrongIterations(int number)
2573  {
2574  numberStrongIterations_ = number;
2575  }
2577  inline int numberStrongIterations() const
2578  {
2579  return numberStrongIterations_;
2580  }
2582  inline int maximumNumberIterations() const
2583  {
2584  return maximumNumberIterations_;
2585  }
2587  inline void setMaximumNumberIterations(int value)
2588  {
2589  maximumNumberIterations_ = value;
2590  }
2591 #ifdef COIN_HAS_NTY
2592  inline CbcSymmetry *symmetryInfo() const
2594  {
2595  return symmetryInfo_;
2596  }
2598  void zapSymmetry();
2599 #endif
2600  inline void setFastNodeDepth(int value)
2602  {
2603  fastNodeDepth_ = value;
2604  }
2606  inline int fastNodeDepth() const
2607  {
2608  return fastNodeDepth_;
2609  }
2611  inline int continuousPriority() const
2612  {
2613  return continuousPriority_;
2614  }
2616  inline void setContinuousPriority(int value)
2617  {
2618  continuousPriority_ = value;
2619  }
2620  inline void incrementExtra(int nodes, int iterations, int fathoms = 1)
2621  {
2622  numberExtraNodes_ += nodes;
2623  numberExtraIterations_ += iterations;
2624  numberFathoms_ += fathoms;
2625  }
2627  inline void zeroExtra()
2628  {
2629  numberExtraNodes_ = 0;
2631  numberFathoms_ = 0;
2632  }
2634  inline int numberExtraIterations() const
2635  {
2636  return numberExtraIterations_;
2637  }
2639  void incrementStrongInfo(int numberTimes, int numberIterations,
2640  int numberFixed, bool ifInfeasible);
2642  inline const int *strongInfo() const
2643  {
2644  return strongInfo_;
2645  }
2646 
2648  inline int *mutableStrongInfo()
2649  {
2650  return strongInfo_;
2651  }
2654  {
2655  return storedRowCuts_;
2656  }
2659  {
2660  storedRowCuts_ = cuts;
2661  }
2663  inline bool allDynamic() const
2664  {
2665  return ((ownership_ & 0x40000000) != 0);
2666  }
2668  void generateCpp(FILE *fp, int options);
2677  inline void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
2678  {
2679  bestSolutionBasis_ = bestSolutionBasis;
2680  }
2682  void redoWalkBack();
2684 
2685  void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
2686  {
2687  this->mipStart_ = mipstart;
2688  }
2689 
2692  void setKeepNamesPreproc( bool _keep )
2693  {
2694  this->keepNamesPreproc = _keep;
2695  }
2696 
2697  bool getKeepNamesPreproc() const
2698  {
2699  return keepNamesPreproc;
2700  }
2701 
2704  void setMIPStart(int count, const char **colNames, const double colValues[]);
2705 
2706 
2707  const std::vector< std::pair< std::string, double > > &getMIPStart()
2708  {
2709  return this->mipStart_;
2710  }
2711 
2712  //---------------------------------------------------------------------------
2713 
2714 private:
2716 
2717 
2720 
2726  unsigned int ownership_;
2727 
2730 
2733 
2736 
2743 
2746 
2749 
2752 
2762 
2771 
2773  double *bestSolution_;
2776 
2785  mutable const double *testSolution_;
2789  std::vector< std::pair< std::string, double > > mipStart_;
2790 
2796 
2808 
2843  int status_;
2875  int phase_;
2876 
2879 
2899 
2908 
2913 
2916 
3009  const double *cbcColLower_;
3012  const double *cbcColUpper_;
3014  const double *cbcRowLower_;
3016  const double *cbcRowUpper_;
3018  const double *cbcColSolution_;
3020  const double *cbcRowPrice_;
3022  const double *cbcReducedCost_;
3024  const double *cbcRowActivity_;
3026  void *appData_;
3067  // Cut generators
3069  // Cut generators before any changes
3080 #ifdef CBC_ONLY_CLP
3082 #else
3084 #endif
3089 
3103 
3167  mutable bool eventHappened_;
3192  int strongInfo_[7];
3237 };
3239 void getIntegerInformation(const OsiObject *object, double &originalLower,
3240  double &originalUpper);
3241 // So we can call from other programs
3242 // Real main program
3243 class OsiClpSolverInterface;
3244 int CbcMain(int argc, const char *argv[], CbcModel &babSolver);
3245 // four ways of calling
3246 int callCbc(const char *input2, OsiClpSolverInterface &solver1);
3247 int callCbc(const char *input2);
3248 int callCbc(const std::string input2, OsiClpSolverInterface &solver1);
3249 int callCbc(const std::string input2);
3250 // When we want to load up CbcModel with options first
3251 void CbcMain0(CbcModel &babSolver);
3252 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver);
3253 // two ways of calling
3254 int callCbc(const char *input2, CbcModel &babSolver);
3255 int callCbc(const std::string input2, CbcModel &babSolver);
3256 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
3257 int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3258 int CbcMain1(int argc, const char *argv[], CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom));
3259 // For uniform setting of cut and heuristic options
3260 void setCutAndHeuristicOptions(CbcModel &model);
3261 #endif
3262 
3263 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
3264 */
void flipModel()
Flip direction of optimization on all models.
CbcThread * masterThread() const
Get pointer to masterthread.
Definition: CbcModel.hpp:2286
void passInSolverCharacteristics(OsiBabSolver *solverCharacteristics)
For advanced applications you may wish to modify the behavior of Cbc e.g.
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver–&gt;getColSolution() ...
Definition: CbcModel.hpp:1382
CbcNodeInfo ** walkback_
Array used to assemble the path between a node and the search tree root.
Definition: CbcModel.hpp:2890
const double * cbcColUpper_
Pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:3012
int status_
Status of problem - 0 finished, 1 stopped, 2 difficulties.
Definition: CbcModel.hpp:2843
void setProblemFeasibility(CbcFeasibilityBase *feasibility)
CglTreeProbingInfo * probingInfo_
Probing info.
Definition: CbcModel.hpp:3159
The objective is assumed to worsen by this amount for each integer infeasibility. ...
Definition: CbcModel.hpp:135
CbcObjectUpdateData * updateItems_
Update items.
Definition: CbcModel.hpp:3211
void resetToReferenceSolver()
Uses a copy of reference solver to be current solver.
int numberExtraNodes_
Number of extra nodes in fast lp.
Definition: CbcModel.hpp:3114
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.
virtual const double * getRowActivity() const =0
Get a pointer to array[getNumRows()] of row activity levels.
CbcNodeInfo ** lastNodeInfo_
Definition: CbcModel.hpp:2893
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:1849
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
void setPointers(const OsiSolverInterface *solver)
Set pointers for speed.
double * currentSolution_
Array holding the current solution.
Definition: CbcModel.hpp:2781
char * integerInfo_
Whether of not integer.
Definition: CbcModel.hpp:2920
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
Definition: CbcModel.hpp:1189
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
Current objective value.
Definition: CbcModel.hpp:161
virtual CoinBigIndex getNumElements() const =0
Get the number of nonzero elements.
int strongStrategy_
Strategy for strong branching 0 - normal when to do all fractional 1 - root node 2 - depth less than ...
Definition: CbcModel.hpp:3187
CbcNode * currentNode_
Current node so can be used elsewhere.
Definition: CbcModel.hpp:2915
void setLastHeuristic(CbcHeuristic *last)
set last heuristic which found a solution
Definition: CbcModel.hpp:1854
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...
Event handling for cbc.
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
Definition: CbcModel.hpp:1690
virtual OsiSolverInterface * clone(bool copyData=true) const =0
Clone.
double getSolverObjValue() const
Get solver objective function value (as minimization)
Definition: CbcModel.hpp:1456
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
Definition: CbcModel.hpp:1335
void setOptionalInteger(int index)
int numberSavedSolutions_
Number of saved solutions.
Definition: CbcModel.hpp:2814
int numberSolutions_
Number of solutions.
Definition: CbcModel.hpp:2812
int moreSpecialOptions() const
Get more special options.
Definition: CbcModel.hpp:2089
double numberDJFixed_
Number of reduced cost fixings.
Definition: CbcModel.hpp:3157
void * getApplicationData() const
Get application data.
int preferredWay_
Preferred way of branching.
Definition: CbcModel.hpp:3131
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:2707
const double * cbcRowLower_
Pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:3014
bool isInitialSolveProvenOptimal() const
Is optimality proven (for initialSolve) ?
int cutoffRowNumber_
-1 - cutoff as constraint not activated -2 - waiting to activate &gt;=0 - activated
Definition: CbcModel.hpp:2864
int stateOfSearch_
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:2823
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
Definition: CbcModel.hpp:1202
int getPrintingMode() const
Get the printing mode.
Definition: CbcModel.hpp:650
void incrementStrongInfo(int numberTimes, int numberIterations, int numberFixed, bool ifInfeasible)
Increment strong info.
CbcCountRowCut ** addedCuts_
The list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2907
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
Definition: CbcModel.hpp:2118
CbcSymmetry * symmetryInfo_
Symmetry information.
Definition: CbcModel.hpp:3086
bool resolveAfterTakeOffCuts_
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:3201
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
double sumChangeObjective2_
Sum of Changes to objective by subsequent solves.
Definition: CbcModel.hpp:2770
CglPreProcess * preProcess() const
Returns CglPreProcess used before branch and bound.
Definition: CbcModel.hpp:322
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
Definition: CbcModel.hpp:1220
bool isAbandoned() const
Are there a numerical difficulties?
The maximum number of nodes before terminating.
Definition: CbcModel.hpp:105
bool isNodeLimitReached() const
Node limit reached?
int priority() const
Return Priority - note 1 is highest priority.
int * whichGenerator_
Which cut generator generated this cut.
Definition: CbcModel.hpp:3149
int maximumRows_
Maximum number of rows.
Definition: CbcModel.hpp:3137
const char * integerType() const
Whether or not integer.
Definition: CbcModel.hpp:1150
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:1606
void setFastNodeDepth(int value)
Set depth for fast nodes.
Definition: CbcModel.hpp:2601
CbcCompareBase * nodeCompare_
User node comparison function.
Definition: CbcModel.hpp:2983
void setNumberStrongIterations(int number)
Set the number of iterations done in strong branching.
Definition: CbcModel.hpp:2572
int getThreadMode() const
Get thread mode.
Definition: CbcModel.hpp:2306
int numberObjects() const
Get the number of objects.
Definition: CbcModel.hpp:493
bool isSolutionLimitReached() const
Solution limit reached?
bool setHeuristicFractionGap(double value)
Set the fraction heuristic gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:770
CoinBigIndex getNumElements() const
Get number of nonzero elements.
Definition: CbcModel.hpp:1127
int moreSpecialOptions2() const
Get more special options2.
Definition: CbcModel.hpp:2113
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
Definition: CbcModel.hpp:1254
int maximumNumberUpdateItems_
Maximum number of outstanding update information items.
Definition: CbcModel.hpp:3209
void setStrongStrategy(int value)
Set strong branching strategy.
Definition: CbcModel.hpp:1756
int * lastNumberCuts_
Definition: CbcModel.hpp:2898
int numberGlobalCutsIn_
Number of global cuts on entry to a node.
Definition: CbcModel.hpp:3231
int * mutableStrongInfo()
Return mutable strong info.
Definition: CbcModel.hpp:2648
virtual bool isIntegerNonBinary(int colIndex) const
Return true if the variable is general integer.
virtual CbcModel * clone(bool cloneHandler)
Clone.
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
Definition: CbcModel.hpp:1288
virtual const char * getRowSense() const =0
Get a pointer to an array[getNumRows()] of row constraint senses.
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 isBinary(int colIndex) const
Return true if variable is binary.
Definition: CbcModel.hpp:1239
void setResolveAfterTakeOffCuts(bool yesNo)
Definition: CbcModel.hpp:1581
int getIterationCount() const
Get how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1018
void * temporaryPointer_
Useful temporary pointer.
Definition: CbcModel.hpp:3053
int numberHeuristics() const
Get the number of heuristics.
Definition: CbcModel.hpp:1839
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
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 &gt;= this can be treated as continuous.
Definition: CbcModel.hpp:2616
void resizeWhichGenerator(int numberNow, int numberAfter)
Update size of whichGenerator.
int maximumRows() const
Maximum number of rows.
Definition: CbcModel.hpp:1586
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
Definition: CbcModel.hpp:1557
int getContinuousInfeasibilities() const
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:1548
int callCbc(const char *input2, OsiClpSolverInterface &solver1)
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
Definition: CbcModel.hpp:1892
void lockThread()
Locks a thread if parallel so that stuff like cut pool can be updated and/or used.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
Definition: CbcModel.hpp:1406
bool getKeepNamesPreproc() const
Definition: CbcModel.hpp:2697
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
Definition: CbcModel.hpp:1521
Stored Cut Generator Class.
Definition: CglStored.hpp:16
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:192
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:1313
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 setInfeasibilityWeight(double value)
Set the weight per integer infeasibility .
Definition: CbcModel.hpp:696
OsiSolverInterface * solver_
The solver associated with this model.
Definition: CbcModel.hpp:2719
void reserveCurrentSolution(const double *solution=NULL)
Make sure region there and optionally copy solution.
int getMultipleRootTries() const
Get multiple root tries.
Definition: CbcModel.hpp:2039
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
Definition: CbcModel.hpp:1109
double * bestSolution_
Array holding the incumbent (best) solution.
Definition: CbcModel.hpp:2773
bool setIntegerTolerance(double value)
Set the integrality tolerance .
Definition: CbcModel.hpp:680
int * integerVariable_
Indices of integer variables.
Definition: CbcModel.hpp:2918
int logLevel() const
Get log level.
Definition: CbcModel.hpp:1962
CbcModel * parentModel_
Parent model.
Definition: CbcModel.hpp:3003
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
Definition: CbcModel.hpp:1741
CoinMessageHandler * handler_
Message handler.
Definition: CbcModel.hpp:2735
const double * hotstartSolution() const
Get the hotstart solution.
Definition: CbcModel.hpp:2522
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
int specialOptions_
Special options 0 bit (1) - check if cuts valid (if on debugger list) 1 bit (2) - use current basis t...
Definition: CbcModel.hpp:2952
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
Definition: CbcModel.hpp:1260
bool canStopOnGap() const
See if can stop on gap.
double minimumDrop_
Minimum degradation in objective value to continue cut generation.
Definition: CbcModel.hpp:2810
Cutoff - stored for speed.
Definition: CbcModel.hpp:157
bool isProvenOptimal() const
Is optimality proven?
CbcCutGenerator ** generator_
Definition: CbcModel.hpp:3068
int numberLongStrong_
Number of long strong goes.
Definition: CbcModel.hpp:3169
virtual const double * getRowPrice() const =0
Get pointer to array[getNumRows()] of dual variable values.
CbcNodeInfo ** walkback() const
Get pointer to walkback.
Definition: CbcModel.hpp:2291
int howOftenGlobalScan() const
Get how often to scan global cuts.
Definition: CbcModel.hpp:965
int fastNodeDepth_
Depth for fast nodes.
Definition: CbcModel.hpp:3078
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
int numberSolves_
Cumulative number of solves.
Definition: CbcModel.hpp:2841
unsigned int ownership_
Ownership of objects and other stuff.
Definition: CbcModel.hpp:2726
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
Definition: CbcModel.hpp:919
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
Definition: CbcModel.hpp:1591
const double * cbcColLower_
Whether to automatically do presolve before branch and bound.
Definition: CbcModel.hpp:3010
CbcEventHandler * eventHandler_
Pointer to the event handler.
Definition: CbcModel.hpp:3083
virtual const CoinPackedMatrix * getMatrixByCol() const =0
Get a pointer to a column-wise copy of the matrix.
char * setupCleanVariables()
Sets up cleanVariables array (i.e. ones to be careful about)
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
Definition: CbcModel.hpp:2533
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2658
bool setDblParam(CbcDblParam key, double value)
Set a double parameter.
Definition: CbcModel.hpp:585
CbcHeuristic * lastHeuristic_
Pointer to heuristic solver which found last solution (or NULL)
Definition: CbcModel.hpp:3076
CbcHeuristic ** heuristic_
Heuristic solvers.
Definition: CbcModel.hpp:3074
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.
int getRandomSeed() const
Get random seed.
Definition: CbcModel.hpp:2029
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
Definition: CbcModel.hpp:1526
int getNodeCount2() const
Get how many Nodes it took to solve the problem.
Definition: CbcModel.hpp:2389
int numberInfeasibleNodes_
Number of nodes infeasible by normal branching (before cuts)
Definition: CbcModel.hpp:3055
Sum of non-zero changes on a branch.
Definition: CbcModel.hpp:186
int phase() const
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:1515
int multipleRootTries_
Multiple root tries.
Definition: CbcModel.hpp:3141
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
int numberStrong_
Maximum number of candidates to consider for strong branching.
Definition: CbcModel.hpp:3032
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
Definition: CbcModel.hpp:2692
int moreSpecialOptions2_
More more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective until...
Definition: CbcModel.hpp:2981
Collections of row cuts and column cuts.
Definition: OsiCuts.hpp:19
Column Cut Class.
Definition: OsiColCut.hpp:23
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 currentNumberCuts() const
Number of entries in the list returned by addedCuts()
Definition: CbcModel.hpp:2538
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.
double getCurrentObjValue() const
Get current objective function value.
Definition: CbcModel.hpp:1418
Clp Solver Interface.
void setNumberThreads(int value)
Set number of threads.
Definition: CbcModel.hpp:2301
int lastNumberCuts2_
Definition: CbcModel.hpp:2896
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
CbcStrategy * strategy_
Strategy.
Definition: CbcModel.hpp:3001
int strongStrategy() const
Stong branching strategy.
Definition: CbcModel.hpp:1751
const double * cbcRowPrice_
Pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:3020
void setPrintFrequency(int number)
Set the print frequency.
Definition: CbcModel.hpp:987
bool feasibleSolution(int &numberIntegerInfeasibilities, int &numberObjectInfeasibilities) const
Test the current solution for feasiblility.
bool normalSolver() const
Says if normal solver i.e. has well defined CoinPackedMatrix.
Definition: CbcModel.hpp:2049
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 currentDepth_
Current depth.
Definition: CbcModel.hpp:3143
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.
double savedSolutionObjective(int which) const
Return a saved solution objective (0==best) - COIN_DBL_MAX if off end.
int numberNewCuts_
Number of new cuts.
Definition: CbcModel.hpp:3173
void unlockThread()
Unlocks a thread if parallel to say cut pool stuff not needed.
The default COIN simplex (basis-oriented) warm start class.
bool defaultHandler() const
Check default handler.
Definition: CbcModel.hpp:1976
void convertToDynamic()
If numberBeforeTrust &gt;0 then we are going to use CbcBranchDynamic.
OsiObject ** object_
Integer and Clique and ...
Definition: CbcModel.hpp:3100
double getIntegerTolerance() const
Get the integrality tolerance .
Definition: CbcModel.hpp:687
CbcStatistics ** statistics_
statistics
Definition: CbcModel.hpp:3153
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 setAllowablePercentageGap(double value)
Set the percentage allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:741
CbcTree * tree_
Tree.
Definition: CbcModel.hpp:2987
int numberIntegers() const
Number of integers in problem.
Definition: CbcModel.hpp:1133
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
Definition: CbcModel.hpp:1695
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
int CbcMain(int argc, const char *argv[], CbcModel &babSolver)
int maximumNumberIterations_
Maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:3203
Adjusts printout 1 does different node message with number unsatisfied on last branch.
Definition: CbcModel.hpp:121
void setApplicationData(void *appData)
Set application data.
Base class for message handling.
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
Definition: CbcModel.hpp:152
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
virtual bool isInteger(int colIndex) const
Return true if the variable is integer.
bool isInitialSolveProvenPrimalInfeasible() const
Is primal infeasiblity proven (for initialSolve) ?
This class allows for the use of more exotic solvers e.g.
Definition: OsiAuxInfo.hpp:52
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
void deleteSolutions()
Delete best and saved solutions.
virtual int getNumCols() const =0
Get the number of columns.
void makeGlobalCuts()
Make partial cuts into global cuts.
double * bestSolution() const
The best solution to the integer programming problem.
Definition: CbcModel.hpp:1467
bool isProvenInfeasible() const
Is infeasiblity proven (or none better than cutoff)?
const OsiRowCut ** lastCut_
Definition: CbcModel.hpp:2894
CbcFullNodeInfo * topOfTree_
Pointer to top of tree.
Definition: CbcModel.hpp:2989
bool eventHappened_
Whether event happened.
Definition: CbcModel.hpp:3167
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
Definition: CbcModel.hpp:1767
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
double penaltyScaleFactor_
Scale factor to make penalties match strong.
Definition: CbcModel.hpp:3047
int numberStrongIterations_
Number of iterations in strong branching.
Definition: CbcModel.hpp:3189
CbcNode ** solveOneNode(int whichSolver, CbcNode *node, int &numberNodesOutput, int &status)
Input one node output N nodes to put on tree and optional solution update This should be able to oper...
int numberUpdateItems_
Number of outstanding update information items.
Definition: CbcModel.hpp:3207
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
int numberGlobalViolations() const
Number of times global cuts violated.
Definition: CbcModel.hpp:1568
CbcNode * currentNode() const
Get a pointer to current node (be careful)
Definition: CbcModel.hpp:2555
Abstract Base Class for describing an interface to a solver.
void setCutAndHeuristicOptions(CbcModel &model)
int getMaximumCutPasses() const
Get the maximum number of cut passes at other nodes (default 10)
Definition: CbcModel.hpp:836
void moveToModel(CbcModel *baseModel, int mode)
Move/copy information from one model to another -1 - initialization 0 - from base model 1 - to base m...
bool ownObjects() const
Now we may not own objects - just point to solver&#39;s objects.
Definition: CbcModel.hpp:2148
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:1303
double getHeuristicGap() const
Get the heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:762
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
Definition: CbcModel.hpp:1266
int maximumCutPassesAtRoot_
Maximum number of cut passes at root.
Definition: CbcModel.hpp:3127
double getAllowablePercentageGap() const
Get the percentage allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:748
OsiSolverInterface * referenceSolver_
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2732
bool maximumSecondsReached() const
Return true if maximum time reached.
Fathoming discipline.
Definition: CbcModel.hpp:117
int numberNodes2_
Cumulative number of nodes for statistics.
Definition: CbcModel.hpp:2837
int maximumDepth_
Current limit on search tree depth.
Definition: CbcModel.hpp:2884
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
Definition: CbcModel.hpp:1226
bool isSecondsLimitReached() const
Time limit reached?
int whenCuts() const
Get at which depths to do cuts.
Definition: CbcModel.hpp:878
void incrementSubTreeStopped()
Says a sub tree was stopped.
Definition: CbcModel.hpp:1663
int threadMode_
thread mode always use numberThreads for branching 1 set then deterministic 2 set then use numberThre...
Definition: CbcModel.hpp:3229
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
Definition: CbcModel.hpp:824
double getMinimumDrop() const
Get the minimum drop to continue cuts.
Definition: CbcModel.hpp:812
CbcCutModifier * cutModifier_
Cut modifier function.
Definition: CbcModel.hpp:2999
void zapGlobalCuts()
Get rid of global cuts.
Definition: CbcModel.hpp:2548
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
Definition: CbcModel.hpp:1400
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...
bool isProvenDualInfeasible() const
Was continuous solution unbounded.
int printFrequency() const
Get the print frequency.
Definition: CbcModel.hpp:992
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...
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 &amp; cut algorithm.
CbcBaseModel * master_
Thread stuff for master.
Definition: CbcModel.hpp:3233
CbcEvent
Events known to cbc.
const double * cbcReducedCost_
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
Definition: CbcModel.hpp:3022
virtual bool isContinuous(int colIndex) const =0
Return true if the variable is continuous.
Current minimization objective value.
Definition: CbcModel.hpp:163
CoinWarmStartBasis * getEmptyBasis(int ns=0, int na=0) const
Return an empty basis object of the specified size.
double getAllowableFractionGap() const
Get the fraction allowable gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:734
int logLevel() const
Get current log (detail) level.
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
Definition: CbcModel.hpp:1710
void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2677
void synchronizeHandlers(int makeDefault)
Makes all handlers same.
void setNumberPenalties(int number)
Set the number of variables for which to compute penalties in dynamic strong branching.
double getAllowableGap() const
Get the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:719
int numberNodes_
Cumulative number of nodes.
Definition: CbcModel.hpp:2833
int numberFixedAtRoot_
Number of fixed by analyze at root.
Definition: CbcModel.hpp:3161
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
int whenCuts_
At which depths to do cuts.
Definition: CbcModel.hpp:2825
const OsiObject * object(int which) const
Get the specified object.
Definition: CbcModel.hpp:510
int numberFathoms_
Number of times fast lp entered.
Definition: CbcModel.hpp:3116
int continuousInfeasibilities_
Number of infeasibilities at continuous.
Definition: CbcModel.hpp:3125
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 getCurrentPassNumber() const
Get current cut pass number in this round of cuts.
Definition: CbcModel.hpp:842
bool isInteger(int colIndex) const
Return true if column is integer.
Definition: CbcModel.hpp:1248
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.
int numberIntegers_
Number of integers in problem.
Definition: CbcModel.hpp:2856
Class to deal with symmetry.
Definition: CbcSymmetry.hpp:66
int problemType_
Problem type as set by user or found by analysis.
Definition: CbcModel.hpp:3062
Base class for Cbc event handling.
int strongInfo_[7]
0 - number times strong branching done, 1 - number fixed, 2 - number infeasible Second group of three...
Definition: CbcModel.hpp:3192
int typePresolve() const
Whether to automatically do presolve before branch and bound (subTrees).
Definition: CbcModel.hpp:1672
CoinMessageHandler * messageHandler() const
Return handler.
Definition: CbcModel.hpp:1945
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
OsiObject ** objects() const
Get the array of objects.
Definition: CbcModel.hpp:504
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
Get a pointer to an array[getNumRows()] of row right-hand sides.
double * currentSolution() const
Solution to the most recent lp relaxation.
Definition: CbcModel.hpp:1375
void deleteNode(CbcNode *node)
Delete a node and possibly null out currentNode_.
Just a marker, so that a static sized array can store parameters.
Definition: CbcModel.hpp:126
This is a first attempt at a message handler.
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
Definition: CbcModel.hpp:1272
void setMaximumSavedSolutions(int value)
Set maximum number of extra saved solutions.
double sumChangeObjective1_
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:2768
void setUseElapsedTime(bool yesNo)
Set time method.
Definition: CbcModel.hpp:2123
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
Definition: CbcModel.hpp:1327
int numberCutGenerators() const
Get the number of cut generators.
Definition: CbcModel.hpp:1762
int getPreferredWay() const
Get the preferred way to branch (default 0)
Definition: CbcModel.hpp:873
double getInfinity() const
Get solver&#39;s value for infinity.
Definition: CbcModel.hpp:1278
virtual const double * getColLower() const =0
Get a pointer to an array[getNumCols()] of column lower bounds.
Cut Generator Base Class.
int numberHeuristicSolutions_
Number of heuristic solutions.
Definition: CbcModel.hpp:2831
int stopNumberIterations_
For threads - stop after this many &quot;iterations&quot;.
Definition: CbcModel.hpp:3044
int numberStoppedSubTrees() const
Returns number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:1658
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
Definition: CbcModel.hpp:1834
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
Definition: CbcModel.hpp:2230
void gutsOfDestructor2()
Clears out enough to reset CbcModel as if no branch and bound done.
double bestObjective_
Best objective.
Definition: CbcModel.hpp:2764
const int * whichGenerator() const
Which cut generator generated this cut.
Definition: CbcModel.hpp:374
int getMaximumNodes() const
Get the maximum node limit .
Definition: CbcModel.hpp:622
const double * savedSolution(int which) const
Return a saved solution (0==best) - NULL if off end.
const double * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:1298
void setBestObjectiveValue(double objectiveValue)
Just update objectiveValue.
void redoWalkBack()
Redo walkback arrays.
int searchStrategy_
Strategy worked out - mainly at root node.
Definition: CbcModel.hpp:3175
int numberBeforeTrust_
The number of branches before pseudo costs believed in dynamic strong branching.
Definition: CbcModel.hpp:3038
int fastNodeDepth() const
Get depth for fast nodes.
Definition: CbcModel.hpp:2606
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
Get the number of rows.
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
double * analyzeResults_
Arrays with analysis results.
Definition: CbcModel.hpp:3051
The amount by which to tighten the objective function cutoff when a new solution is discovered...
Definition: CbcModel.hpp:138
const double * cbcColSolution_
Pointer to array[getNumCols()] (for speed) of primal solution vector.
Definition: CbcModel.hpp:3018
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
CbcModel * parentModel() const
Get the current parent model.
Definition: CbcModel.hpp:1814
void setCutoff(double value)
Set cutoff bound on the objective function.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
Definition: CbcModel.hpp:1394
int printFrequency_
Print frequency.
Definition: CbcModel.hpp:3064
double continuousObjective_
Value of objective at continuous (Well actually after initial round of cuts)
Definition: CbcModel.hpp:3120
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
void passInPriorities(const int *priorities, bool ifNotSimpleIntegers)
Pass in branching priorities.
int numberBeforeTrust() const
get the number of branches before pseudo costs believed in dynamic strong branching.
Definition: CbcModel.hpp:902
virtual bool isBinary(int colIndex) const
Return true if the variable is binary.
virtual double getInfinity() const =0
Get the solver&#39;s value for infinity.
CoinWarmStartBasis bestSolutionBasis_
Warm start object produced by heuristic or strong branching.
Definition: CbcModel.hpp:2803
int howOftenGlobalScan_
How often to scan global cuts.
Definition: CbcModel.hpp:3107
OsiRowCut augmented with bookkeeping.
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
Definition: CbcModel.hpp:1732
int callCbc1(const char *input2, CbcModel &babSolver, int(CbcModel *currentSolver, int whereFrom))
bool keepNamesPreproc
keepNamesPreproc if variables names will be preserved in the pre-processed problem (usefull in callba...
Definition: CbcModel.hpp:2795
double getCurrentSeconds() const
Current time since start of branchAndbound.
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...
int maximumDepthActual_
Maximum depth reached.
Definition: CbcModel.hpp:3155
void setNumberObjects(int number)
Set the number of objects.
Definition: CbcModel.hpp:498
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
Definition: CbcModel.hpp:1423
double getContinuousObjective() const
Value of objective at continuous.
Definition: CbcModel.hpp:1539
int numberRowsAtContinuous_
Number of rows at continuous.
Definition: CbcModel.hpp:2858
CoinWarmStart * emptyWarmStart_
Pointer to an empty warm start object.
Definition: CbcModel.hpp:2761
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:2627
CbcBaseModel * master() const
Thread stuff for master.
Definition: CbcModel.hpp:2345
CbcModel()
Default Constructor.
int continuousPriority() const
Get anything with priority &gt;= this can be treated as continuous.
Definition: CbcModel.hpp:2611
CbcBranchDecision * branchingMethod_
Variable selection function.
Definition: CbcModel.hpp:2997
Optimization direction - stored for speed.
Definition: CbcModel.hpp:159
Information required while the node is live.
Definition: CbcNode.hpp:49
int numberFixedNow_
Number fixed by analyze so far.
Definition: CbcModel.hpp:3163
For gathering statistics.
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
Definition: CbcModel.hpp:1293
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:970
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
Definition: CbcModel.hpp:1487
const double * cbcRowActivity_
Pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:3024
int getNumRows() const
Get number of rows.
Definition: CbcModel.hpp:1121
int numberStoppedSubTrees_
Number of times any subtree stopped on nodes, time etc.
Definition: CbcModel.hpp:2995
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:793
virtual double getObjValue() const =0
Get the objective function value.
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
Definition: CbcModel.hpp:2329
int continuousPriority_
Anything with priority &gt;= this can be treated as continuous.
Definition: CbcModel.hpp:3205
int numberCutGenerators_
Number of cut generators.
Definition: CbcModel.hpp:3066
int currentPassNumber_
Current cut pass number.
Definition: CbcModel.hpp:3133
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
Definition: CbcModel.hpp:2567
int numberObjects_
Total number of objects.
Definition: CbcModel.hpp:3088
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
Definition: CbcModel.hpp:1532
int currentDepth() const
Current depth.
Definition: CbcModel.hpp:957
double dblParam_[CbcLastDblParam]
Array for double parameters.
Definition: CbcModel.hpp:2751
void CbcMain0(CbcModel &babSolver)
The maximum number of solutions before terminating.
Definition: CbcModel.hpp:107
int getExtraNodeCount() const
Get how many Nodes were enumerated in complete fathoming B&amp;B inside CLP.
Definition: CbcModel.hpp:1038
CbcFeasibilityBase * problemFeasibility_
User feasibility function (see CbcFeasibleBase.hpp)
Definition: CbcModel.hpp:2985
Row Cut Class.
Definition: OsiRowCut.hpp:29
CbcCompareBase * nodeComparison() const
Definition: CbcModel.hpp:1620
int maximumStatistics_
Maximum number of statistics.
Definition: CbcModel.hpp:3151
int maximumSavedSolutions_
Maximum number of saved solutions.
Definition: CbcModel.hpp:2816
OsiSolverInterface * continuousSolver_
A copy of the solver, taken at the continuous (root) node.
Definition: CbcModel.hpp:2729
CoinMessages messages_
Cbc messages.
Definition: CbcModel.hpp:2745
int getNumCols() const
Get number of columns.
Definition: CbcModel.hpp:1115
CbcRowCuts globalCuts_
Global cuts.
Definition: CbcModel.hpp:2805
int intParam_[CbcLastIntParam]
Array for integer parameters.
Definition: CbcModel.hpp:2748
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:2653
bool defaultHandler_
Flag to say if handler_ is the default handler.
Definition: CbcModel.hpp:2742
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
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
Definition: CbcModel.hpp:1214
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
Definition: CbcModel.hpp:1809
void incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
Definition: CbcModel.hpp:1023
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
int getNumberThreads() const
Get number of threads.
Definition: CbcModel.hpp:2296
int maximumNumberCuts_
Maximum number of cuts.
Definition: CbcModel.hpp:2866
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
Sparse Matrix Base Class.
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 ...
void setObjValue(double value)
Set best objective function value.
Definition: CbcModel.hpp:1451
The maximum number of seconds before terminating.
Definition: CbcModel.hpp:155
CoinMessages & messages()
Return messages.
Definition: CbcModel.hpp:1950
bool allDynamic() const
Says whether all dynamic integers.
Definition: CbcModel.hpp:2663
const int COIN_INT_MAX
Definition: CoinFinite.hpp:19
void initialSolve()
Solve the initial LP relaxation.
bool ownObjects_
Now we may not own objects - just point to solver&#39;s objects.
Definition: CbcModel.hpp:3102
int maximumCutPasses_
Maximum number of cut passes.
Definition: CbcModel.hpp:3129
bool isContinuous(int colIndex) const
Return true if variable is continuous.
Definition: CbcModel.hpp:1233
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
Definition: CbcModel.hpp:1412
int lastDepth_
Definition: CbcModel.hpp:2895
CbcRowCuts * globalCuts()
Global cuts.
Definition: CbcModel.hpp:2543
int status() const
Final status of problem Some of these can be found out by is......
Definition: CbcModel.hpp:1056
CbcRowCuts * globalConflictCuts_
Global conflict cuts.
Definition: CbcModel.hpp:2807
int maximumCuts_
Definition: CbcModel.hpp:2897
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
Get a pointer to an array[getNumCols()] of primal variable values.
const double * cbcRowUpper_
Pointer to array[getNumRows()] (for speed) of row upper bounds.
Definition: CbcModel.hpp:3016
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
Definition: CbcModel.hpp:1176
void addObjects(int numberObjects, OsiObject **objects)
Add in object information.
int getStopNumberIterations() const
Get number of &quot;iterations&quot; to stop after.
Definition: CbcModel.hpp:1596
CglStored * storedRowCuts_
Stored row cuts for donor/recipient CbcModel.
Definition: CbcModel.hpp:3213
Base class for Clp event handling.
void incrementExtra(int nodes, int iterations, int fathoms=1)
Definition: CbcModel.hpp:2620
OsiSolverInterface * solver() const
Returns solver - has current state.
Definition: CbcModel.hpp:2216
Heuristic base class.
bool isInitialSolveAbandoned() const
Are there numerical difficulties (for initialSolve) ?
int splitModel(int numberModels, CbcModel **model, int numberNodes)
Split up nodes.
Language
Supported languages.
int numberIterations_
Cumulative number of iterations.
Definition: CbcModel.hpp:2839
double * continuousSolution_
Holds solution at continuous (after cuts)
Definition: CbcModel.hpp:2922
void sayEventHappened()
Tell model to stop on event.
Definition: CbcModel.hpp:2044
Abstract cut modifier base class.
double getObjValue() const
Get best objective function value.
Definition: CbcModel.hpp:1440
double ** savedSolutions_
Arrays holding other solutions.
Definition: CbcModel.hpp:2775
bool isLocked() const
From here to end of section - code in CbcThread.cpp until class changed Returns true if locked...
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 numberAnalyzeIterations_
Number of analyze iterations to do.
Definition: CbcModel.hpp:3049
virtual double getObjSense() const =0
Get the objective function sense.
int secondaryStatus_
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
Definition: CbcModel.hpp:2854
void setParentModel(CbcModel &parentModel)
Set the parent model.
Definition: CbcModel.hpp:1819
virtual bool isFreeBinary(int colIndex) const
Return true if the variable is binary and not fixed.
int CoinBigIndex
int * hotstartPriorities_
Hotstart priorities.
Definition: CbcModel.hpp:2829
bool isContinuousUnbounded() const
Was continuous solution unbounded.
double originalContinuousObjective_
Value of objective before root node cuts added.
Definition: CbcModel.hpp:3123
int getNodeCount() const
Get how many Nodes it took to solve the problem (including those in complete fathoming B&amp;B inside CLP...
Definition: CbcModel.hpp:1028
void zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
CglPreProcess * preProcess_
preProcess used before branch and bound (optional)
Definition: CbcModel.hpp:2892
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
Information required to recreate the subproblem at this node.
void setSecondaryStatus(int value)
Definition: CbcModel.hpp:1080
void setMaximumNumberIterations(int value)
Set maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2587
CbcModel * subTreeModel_
A pointer to model to be used for subtrees.
Definition: CbcModel.hpp:2991
Base model.
Definition: CbcThread.hpp:475
CoinWarmStartBasis workingBasis_
Work basis for temporary use.
Definition: CbcModel.hpp:3147
void * appData_
Pointer to user-defined data structure.
Definition: CbcModel.hpp:3026
void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0)
Do heuristics at root.
void setContinuousObjective(double value)
Definition: CbcModel.hpp:1543
void analyzeObjective()
Analyze problem to find a minimum change in the objective function.
int numberPenalties() const
get the number of variables for which to compute penalties in dynamic strong branching.
Definition: CbcModel.hpp:914
void setProblemStatus(int value)
Definition: CbcModel.hpp:1060
bool stoppedOnGap_
Whether stopping on gap.
Definition: CbcModel.hpp:3165
int numberStrongIterations() const
Get the number of iterations done in strong branching.
Definition: CbcModel.hpp:2577
CbcAction
Action codes returned by the event handler.
Largest non-zero change on a branch.
Definition: CbcModel.hpp:188
int specialOptions() const
Get special options.
Definition: CbcModel.hpp:2019
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
Definition: CbcModel.hpp:1283
int getSolutionCount() const
Get number of solutions.
Definition: CbcModel.hpp:1481
bool useElapsedTime() const
Get time method.
Definition: CbcModel.hpp:2131
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
void setTestSolution(const double *solution)
Definition: CbcModel.hpp:1386
char integerType(int i) const
Whether or not integer.
Definition: CbcModel.hpp:1143
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
Definition: CbcModel.hpp:1642
OsiRowCut * nextRowCut_
A pointer to a row cut which will be added instead of normal branching.
Definition: CbcModel.hpp:2912
int phase_
Current phase (so heuristics etc etc can find out).
Definition: CbcModel.hpp:2875
int numberSavedSolutions() const
Number of saved solutions (including best)
CbcModel * heuristicModel_
A pointer to model from CbcHeuristic.
Definition: CbcModel.hpp:2993
double penaltyScaleFactor() const
Get scale factor to make penalties match strong.
Definition: CbcModel.hpp:934
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
Definition: CbcModel.hpp:608
double getMinimizationObjValue() const
Get best objective function value as minimization.
Definition: CbcModel.hpp:1429
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
Definition: CbcModel.hpp:1156
OsiBabSolver * solverCharacteristics_
For advanced applications you may wish to modify the behavior of Cbc e.g.
Definition: CbcModel.hpp:3199
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
int numberAnalyzeIterations() const
Definition: CbcModel.hpp:928
bool setAllowableGap(double value)
Set the allowable gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:712
void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
Definition: CbcModel.hpp:2685
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
void setMinimumDrop(double value)
Set the minimum drop to continue cuts.
Definition: CbcModel.hpp:807
int * usedInSolution_
Array marked whenever a solution is found if non-zero.
Definition: CbcModel.hpp:2924
int getIntParam(CbcIntParam key) const
Get an integer parameter.
Definition: CbcModel.hpp:591
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
double getInfeasibilityWeight() const
Get the weight per integer infeasibility .
Definition: CbcModel.hpp:704
Validate cuts against a known solution.
int presolve_
Presolve for CbcTreeLocal.
Definition: CbcModel.hpp:3028
CbcThread * masterThread_
Pointer to masterthread.
Definition: CbcModel.hpp:3235
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
Definition: CbcModel.hpp:2582
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
Definition: CbcModel.hpp:1777
void resetModel()
Clears out enough to reset CbcModel cutoff etc.
void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod)
Go to dantzig pivot selection if easy problem (clp only)
int problemType() const
Definition: CbcModel.hpp:952
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...
CbcCutGenerator ** virginGenerator_
Definition: CbcModel.hpp:3070
OsiBranchingInformation usefulInformation() const
Generate an OsiBranchingInformation object.
Class for preProcessing and postProcessing.
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
virtual const double * getObjCoefficients() const =0
Get a pointer to an array[getNumCols()] of objective function coefficients.
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...
CglTreeProbingInfo * probingInfo() const
Get a pointer to probing info.
Definition: CbcModel.hpp:2562
int numberExtraIterations() const
Number of extra iterations.
Definition: CbcModel.hpp:2634
virtual const CoinPackedMatrix * getMatrixByRow() const =0
Get a pointer to a row-wise copy of the matrix.
std::vector< std::pair< std::string, double > > mipStart_
MIPstart values values for integer variables which will be converted to a complete integer initial fe...
Definition: CbcModel.hpp:2789
int numberOldActiveCuts_
Number of old active cuts.
Definition: CbcModel.hpp:3171
void AddIntegers()
Add additional integers.
int maximumSavedSolutions() const
Maximum number of extra saved solutions.
Definition: CbcModel.hpp:1494
bool solveWithCuts(OsiCuts &cuts, int numberTries, CbcNode *node)
Evaluate a subproblem using cutting planes and heuristics.
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
Definition: CbcModel.hpp:1926
CbcStrategy * strategy() const
Get the current strategy.
Definition: CbcModel.hpp:1802
int getMaximumSolutions() const
Get the maximum number of solutions desired.
Definition: CbcModel.hpp:639
void setContinuousInfeasibilities(int value)
Definition: CbcModel.hpp:1552
int reducedCostFix()
Perform reduced cost fixing.
void saveSolution(const ClpSimplex *lpSolver, std::string fileName)
Solver Branch Class.
const double * testSolution_
For testing infeasibilities - will point to currentSolution_ or solver–&gt;getColSolution() ...
Definition: CbcModel.hpp:2785
bool setMaximumSeconds(double value)
Set the maximum number of seconds desired.
Definition: CbcModel.hpp:659
virtual const double * getRowUpper() const =0
Get a pointer to an array[getNumRows()] of row upper bounds.
Interface between Cbc and Cut Generation Library.
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const
Set objective value in a node.
virtual const double * getReducedCost() const =0
Get a pointer to an array[getNumCols()] of reduced costs.
virtual const double * getRowLower() const =0
Get a pointer to an array[getNumRows()] of row lower bounds.
void setTypePresolve(int value)
Definition: CbcModel.hpp:1676
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
double getMaximumSeconds() const
Get the maximum number of seconds desired.
Definition: CbcModel.hpp:667
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
Definition: CbcModel.hpp:785
int numberPenalties_
The number of variables for which to compute penalties in dynamic strong branching.
Definition: CbcModel.hpp:3042
bool setHeuristicGap(double value)
Set the heuristic gap between the best known solution and the best possible solution.
Definition: CbcModel.hpp:755
CbcModel * findCliques(bool makeEquality, int atLeastThisMany, int lessThanThis, int defaultValue=1000)
Identify cliques and construct corresponding objects.
double getHeuristicFractionGap() const
Get the fraction heuristic gap between the best known solution and the best possible solution...
Definition: CbcModel.hpp:777
The maximum amount the value of an integer variable can vary from integer and still be considered fea...
Definition: CbcModel.hpp:132
Abstract base class for `objects&#39;.
virtual const double * getRowRange() const =0
Get a pointer to an array[getNumRows()] of row ranges.
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
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
double getDblParam(CbcDblParam key) const
Get a double parameter.
Definition: CbcModel.hpp:596
int numberExtraIterations_
Number of extra iterations in fast lp.
Definition: CbcModel.hpp:3112
OsiObject * modifiableObject(int which) const
Get the specified object.
Definition: CbcModel.hpp:515
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
Definition: CbcModel.hpp:1308
void setPreferredWay(int value)
Set global preferred way to branch -1 down, +1 up, 0 no preference.
Definition: CbcModel.hpp:868
int * originalColumns_
Original columns as created by integerPresolve or preprocessing.
Definition: CbcModel.hpp:3105
CoinThreadRandom randomNumberGenerator_
Thread specific random number generator.
Definition: CbcModel.hpp:3145
Dual Row Pivot Abstract Base Class.
double getBestPossibleObjValue() const
Get best possible objective function value.
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
Definition: CbcModel.hpp:1208
void gutsOfDestructor()
Clears out as much as possible (except solver)
const int * strongInfo() const
Return strong info.
Definition: CbcModel.hpp:2642
int numberThreads_
Parallel 0 - off 1 - testing 2-99 threads other special meanings.
Definition: CbcModel.hpp:3221
Simple Branch and bound class.
Definition: CbcModel.hpp:100
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
Definition: CbcModel.hpp:2248
Abstract base class for warm start information.
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.
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
Definition: CbcModel.hpp:1577
int randomSeed_
Random seed.
Definition: CbcModel.hpp:3139
void setStopNumberIterations(int value)
Set number of &quot;iterations&quot; 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
CbcFeasibilityBase * problemFeasibility() const
Definition: CbcModel.hpp:1631
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.
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
Definition: CbcModel.hpp:1318
int moreSpecialOptions_
More special options at present bottom 6 bits used for shadow price mode 1024 for experimental hotsta...
Definition: CbcModel.hpp:2967
int currentNumberCuts_
Number of entries in addedCuts_.
Definition: CbcModel.hpp:2878
void setNextRowCut(const OsiRowCut &cut)
Copy and set a pointer to a row cut which will be added instead of normal branching.
Class to hold and manipulate an array of massaged messages.
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
Definition: CbcModel.hpp:1772
void originalModel(CbcModel *presolvedModel, bool weak)
Put back information into the original model after integer presolve.
Strategy base class.
Definition: CbcStrategy.hpp:18
int numberGlobalViolations_
Number of times global cuts violated.
Definition: CbcModel.hpp:3110
void pseudoShadow(int type)
Fill in useful estimates.
bool doCutsNow(int allowForTopOfTree) const
Return true if we want to do cuts If allowForTopOfTree zero then just does on multiples of depth if 1...
int numberHeuristics_
Number of heuristics.
Definition: CbcModel.hpp:3072
void passInSubTreeModel(CbcModel &model)
For passing in an CbcModel to do a sub Tree (with derived tree handlers).
Class for thread specific random numbers.
bool isInitialSolveProvenDualInfeasible() const
Is dual infeasiblity proven (for initialSolve) ?
virtual ~CbcModel()
Destructor.
A class to encapsulate thread stuff.
Definition: CbcThread.hpp:466
double * hotstartSolution_
Hotstart solution.
Definition: CbcModel.hpp:2827
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
const int * hotstartPriorities() const
Get the hotstart priorities.
Definition: CbcModel.hpp:2527
void adjustHeuristics()
Adjust heuristics based on model.
double sumChangeObjective() const
Sum of Changes to objective by first solve.
Definition: CbcModel.hpp:1562
const int * integerVariable() const
Definition: CbcModel.hpp:1138
virtual void setObjSense(double s)=0
Set the objective function sense.
int maximumWhich_
Maximum number of cuts (for whichGenerator_)
Definition: CbcModel.hpp:3135
double bestPossibleObjective_
Best possible objective.
Definition: CbcModel.hpp:2766
void moveInfo(const CbcModel &rhs)
Move status, nodes etc etc across.
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
Definition: CbcModel.hpp:1880
int getFathomCount() const
Get how many times complete fathoming B&amp;B was done.
Definition: CbcModel.hpp:1043
virtual const double * getColUpper() const =0
Get a pointer to an array[getNumCols()] of column upper bounds.