10 #include "CoinMessageHandler.hpp"
11 #include "OsiSolverInterface.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiCuts.hpp"
14 #include "CoinWarmStartBasis.hpp"
19 #include "ClpDualRowPivot.hpp"
26 class OsiRowCutDebugger;
27 class CglCutGenerator;
30 class CglTreeProbingInfo;
42 class OsiClpSolverInterface;
228 bool solveWithCuts(OsiCuts & cuts,
int numberTries,
CbcNode * node);
236 int serialCuts(OsiCuts & cuts,
CbcNode * node, OsiCuts & slackCuts,
int lastNumberCuts);
252 int & numberNodesOutput,
int &
status) ;
254 void resizeWhichGenerator(
int numberNow,
int numberAfter);
256 #ifdef CBC_KEEP_DEPRECATED
262 CbcModel * cleanModel(
const double * lower,
const double * upper);
279 int subBranchAndBound(
CbcModel * model2,
297 int subBranchAndBound(
const double * lower,
const double * upper,
306 OsiSolverInterface * strengthenedModel();
316 CglPreProcess * preProcess(
int makeEquality = 0,
int numberPasses = 5,
320 void postProcess(CglPreProcess * process);
348 double * saveLower = NULL,
349 double * saveUpper = NULL);
366 {
return whichGenerator_;}
384 int lessThanThis,
int defaultValue = 1000);
426 bool tightenVubs(
int type,
bool allowMultipleBinary =
false,
427 double useCutoff = 1.0e50);
434 bool tightenVubs(
int numberVubs,
const int * which,
435 double useCutoff = 1.0e50);
448 void saveModel(OsiSolverInterface * saveSolver,
double * checkCutoffForRestart,
bool * feasible);
464 return numberObjects_;
468 numberObjects_ = number;
477 const inline OsiObject *
object(
int which)
const {
478 return object_[which];
482 return object_[which];
516 #ifdef SWITCH_VARIABLES
520 int fixAssociated(OsiSolverInterface *
solver,
int cleanBasis);
522 int checkAssociated(
const OsiSolverInterface *
solver,
523 const double * solution,
int printLevel);
540 intParam_[key] = value;
545 dblParam_[key] = value;
550 return intParam_[key];
554 return dblParam_[key];
739 minimumDrop_ = value;
749 maximumCutPassesAtRoot_ = value;
753 return maximumCutPassesAtRoot_;
759 maximumCutPasses_ = value;
763 return maximumCutPasses_;
768 return currentPassNumber_;
773 currentPassNumber_ = value;
786 return numberStrong_;
791 preferredWay_ = value;
795 return preferredWay_;
810 bool doCutsNow(
int allowForTopOfTree)
const;
821 return numberBeforeTrust_;
832 return numberPenalties_;
836 {
return topOfTree_;}
839 numberAnalyzeIterations_ = number;
842 return numberAnalyzeIterations_;
847 return penaltyScaleFactor_;
860 problemType_ = number;
867 return currentDepth_;
874 return howOftenGlobalScan_;
878 return originalColumns_;
882 int numberGood=COIN_INT_MAX) ;
894 printFrequency_ = number;
898 return printFrequency_;
923 return numberIterations_;
927 numberIterations_ += value;
935 numberNodes_ += value;
939 return numberExtraNodes_;
943 return numberFathoms_;
973 return secondaryStatus_;
976 secondaryStatus_ = value;
1004 return numberRowsAtContinuous_;
1009 return solver_->getNumCols();
1014 return solver_->getNumRows();
1019 return solver_->getNumElements();
1024 return numberIntegers_;
1028 return integerVariable_;
1032 assert (integerInfo_);
1033 assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
1034 return integerInfo_[i];
1038 return integerInfo_;
1043 return solver_->getColLower();
1048 return solver_->getColUpper();
1061 return solver_->getRowSense();
1073 return solver_->getRightHandSide();
1085 return solver_->getRowRange();
1090 return solver_->getRowLower();
1095 return solver_->getRowUpper();
1100 return solver_->getObjCoefficients();
1111 return solver_->isContinuous(colIndex);
1116 return solver_->isBinary(colIndex);
1124 return solver_->isInteger(colIndex);
1129 return solver_->isIntegerNonBinary(colIndex);
1134 return solver_->isFreeBinary(colIndex) ;
1139 return solver_->getMatrixByRow();
1144 return solver_->getMatrixByCol();
1149 return solver_->getInfinity();
1153 return cbcColLower_;
1157 return cbcColUpper_;
1161 return cbcRowLower_;
1165 return cbcRowUpper_;
1169 return cbcColSolution_;
1173 return cbcRowPrice_;
1177 return cbcReducedCost_;
1181 return cbcRowActivity_;
1190 return continuousSolution_;
1197 return usedInSolution_;
1203 double & objectiveValue,
const double *solution,
1204 int fixVariables = 0);
1210 const double * solution);
1219 virtual double checkSolution(
double cutoff,
double * solution,
1220 int fixVariables,
double originalObjValue);
1228 int & numberObjectInfeasibilities)
const;
1236 return currentSolution_;
1242 return testSolution_;
1245 testSolution_ = solution;
1252 return solver_->getColSolution();
1257 return solver_->getRowPrice();
1262 return solver_->getReducedCost();
1267 return solver_->getRowActivity();
1281 return bestObjective_;
1285 bestObjective_ = value;
1290 return bestObjective_ * solver_->getObjSense() ;
1300 bestObjective_ = value * solver_->getObjSense() ;
1304 return solver_->getObjValue() * solver_->getObjSense() ;
1314 return bestSolution_;
1323 double objectiveValue,
bool check =
false);
1327 return numberSolutions_;
1332 numberSolutions_ = value;
1338 return maximumSavedSolutions_;
1363 return numberHeuristicSolutions_;
1367 numberHeuristicSolutions_ = value;
1373 solver_->setObjSense(s);
1378 return originalContinuousObjective_;
1381 originalContinuousObjective_ = value;
1385 return continuousInfeasibilities_;
1388 continuousInfeasibilities_ = value;
1392 return continuousObjective_;
1396 return sumChangeObjective1_;
1401 return numberGlobalViolations_;
1404 numberGlobalViolations_ = 0;
1408 return resolveAfterTakeOffCuts_;
1411 resolveAfterTakeOffCuts_ = yesNo;
1415 return maximumRows_;
1419 return workingBasis_;
1423 return stopNumberIterations_;
1427 stopNumberIterations_ = value;
1431 {
return heuristicModel_;}
1434 { heuristicModel_ = model;}
1441 return nodeCompare_;
1451 return problemFeasibility_;
1476 return numberStoppedSubTrees_;
1480 numberStoppedSubTrees_++;
1504 return branchingMethod_;
1508 delete branchingMethod_;
1509 branchingMethod_ = method->
clone();
1516 delete branchingMethod_;
1517 branchingMethod_ = method.
clone();
1521 return cutModifier_;
1542 return stateOfSearch_;
1545 stateOfSearch_ = state;
1549 return searchStrategy_;
1553 searchStrategy_ = value;
1557 return strongStrategy_;
1561 strongStrategy_ = value;
1566 return numberCutGenerators_;
1574 return generator_[i];
1578 return virginGenerator_[i];
1589 int howOften = 1,
const char * name = NULL,
1590 bool normal =
true,
bool atSolution =
false,
1591 bool infeasible =
false,
int howOftenInSub = -100,
1592 int whatDepth = -1,
int whatDepthInSub = -1);
1612 return parentModel_;
1631 return heuristic_[i];
1635 return numberHeuristics_;
1639 numberHeuristics_ = value;
1643 return lastHeuristic_;
1647 lastHeuristic_ = last;
1672 return object_[sequence]->priority();
1683 return (eventHandler_) ;
1716 return solverCharacteristics_;
1727 void newLanguage(CoinMessages::Language language);
1747 return handler_->logLevel();
1755 defaultHandler_ = yesNo;
1759 return defaultHandler_;
1794 specialOptions_ = value;
1798 return specialOptions_;
1802 randomSeed_ = value;
1810 multipleRootTries_ = value;
1814 return multipleRootTries_;
1818 { eventHappened_=
true;}
1821 return (specialOptions_&16) == 0;
1828 return (specialOptions_&1048576) != 0;
1854 moreSpecialOptions_ = value;
1858 return moreSpecialOptions_;
1875 moreSpecialOptions2_ = value;
1879 return moreSpecialOptions2_;
1883 cutoffRowNumber_ = (yesNo) ? -2 : -1;
1888 moreSpecialOptions_ |= 131072;
1890 moreSpecialOptions_ &= ~131072;
1894 return (moreSpecialOptions_&131072)!=0;
1898 {
return temporaryPointer_;}
1901 { temporaryPointer_=pointer;}
1903 void goToDantzig(
int numberNodes, ClpDualRowPivot *& savePivotMethod);
1919 CbcModel(
const OsiSolverInterface &);
1943 ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
1952 return ((ownership_&0x80000000) != 0) ;
1976 OsiSolverInterface * returnSolver = solver_;
1978 return returnSolver;
1983 return continuousSolver_;
1988 continuousSolver_ = solver_->clone();
1992 delete continuousSolver_;
1993 continuousSolver_ = NULL;
1998 return referenceSolver_;
2035 return masterThread_;
2043 return numberThreads_;
2047 numberThreads_ = value;
2063 threadMode_ = value;
2072 if (!numberThreads_) {
2073 if ((threadMode_&1) == 0)
2079 if ((threadMode_&1) == 0)
2134 return numberNodes2_;
2157 int resolveClp(OsiClpSolverInterface *
solver,
int type);
2165 CbcNode * oldNode, OsiCuts & cuts,
2166 bool & resolved, CoinWarmStartBasis *lastws,
2167 const double * lowerBefore,
const double * upperBefore,
2168 OsiSolverBranch * & branches);
2177 CoinWarmStartBasis *
getEmptyBasis(
int ns = 0,
int na = 0)
const ;
2191 bool allowResolve, OsiCuts * saveCuts,
2192 int numberNewCuts = 0,
const OsiRowCut ** newCuts = NULL) ;
2229 double & lower,
double & upper,
int force);
2256 int * numberDown = NULL,
int * numberUp = NULL,
2257 int * numberDownInfeasible = NULL,
2258 int * numberUpInfeasible = NULL)
const;
2269 return hotstartSolution_;
2273 return hotstartPriorities_;
2282 return currentNumberCuts_;
2286 return &globalCuts_;
2296 return currentNode_;
2300 return probingInfo_;
2304 return &randomNumberGenerator_;
2308 numberStrongIterations_ = number;
2312 return numberStrongIterations_;
2316 return maximumNumberIterations_;
2320 maximumNumberIterations_ = value;
2324 {
return symmetryInfo_;}
2327 fastNodeDepth_ = value;
2331 return fastNodeDepth_;
2335 return continuousPriority_;
2339 continuousPriority_ = value;
2342 numberExtraNodes_ += nodes;
2343 numberExtraIterations_ += iterations;
2344 numberFathoms_ += fathoms;
2348 numberExtraNodes_ = 0;
2349 numberExtraIterations_ = 0;
2354 return numberExtraIterations_;
2358 int numberFixed,
bool ifInfeasible);
2370 return storedRowCuts_;
2374 storedRowCuts_ = cuts;
2378 return ((ownership_&0x40000000) != 0) ;
2391 bestSolutionBasis_ = bestSolutionBasis;
2397 void setMIPStart(
const std::vector< std::pair< std::string, double > > &Mips ) {
2398 this->mipStart_ = Mips;
2401 const std::vector< std::pair< std::string, double > > &
getMIPStart() {
2402 return this->mipStart_;
2413 OsiSolverInterface * solver_;
2420 unsigned int ownership_ ;
2423 OsiSolverInterface * continuousSolver_;
2426 OsiSolverInterface * referenceSolver_;
2429 CoinMessageHandler * handler_;
2436 bool defaultHandler_;
2439 CoinMessages messages_;
2455 mutable CoinWarmStart *emptyWarmStart_ ;
2458 double bestObjective_;
2460 double bestPossibleObjective_;
2462 double sumChangeObjective1_;
2464 double sumChangeObjective2_;
2467 double * bestSolution_;
2469 double ** savedSolutions_;
2475 double * currentSolution_;
2479 mutable const double * testSolution_;
2483 std::vector< std::pair< std::string, double > > mipStart_;
2490 CoinWarmStartBasis bestSolutionBasis_ ;
2497 double minimumDrop_;
2499 int numberSolutions_;
2501 int numberSavedSolutions_;
2503 int maximumSavedSolutions_;
2514 double * hotstartSolution_;
2516 int * hotstartPriorities_;
2518 int numberHeuristicSolutions_;
2526 int numberIterations_;
2541 int secondaryStatus_;
2543 int numberIntegers_;
2545 int numberRowsAtContinuous_;
2551 int cutoffRowNumber_;
2553 int maximumNumberCuts_;
2565 int currentNumberCuts_;
2579 const OsiRowCut ** lastCut_;
2581 int lastNumberCuts2_;
2583 int * lastNumberCuts_;
2597 OsiRowCut * nextRowCut_;
2603 int * integerVariable_;
2605 char * integerInfo_;
2607 double * continuousSolution_;
2609 int * usedInSolution_;
2637 int specialOptions_;
2652 int moreSpecialOptions_;
2666 int moreSpecialOptions2_;
2680 int numberStoppedSubTrees_;
2694 const double * cbcColLower_;
2697 const double * cbcColUpper_;
2699 const double * cbcRowLower_;
2701 const double * cbcRowUpper_;
2703 const double * cbcColSolution_;
2705 const double * cbcRowPrice_;
2707 const double * cbcReducedCost_;
2709 const double * cbcRowActivity_;
2723 int numberBeforeTrust_;
2727 int numberPenalties_;
2729 int stopNumberIterations_;
2732 double penaltyScaleFactor_;
2734 int numberAnalyzeIterations_;
2736 double * analyzeResults_;
2738 void * temporaryPointer_;
2740 int numberInfeasibleNodes_;
2749 int printFrequency_;
2751 int numberCutGenerators_;
2757 int numberHeuristics_;
2765 # ifdef CBC_ONLY_CLP
2766 ClpEventHandler *eventHandler_ ;
2785 OsiObject ** object_;
2790 int * originalColumns_;
2792 int howOftenGlobalScan_;
2795 int numberGlobalViolations_;
2797 int numberExtraIterations_;
2799 int numberExtraNodes_;
2805 double continuousObjective_;
2808 double originalContinuousObjective_;
2810 int continuousInfeasibilities_;
2812 int maximumCutPassesAtRoot_;
2814 int maximumCutPasses_;
2818 int currentPassNumber_;
2826 int multipleRootTries_;
2830 mutable CoinThreadRandom randomNumberGenerator_;
2832 CoinWarmStartBasis workingBasis_;
2834 int * whichGenerator_;
2836 int maximumStatistics_;
2840 int maximumDepthActual_;
2842 double numberDJFixed_;
2844 CglTreeProbingInfo * probingInfo_;
2846 int numberFixedAtRoot_;
2848 int numberFixedNow_;
2852 mutable bool eventHappened_;
2854 int numberLongStrong_;
2856 int numberOldActiveCuts_;
2860 int searchStrategy_;
2872 int strongStrategy_;
2874 int numberStrongIterations_;
2884 OsiBabSolver * solverCharacteristics_;
2886 bool resolveAfterTakeOffCuts_;
2888 int maximumNumberIterations_;
2890 int continuousPriority_;
2892 int numberUpdateItems_;
2894 int maximumNumberUpdateItems_;
2898 CglStored * storedRowCuts_;
2916 int numberGlobalCutsIn_;
2925 double & originalUpper) ;
2928 class OsiClpSolverInterface;
2929 int CbcMain (
int argc,
const char *argv[], OsiClpSolverInterface & solver,
CbcModel ** babSolver);
2932 int callCbc(
const char * input2, OsiClpSolverInterface& solver1);
2933 int callCbc(
const char * input2);
2934 int callCbc(
const std::string input2, OsiClpSolverInterface& solver1);
2935 int callCbc(
const std::string input2) ;
void flipModel()
Flip direction of optimization on all models.
CbcThread * masterThread() const
Get pointer to masterthread.
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–>getColSolution() ...
void setProblemFeasibility(CbcFeasibilityBase *feasibility)
The objective is assumed to worsen by this amount for each integer infeasibility. ...
void resetToReferenceSolver()
Uses a copy of reference solver to be current solver.
Number of branches (may be more than number of nodes as may include strong branching) ...
void newLanguage(CoinMessages::Language language)
Set language.
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
void setPointers(const OsiSolverInterface *solver)
Set pointers for speed.
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
void setLastHeuristic(CbcHeuristic *last)
set last heuristic which found a solution
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
double getSolverObjValue() const
Get solver objective function value (as minimization)
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
void setOptionalInteger(int index)
int moreSpecialOptions() const
Get more special options.
void * getApplicationData() const
Get application data.
void setRandomSeed(int value)
Set random seed.
bool setAllowableFractionGap(double value)
Set the fraction allowable gap between the best known solution and the best possible solution...
const std::vector< std::pair< std::string, double > > & getMIPStart()
bool isInitialSolveProvenOptimal() const
Is optimality proven (for initialSolve) ?
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
int getPrintingMode() const
Get the printing mode.
void incrementStrongInfo(int numberTimes, int numberIterations, int numberFixed, bool ifInfeasible)
Increment strong info.
int CbcMain(int argc, const char *argv[], OsiClpSolverInterface &solver, CbcModel **babSolver)
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
bool isAbandoned() const
Are there a numerical difficulties?
The maximum number of nodes before terminating.
bool isNodeLimitReached() const
Node limit reached?
const char * integerType() const
Whether or not integer.
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
void setFastNodeDepth(int value)
Set depth for fast nodes.
void setNumberStrongIterations(int number)
Set the number of iterations done in strong branching.
int getThreadMode() const
Get thread mode.
int numberObjects() const
Get the number of objects.
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...
CoinBigIndex getNumElements() const
Get number of nonzero elements.
int moreSpecialOptions2() const
Get more special options2.
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
void setStrongStrategy(int value)
Set strong branching strategy.
int * mutableStrongInfo()
Return mutable strong info.
virtual CbcModel * clone(bool cloneHandler)
Clone.
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
void setCurrentPassNumber(int value)
Set current cut pass number in this round of cuts.
bool isBinary(int colIndex) const
Return true if variable is binary.
void setResolveAfterTakeOffCuts(bool yesNo)
int getIterationCount() const
Get how many iterations it took to solve the problem.
int numberHeuristics() const
Get the number of heuristics.
int secondaryStatus() const
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
void incrementNodeCount(int value)
Increment how many nodes it took to solve the problem.
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
int maximumRows() const
Maximum number of rows.
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
int getContinuousInfeasibilities() const
Number of infeasibilities at continuous.
int callCbc(const char *input2, OsiClpSolverInterface &solver1)
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
Just a marker, so that a static sized array can store parameters.
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
bool setInfeasibilityWeight(double value)
Set the weight per integer infeasibility .
void reserveCurrentSolution(const double *solution=NULL)
Make sure region there and optionally copy solution.
int getMultipleRootTries() const
Get multiple root tries.
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
bool setIntegerTolerance(double value)
Set the integrality tolerance .
int logLevel() const
Get log level.
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
const double * hotstartSolution() const
Get the hotstart solution.
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.
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
bool canStopOnGap() const
See if can stop on gap.
Cutoff - stored for speed.
bool isProvenOptimal() const
Is optimality proven?
CbcNodeInfo ** walkback() const
Get pointer to walkback.
int howOftenGlobalScan() const
Get how often to scan global cuts.
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
bool setDblParam(CbcDblParam key, double value)
Set a double parameter.
void clearContinuousSolver()
Clear solver with continuous state.
CoinMessages * messagesPointer()
Return pointer to messages.
void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver=NULL)
Make partial cut into a global cut and save.
int getRandomSeed() const
Get random seed.
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
int getNodeCount2() const
Get how many Nodes it took to solve the problem.
Sum of non-zero changes on a branch.
int phase() const
Current phase (so heuristics etc etc can find out).
bool modelOwnsSolver()
Get ownership of solver.
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
void setNumberAnalyzeIterations(int number)
Number of analyze iterations to do.
int currentNumberCuts() const
Number of entries in the list returned by addedCuts()
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
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.
void setNumberThreads(int value)
Set number of threads.
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
int strongStrategy() const
Stong branching strategy.
void setPrintFrequency(int number)
Set the print frequency.
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.
virtual double checkSolution(double cutoff, double *solution, int fixVariables, double originalObjValue)
Call this to really test if a valid solution can be feasible Solution is number columns in size...
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
void setNumberStrong(int number)
Set the maximum number of candidates to be evaluated for strong branching.
void setLanguage(CoinMessages::Language language)
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.
bool defaultHandler() const
Check default handler.
void convertToDynamic()
If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
double getIntegerTolerance() const
Get the integrality tolerance .
int numberStrong() const
Get the maximum number of candidates to be evaluated for strong branching.
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
bool setAllowablePercentageGap(double value)
Set the percentage allowable gap between the best known solution and the best possible solution...
int numberIntegers() const
Number of integers in problem.
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
int cliquePseudoCosts(int doStatistics)
Use cliques for pseudocost information - return nonzero if infeasible.
Adjusts printout 1 does different node message with number unsatisfied on last branch.
void setApplicationData(void *appData)
Set application data.
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
void setStrategy(CbcStrategy &strategy)
Set the strategy. Clones.
void setSearchStrategy(int value)
Set strategy worked out - mainly at root node for use by CbcNode.
bool isInitialSolveProvenPrimalInfeasible() const
Is primal infeasiblity proven (for initialSolve) ?
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
void deleteSolutions()
Delete best and saved solutions.
void makeGlobalCuts()
Make partial cuts into global cuts.
double * bestSolution() const
The best solution to the integer programming problem.
bool isProvenInfeasible() const
Is infeasiblity proven (or none better than cutoff)?
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
void setMoreSpecialOptions(int value)
Set more special options at present bottom 6 bits used for shadow price mode 1024 for experimental ho...
bool setPrintingMode(int value)
Set the printing mode.
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
int numberGlobalViolations() const
Number of times global cuts violated.
CbcNode * currentNode() const
Get a pointer to current node (be careful)
void saveSolution(const OsiSolverInterface *osi, std::string fileName)
void setCutAndHeuristicOptions(CbcModel &model)
int getMaximumCutPasses() const
Get the maximum number of cut passes at other nodes (default 10)
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's objects.
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
double getHeuristicGap() const
Get the heuristic gap between the best known solution and the best possible solution.
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
double getAllowablePercentageGap() const
Get the percentage allowable gap between the best known solution and the best possible solution...
bool maximumSecondsReached() const
Return true if maximum time reached.
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
bool isSecondsLimitReached() const
Time limit reached?
int whenCuts() const
Get at which depths to do cuts.
void incrementSubTreeStopped()
Says a sub tree was stopped.
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
double getMinimumDrop() const
Get the minimum drop to continue cuts.
void zapGlobalCuts()
Get rid of global cuts.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
void gutsOfCopy(const CbcModel &rhs, int mode=0)
Most of copy constructor mode - 0 copy but don't delete before 1 copy and delete before 2 copy and de...
bool isProvenDualInfeasible() const
Was continuous solution unbounded.
int printFrequency() const
Get the print frequency.
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 & cut algorithm.
CbcEvent
Events known to cbc.
Current minimization objective value.
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...
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
Warm start object produced by heuristic or strong branching.
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.
void setMinimizationObjValue(double value)
Set best objective function value as minimization.
void startSplitModel(int numberIterations)
Start threads.
Using MS heap implementation.
const OsiObject * object(int which) const
Get the specified object.
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
void setLogLevel(int value)
Set log level.
int getCurrentPassNumber() const
Get current cut pass number in this round of cuts.
bool isInteger(int colIndex) const
Return true if column is integer.
void setWhenCuts(int value)
Set at which depths to do cuts.
void setNumberBeforeTrust(int number)
Set the number of branches before pseudo costs believed in dynamic strong branching.
Class to deal with symmetry.
Base class for Cbc event handling.
int callCbc1(const char *input2, CbcModel &babSolver)
int typePresolve() const
Whether to automatically do presolve before branch and bound (subTrees).
CoinMessageHandler * messageHandler() const
Return handler.
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
OsiObject ** objects() const
Get the array of objects.
int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws)
Determine and install the active cuts that need to be added for the current subproblem.
double * currentSolution() const
Solution to the most recent lp relaxation.
Just a marker, so that a static sized array can store parameters.
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
void setMaximumSavedSolutions(int value)
Set maximum number of extra saved solutions.
void setUseElapsedTime(bool yesNo)
Set time method.
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
int numberCutGenerators() const
Get the number of cut generators.
int getPreferredWay() const
Get the preferred way to branch (default 0)
double getInfinity() const
Get solver's value for infinity.
int numberStoppedSubTrees() const
Returns number of times any subtree stopped on nodes, time etc.
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
void gutsOfDestructor2()
Clears out enough to reset CbcModel as if no branch and bound done.
const int * whichGenerator() const
Which cut generator generated this cut.
int getMaximumNodes() const
Get the maximum node limit .
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.
void setBestObjectiveValue(double objectiveValue)
Just update objectiveValue.
CbcSymmetry * symmetryInfo() const
Symmetry information.
void redoWalkBack()
Redo walkback arrays.
int fastNodeDepth() const
Get depth for fast nodes.
void setStateOfSearch(int state)
void setNodeComparison(CbcCompareBase *compare)
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
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.
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.
The amount by which to tighten the objective function cutoff when a new solution is discovered...
virtual CbcBranchDecision * clone() const =0
Clone.
void setProblemType(int number)
Problem type as set by user or found by analysis.
void saveBestSolution(const double *solution, double objectiveValue)
Save a solution to best and move current to saved.
void clearNumberGlobalViolations()
CbcModel * parentModel() const
Get the current parent model.
void setCutoff(double value)
Set cutoff bound on the objective function.
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
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.
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...
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's...
void setNumberObjects(int number)
Set the number of objects.
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.
double getContinuousObjective() const
Value of objective at continuous.
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.
CbcBaseModel * master() const
Thread stuff for master.
CbcModel()
Default Constructor.
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
Optimization direction - stored for speed.
Information required while the node is live.
For gathering statistics.
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
int getNumRows() const
Get number of rows.
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
int currentDepth() const
Current depth.
void CbcMain0(CbcModel &babSolver)
The maximum number of solutions before terminating.
int getExtraNodeCount() const
Get how many Nodes were enumerated in complete fathoming B&B inside CLP.
CbcCompareBase * nodeComparison() const
int getNumCols() const
Get number of columns.
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
void setMoreSpecialOptions2(int value)
Set more more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective u...
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
void incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
CBC_Message
This deals with Cbc messages (as against Clp messages etc).
Smallest non-zero change on a branch.
int getNumberThreads() const
Get number of threads.
void setMaximumCutPassesAtRoot(int value)
Set the maximum number of cut passes at root node (default 20) Minimum drop can also be used for fine...
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.
The maximum number of seconds before terminating.
CoinMessages & messages()
Return messages.
bool allDynamic() const
Says whether all dynamic integers.
void initialSolve()
Solve the initial LP relaxation.
bool isContinuous(int colIndex) const
Return true if variable is continuous.
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
CbcRowCuts * globalCuts()
Global cuts.
int status() const
Final status of problem Some of these can be found out by is......
bool setMaximumNodes(int value)
Set the maximum node limit .
The time at start of model.
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
void addObjects(int numberObjects, OsiObject **objects)
Add in object information.
int getStopNumberIterations() const
Get number of "iterations" to stop after.
void incrementExtra(int nodes, int iterations, int fathoms=1)
OsiSolverInterface * solver() const
Returns solver - has current state.
bool isInitialSolveAbandoned() const
Are there numerical difficulties (for initialSolve) ?
int splitModel(int numberModels, CbcModel **model, int numberNodes)
Split up nodes.
void sayEventHappened()
Tell model to stop on event.
Abstract cut modifier base class.
double getObjValue() const
Get best objective function value.
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.
void setBestSolution(CBC_Message how, double &objectiveValue, const double *solution, int fixVariables=0)
Record a new incumbent solution and update objectiveValue.
void setParentModel(CbcModel &parentModel)
Set the parent model.
bool isContinuousUnbounded() const
Was continuous solution unbounded.
int getNodeCount() const
Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP...
void zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
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)
void setMaximumNumberIterations(int value)
Set maximum number of iterations (designed to be used in heuristics)
void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0)
Do heuristics at root.
void setContinuousObjective(double value)
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.
void setProblemStatus(int value)
int numberStrongIterations() const
Get the number of iterations done in strong branching.
CbcAction
Action codes returned by the event handler.
Largest non-zero change on a branch.
int specialOptions() const
Get special options.
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
int getSolutionCount() const
Get number of solutions.
bool useElapsedTime() const
Get time method.
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.
void setTestSolution(const double *solution)
char integerType(int i) const
Whether or not integer.
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
int numberSavedSolutions() const
Number of saved solutions (including best)
double penaltyScaleFactor() const
Get scale factor to make penalties match strong.
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
double getMinimizationObjValue() const
Get best objective function value as minimization.
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
void setNumberHeuristics(int value)
Set the number of heuristics.
Small non-zero change on a branch to be used as guess.
int numberAnalyzeIterations() const
bool setAllowableGap(double value)
Set the allowable gap between the best known solution and the best possible solution.
void setMaximumCutPasses(int value)
Set the maximum number of cut passes at other nodes (default 10) Minimum drop can also be used for fi...
void setMinimumDrop(double value)
Set the minimum drop to continue cuts.
int getIntParam(CbcIntParam key) const
Get an integer parameter.
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
double getInfeasibilityWeight() const
Get the weight per integer infeasibility .
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
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)
OsiBranchingInformation usefulInformation() const
Generate an OsiBranchingInformation object.
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.
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
void setMultipleRootTries(int value)
Set multiple root tries.
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.
int numberExtraIterations() const
Number of extra iterations.
void AddIntegers()
Add additional integers.
int maximumSavedSolutions() const
Maximum number of extra saved solutions.
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
CbcStrategy * strategy() const
Get the current strategy.
int getMaximumSolutions() const
Get the maximum number of solutions desired.
void setContinuousInfeasibilities(int value)
int reducedCostFix()
Perform reduced cost fixing.
bool setMaximumSeconds(double value)
Set the maximum number of seconds desired.
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.
void setTypePresolve(int value)
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
void setMIPStart(const std::vector< std::pair< std::string, double > > &Mips)
double getMaximumSeconds() const
Get the maximum number of seconds desired.
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
bool setHeuristicGap(double value)
Set the heuristic gap between the best known solution and the best possible solution.
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...
The maximum amount the value of an integer variable can vary from integer and still be considered fea...
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...
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.
bool waitingForMiniBranchAndBound() const
Says if model is sitting there waiting for mini branch and bound to finish This is because an event h...
double getDblParam(CbcDblParam key) const
Get a double parameter.
OsiObject * modifiableObject(int which) const
Get the specified object.
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
void setPreferredWay(int value)
Set global preferred way to branch -1 down, +1 up, 0 no preference.
double getBestPossibleObjValue() const
Get best possible objective function value.
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
void gutsOfDestructor()
Clears out as much as possible (except solver)
const int * strongInfo() const
Return strong info.
Simple Branch and bound class.
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.
void * temporaryPointer() const
Get useful temporary pointer.
void findIntegers(bool startAgain, int type=0)
Identify integer variables and create corresponding objects.
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
void setStopNumberIterations(int value)
Set number of "iterations" to stop after.
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...
CbcFeasibilityBase * problemFeasibility() const
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.
void setNextRowCut(const OsiRowCut &cut)
Copy and set a pointer to a row cut which will be added instead of normal branching.
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
void originalModel(CbcModel *presolvedModel, bool weak)
Put back information into the original model after integer presolve.
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...
void passInSubTreeModel(CbcModel &model)
For passing in an CbcModel to do a sub Tree (with derived tree handlers).
bool isInitialSolveProvenDualInfeasible() const
Is dual infeasiblity proven (for initialSolve) ?
virtual ~CbcModel()
Destructor.
A class to encapsulate thread stuff.
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
const int * hotstartPriorities() const
Get the hotstart priorities.
void adjustHeuristics()
Adjust heuristics based on model.
double sumChangeObjective() const
Sum of Changes to objective by first solve.
const int * integerVariable() const
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)
int getFathomCount() const
Get how many times complete fathoming B&B was done.