Go to the documentation of this file.
10 #include "CoinMessageHandler.hpp"
11 #include "OsiSolverInterface.hpp"
12 #include "OsiBranchingObject.hpp"
13 #include "OsiCuts.hpp"
14 #include "CoinWarmStartBasis.hpp"
19 #include "ClpDualRowPivot.hpp"
25 class OsiRowCutDebugger;
26 class CglCutGenerator;
29 class CglTreeProbingInfo;
41 class OsiClpSolverInterface;
226 bool solveWithCuts(OsiCuts &cuts,
int numberTries,
CbcNode *node);
234 int serialCuts(OsiCuts &cuts,
CbcNode *node, OsiCuts &slackCuts,
int lastNumberCuts);
250 int &numberNodesOutput,
int &
status);
252 void resizeWhichGenerator(
int numberNow,
int numberAfter);
255 #ifdef CBC_KEEP_DEPRECATED
261 CbcModel *cleanModel(
const double *lower,
const double *upper);
278 int subBranchAndBound(
CbcModel *model2,
296 int subBranchAndBound(
const double *lower,
const double *upper,
305 OsiSolverInterface *strengthenedModel();
315 CglPreProcess *
preProcess(
int makeEquality = 0,
int numberPasses = 5,
319 void postProcess(CglPreProcess *process);
357 double *saveLower = NULL,
358 double *saveUpper = NULL);
376 return whichGenerator_;
395 int lessThanThis,
int defaultValue = 1000);
436 bool tightenVubs(
int type,
bool allowMultipleBinary =
false,
437 double useCutoff = 1.0e50);
445 double useCutoff = 1.0e50);
463 void saveModel(OsiSolverInterface *saveSolver,
double *checkCutoffForRestart,
bool *feasible);
495 return numberObjects_;
500 numberObjects_ = number;
510 const inline OsiObject *
object(
int which)
const
512 return object_[which];
517 return object_[which];
556 #ifdef SWITCH_VARIABLES
560 int fixAssociated(OsiSolverInterface *
solver,
int cleanBasis);
562 int checkAssociated(
const OsiSolverInterface *
solver,
563 const double *solution,
int printLevel);
581 intParam_[key] = value;
587 dblParam_[key] = value;
593 return intParam_[key];
598 return dblParam_[key];
809 minimumDrop_ = value;
821 maximumCutPassesAtRoot_ = value;
826 return maximumCutPassesAtRoot_;
833 maximumCutPasses_ = value;
838 return maximumCutPasses_;
844 return currentPassNumber_;
850 currentPassNumber_ = value;
864 return numberStrong_;
870 preferredWay_ = value;
875 return preferredWay_;
892 bool doCutsNow(
int allowForTopOfTree)
const;
904 return numberBeforeTrust_;
916 return numberPenalties_;
926 numberAnalyzeIterations_ = number;
930 return numberAnalyzeIterations_;
936 return penaltyScaleFactor_;
950 problemType_ = number;
959 return currentDepth_;
967 return howOftenGlobalScan_;
972 return originalColumns_;
976 int numberGood = COIN_INT_MAX);
989 printFrequency_ = number;
994 return printFrequency_;
1020 return numberIterations_;
1025 numberIterations_ += value;
1030 return numberNodes_;
1035 numberNodes_ += value;
1040 return numberExtraNodes_;
1045 return numberFathoms_;
1078 return secondaryStatus_;
1082 secondaryStatus_ = value;
1111 return numberRowsAtContinuous_;
1117 return solver_->getNumCols();
1123 return solver_->getNumRows();
1129 return solver_->getNumElements();
1135 return numberIntegers_;
1140 return integerVariable_;
1145 assert(integerInfo_);
1146 assert(integerInfo_[i] == 0 || integerInfo_[i] == 1);
1147 return integerInfo_[i];
1152 return integerInfo_;
1158 return solver_->getColLower();
1164 return solver_->getColUpper();
1178 return solver_->getRowSense();
1191 return solver_->getRightHandSide();
1204 return solver_->getRowRange();
1210 return solver_->getRowLower();
1216 return solver_->getRowUpper();
1222 return solver_->getObjCoefficients();
1235 return solver_->isContinuous(colIndex);
1241 return solver_->isBinary(colIndex);
1250 return solver_->isInteger(colIndex);
1256 return solver_->isIntegerNonBinary(colIndex);
1262 return solver_->isFreeBinary(colIndex);
1268 return solver_->getMatrixByRow();
1274 return solver_->getMatrixByCol();
1280 return solver_->getInfinity();
1285 return cbcColLower_;
1290 return cbcColUpper_;
1295 return cbcRowLower_;
1300 return cbcRowUpper_;
1305 return cbcColSolution_;
1310 return cbcRowPrice_;
1315 return cbcReducedCost_;
1320 return cbcRowActivity_;
1329 return continuousSolution_;
1337 return usedInSolution_;
1343 double &objectiveValue,
const double *solution,
1344 int fixVariables = 0);
1350 const double *solution);
1359 virtual double checkSolution(
double cutoff,
double *solution,
1360 int fixVariables,
double originalObjValue);
1368 int &numberObjectInfeasibilities)
const;
1377 return currentSolution_;
1384 return testSolution_;
1388 testSolution_ = solution;
1396 return solver_->getColSolution();
1402 return solver_->getRowPrice();
1408 return solver_->getReducedCost();
1414 return solver_->getRowActivity();
1431 return bestObjective_;
1436 bestObjective_ = value;
1442 return bestObjective_ * solver_->getObjSense();
1453 bestObjective_ = value * solver_->getObjSense();
1458 return solver_->getObjValue() * solver_->getObjSense();
1469 return bestSolution_;
1478 double objectiveValue,
bool check =
false);
1483 return numberSolutions_;
1489 numberSolutions_ = value;
1496 return maximumSavedSolutions_;
1523 return numberHeuristicSolutions_;
1528 numberHeuristicSolutions_ = value;
1535 solver_->setObjSense(s);
1541 return originalContinuousObjective_;
1545 originalContinuousObjective_ = value;
1550 return continuousInfeasibilities_;
1554 continuousInfeasibilities_ = value;
1559 return continuousObjective_;
1564 return sumChangeObjective1_;
1570 return numberGlobalViolations_;
1574 numberGlobalViolations_ = 0;
1579 return resolveAfterTakeOffCuts_;
1583 resolveAfterTakeOffCuts_ = yesNo;
1588 return maximumRows_;
1593 return workingBasis_;
1598 return stopNumberIterations_;
1603 stopNumberIterations_ = value;
1608 return heuristicModel_;
1613 heuristicModel_ = model;
1622 return nodeCompare_;
1633 return problemFeasibility_;
1660 return numberStoppedSubTrees_;
1665 numberStoppedSubTrees_++;
1692 return branchingMethod_;
1697 delete branchingMethod_;
1698 branchingMethod_ = method->
clone();
1706 delete branchingMethod_;
1707 branchingMethod_ = method.
clone();
1712 return cutModifier_;
1734 return stateOfSearch_;
1738 stateOfSearch_ = state;
1743 return searchStrategy_;
1748 searchStrategy_ = value;
1753 return strongStrategy_;
1758 strongStrategy_ = value;
1764 return numberCutGenerators_;
1774 return generator_[i];
1779 return virginGenerator_[i];
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);
1816 return parentModel_;
1836 return heuristic_[i];
1841 return numberHeuristics_;
1846 numberHeuristics_ = value;
1851 return lastHeuristic_;
1856 lastHeuristic_ = last;
1882 return object_[sequence]->priority();
1894 return (eventHandler_);
1928 return solverCharacteristics_;
1939 void newLanguage(CoinMessages::Language language);
1964 return handler_->logLevel();
1973 defaultHandler_ = yesNo;
1978 return defaultHandler_;
2016 specialOptions_ = value;
2021 return specialOptions_;
2026 randomSeed_ = value;
2036 multipleRootTries_ = value;
2041 return multipleRootTries_;
2046 eventHappened_ =
true;
2051 return (specialOptions_ & 16) == 0;
2059 return (specialOptions_ & 1048576) != 0;
2086 moreSpecialOptions_ = value;
2091 return moreSpecialOptions_;
2110 moreSpecialOptions2_ = value;
2115 return moreSpecialOptions2_;
2120 cutoffRowNumber_ = (yesNo) ? -2 : -1;
2126 moreSpecialOptions_ |= 131072;
2128 moreSpecialOptions_ &= ~131072;
2133 return (moreSpecialOptions_ & 131072) != 0;
2138 return temporaryPointer_;
2143 temporaryPointer_ = pointer;
2146 void goToDantzig(
int numberNodes, ClpDualRowPivot *&savePivotMethod);
2163 CbcModel(
const OsiSolverInterface &);
2188 ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000));
2198 return ((ownership_ & 0x80000000) != 0);
2224 OsiSolverInterface *returnSolver = solver_;
2226 return returnSolver;
2232 return continuousSolver_;
2238 continuousSolver_ = solver_->clone();
2243 delete continuousSolver_;
2244 continuousSolver_ = NULL;
2250 return referenceSolver_;
2288 return masterThread_;
2298 return numberThreads_;
2303 numberThreads_ = value;
2321 threadMode_ = value;
2331 if (!numberThreads_) {
2332 if ((threadMode_ & 1) == 0)
2338 if ((threadMode_ & 1) == 0)
2398 return numberNodes2_;
2421 int resolveClp(OsiClpSolverInterface *
solver,
int type);
2429 CbcNode *oldNode, OsiCuts &cuts,
2430 bool &resolved, CoinWarmStartBasis *lastws,
2431 const double *lowerBefore,
const double *upperBefore,
2432 OsiSolverBranch *&branches);
2441 CoinWarmStartBasis *
getEmptyBasis(
int ns = 0,
int na = 0)
const;
2455 bool allowResolve, OsiCuts *saveCuts,
2456 int numberNewCuts = 0,
const OsiRowCut **newCuts = NULL);
2493 double &lower,
double &upper,
int force);
2520 int *numberDown = NULL,
int *numberUp = NULL,
2521 int *numberDownInfeasible = NULL,
2522 int *numberUpInfeasible = NULL)
const;
2534 return hotstartSolution_;
2539 return hotstartPriorities_;
2550 return currentNumberCuts_;
2555 return &globalCuts_;
2567 return currentNode_;
2574 return probingInfo_;
2579 return &randomNumberGenerator_;
2584 numberStrongIterations_ = number;
2589 return numberStrongIterations_;
2594 return maximumNumberIterations_;
2599 maximumNumberIterations_ = value;
2605 return symmetryInfo_;
2613 fastNodeDepth_ = value;
2618 return fastNodeDepth_;
2623 return continuousPriority_;
2628 continuousPriority_ = value;
2632 numberExtraNodes_ += nodes;
2633 numberExtraIterations_ += iterations;
2634 numberFathoms_ += fathoms;
2639 numberExtraNodes_ = 0;
2640 numberExtraIterations_ = 0;
2646 return numberExtraIterations_;
2650 int numberFixed,
bool ifInfeasible);
2665 return storedRowCuts_;
2670 storedRowCuts_ = cuts;
2675 return ((ownership_ & 0x40000000) != 0);
2689 bestSolutionBasis_ = bestSolutionBasis;
2695 void setMIPStart(
const std::vector< std::pair< std::string, double > > &mipstart)
2697 this->mipStart_ = mipstart;
2704 this->keepNamesPreproc = _keep;
2709 return keepNamesPreproc;
2714 void setMIPStart(
int count,
const char **colNames,
const double colValues[]);
2719 return this->mipStart_;
2729 OsiSolverInterface *solver_;
2736 unsigned int ownership_;
2739 OsiSolverInterface *continuousSolver_;
2742 OsiSolverInterface *referenceSolver_;
2745 CoinMessageHandler *handler_;
2752 bool defaultHandler_;
2755 CoinMessages messages_;
2771 mutable CoinWarmStart *emptyWarmStart_;
2774 double bestObjective_;
2776 double bestPossibleObjective_;
2778 double sumChangeObjective1_;
2780 double sumChangeObjective2_;
2783 double *bestSolution_;
2785 double **savedSolutions_;
2791 double *currentSolution_;
2795 mutable const double *testSolution_;
2799 std::vector< std::pair< std::string, double > > mipStart_;
2805 bool keepNamesPreproc;
2813 CoinWarmStartBasis bestSolutionBasis_;
2820 double minimumDrop_;
2822 int numberSolutions_;
2824 int numberSavedSolutions_;
2826 int maximumSavedSolutions_;
2837 double *hotstartSolution_;
2839 int *hotstartPriorities_;
2841 int numberHeuristicSolutions_;
2849 int numberIterations_;
2864 int secondaryStatus_;
2866 int numberIntegers_;
2868 int numberRowsAtContinuous_;
2874 int cutoffRowNumber_;
2876 int maximumNumberCuts_;
2888 int currentNumberCuts_;
2902 CglPreProcess *preProcess_;
2904 const OsiRowCut **lastCut_;
2906 int lastNumberCuts2_;
2908 int *lastNumberCuts_;
2922 OsiRowCut *nextRowCut_;
2928 int *integerVariable_;
2932 double *continuousSolution_;
2934 int *usedInSolution_;
2962 int specialOptions_;
2977 int moreSpecialOptions_;
2991 int moreSpecialOptions2_;
3005 int numberStoppedSubTrees_;
3019 const double *cbcColLower_;
3022 const double *cbcColUpper_;
3024 const double *cbcRowLower_;
3026 const double *cbcRowUpper_;
3028 const double *cbcColSolution_;
3030 const double *cbcRowPrice_;
3032 const double *cbcReducedCost_;
3034 const double *cbcRowActivity_;
3048 int numberBeforeTrust_;
3052 int numberPenalties_;
3054 int stopNumberIterations_;
3057 double penaltyScaleFactor_;
3059 int numberAnalyzeIterations_;
3061 double *analyzeResults_;
3063 void *temporaryPointer_;
3065 int numberInfeasibleNodes_;
3074 int printFrequency_;
3076 int numberCutGenerators_;
3082 int numberHeuristics_;
3091 ClpEventHandler *eventHandler_;
3110 OsiObject **object_;
3115 int *originalColumns_;
3117 int howOftenGlobalScan_;
3120 int numberGlobalViolations_;
3122 int numberExtraIterations_;
3124 int numberExtraNodes_;
3130 double continuousObjective_;
3133 double originalContinuousObjective_;
3135 int continuousInfeasibilities_;
3137 int maximumCutPassesAtRoot_;
3139 int maximumCutPasses_;
3143 int currentPassNumber_;
3151 int multipleRootTries_;
3155 mutable CoinThreadRandom randomNumberGenerator_;
3157 CoinWarmStartBasis workingBasis_;
3159 int *whichGenerator_;
3161 int maximumStatistics_;
3165 int maximumDepthActual_;
3167 double numberDJFixed_;
3169 CglTreeProbingInfo *probingInfo_;
3171 int numberFixedAtRoot_;
3173 int numberFixedNow_;
3177 mutable bool eventHappened_;
3179 int numberLongStrong_;
3181 int numberOldActiveCuts_;
3185 int searchStrategy_;
3197 int strongStrategy_;
3199 int numberStrongIterations_;
3209 OsiBabSolver *solverCharacteristics_;
3211 bool resolveAfterTakeOffCuts_;
3213 int maximumNumberIterations_;
3215 int continuousPriority_;
3217 int numberUpdateItems_;
3219 int maximumNumberUpdateItems_;
3223 CglStored *storedRowCuts_;
3241 int numberGlobalCutsIn_;
3250 double &originalUpper);
3253 class OsiClpSolverInterface;
3254 int CbcMain(
int argc,
const char *argv[], OsiClpSolverInterface &solver,
CbcModel **babSolver);
3257 int callCbc(
const char *input2, OsiClpSolverInterface &solver1);
3258 int callCbc(
const char *input2);
3259 int callCbc(
const std::string input2, OsiClpSolverInterface &solver1);
3260 int callCbc(
const std::string input2);
void setMaximumSavedSolutions(int value)
Set maximum number of extra saved solutions.
void setObjValue(double value)
Set best objective function value.
@ CbcCurrentObjectiveValue
Current objective value.
void setParentModel(CbcModel &parentModel)
Set the parent model.
bool setPrintingMode(int value)
Set the printing mode.
void setStopNumberIterations(int value)
Set number of "iterations" to stop after.
@ CbcCurrentCutoff
Cutoff - stored for speed.
void addSOSEtcToSolver()
Add SOS info to solver - Overwrites SOS information in solver with information in CbcModel.
void setBestSolution(CBC_Message how, double &objectiveValue, const double *solution, int fixVariables=0)
Record a new incumbent solution and update objectiveValue.
const OsiSolverInterface * postProcessedSolver(int solutionType=1)
Returns postProcessed solution in solver(called from event handler) Normally used for integer solutio...
void moveInfo(const CbcModel &rhs)
Move status, nodes etc etc across.
const double * getCbcColLower() const
Get pointer to array[getNumCols()] (for speed) of column lower bounds.
void setNextRowCut(const OsiRowCut &cut)
Copy and set a pointer to a row cut which will be added instead of normal branching.
bool maximumSecondsReached() const
Return true if maximum time reached.
void setNumberBeforeTrust(int number)
Set the number of branches before pseudo costs believed in dynamic strong branching.
int * usedInSolution() const
Array marked whenever a solution is found if non-zero.
const double * hotstartSolution() const
Get the hotstart solution.
void setProblemType(int number)
Problem type as set by user or found by analysis.
double getAllowablePercentageGap() const
Get the percentage allowable gap between the best known solution and the best possible solution.
void flipModel()
Flip direction of optimization on all models.
int reducedCostFix()
Perform reduced cost fixing.
int numberAnalyzeIterations() const
int getNodeCount() const
Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP...
int getSolutionCount() const
Get number of solutions.
OsiSolverInterface * continuousSolver() const
Returns solver with continuous state.
double getMinimumDrop() const
Get the minimum drop to continue cuts.
bool canStopOnGap() const
See if can stop on gap.
int stateOfSearch() const
State of search 0 - no solution 1 - only heuristic solutions 2 - branched to a solution 3 - no soluti...
void setMultipleRootTries(int value)
Set multiple root tries.
@ CbcInfeasibilityWeight
The objective is assumed to worsen by this amount for each integer infeasibility.
bool isInitialSolveProvenDualInfeasible() const
Is dual infeasiblity proven (for initialSolve) ?
void generateCpp(FILE *fp, int options)
Create C++ lines to get to current state.
void setNodeComparison(CbcCompareBase *compare)
int getPreferredWay() const
Get the preferred way to branch (default 0)
int printFrequency() const
Get the print frequency.
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.
int numberCutGenerators() const
Get the number of cut generators.
void setNumberPenalties(int number)
Set the number of variables for which to compute penalties in dynamic strong branching.
double * continuousSolution() const
Holds solution at continuous (after cuts if branchAndBound called)
OsiRowCut augmented with bookkeeping.
@ CbcSumChange
Sum of non-zero changes on a branch.
const double * savedSolution(int which) const
Return a saved solution (0==best) - NULL if off end.
static bool haveMultiThreadSupport()
Indicates whether Cbc library has been compiled with multithreading support.
CbcCountRowCut ** addedCuts() const
Return the list of cuts initially collected for this subproblem.
double rootObjectiveAfterCuts() const
Value of objective after root node cuts added.
void setOptionalInteger(int index)
void checkModel()
Check original model before it gets messed up.
bool setIntegerTolerance(double value)
Set the integrality tolerance .
const double * getRightHandSide() const
Get pointer to array[getNumRows()] of rows right-hand sides.
int numberIntegers() const
Number of integers in problem.
bool setMaximumNodes(int value)
Set the maximum node limit .
double getCurrentObjValue() const
Get current objective function value.
bool addCuts1(CbcNode *node, CoinWarmStartBasis *&lastws)
Traverse the tree from node to root and prep the model.
void zapIntegerInformation(bool leaveObjects=true)
Zap integer information in problem (may leave object info)
const int * integerVariable() const
OsiBranchingInformation usefulInformation() const
Generate an OsiBranchingInformation object.
int getNodeCount2() const
Get how many Nodes it took to solve the problem.
CoinBigIndex getNumElements() const
Get number of nonzero elements.
int getMaximumSolutions() const
Get the maximum number of solutions desired.
bool isProvenOptimal() const
Is optimality proven?
void setObjSense(double s)
Set objective function sense (1 for min (default), -1 for max,)
double getCurrentSeconds() const
Current time since start of branchAndbound.
void * temporaryPointer() const
Get useful temporary pointer.
bool isLocked() const
From here to end of section - code in CbcThread.cpp until class changed Returns true if locked.
int currentDepth() const
Current depth.
void setModelOwnsSolver(bool ourSolver)
Set ownership of solver.
bool setAllowableGap(double value)
Set the allowable gap between the best known solution and the best possible solution.
@ CbcPrinting
Adjusts printout 1 does different node message with number unsatisfied on last branch.
void setSolutionCount(int value)
Set number of solutions (so heuristics will be different)
void resetToReferenceSolver()
Uses a copy of reference solver to be current solver.
int makeGlobalCut(const OsiRowCut *cut)
Make given cut into a global cut.
void setPenaltyScaleFactor(double value)
Set scale factor to make penalties match strong.
void setMoreSpecialOptions2(int value)
Set more more special options 0 bit (1) - find switching variables 1 bit (2) - using fake objective u...
void startSplitModel(int numberIterations)
Start threads.
void setTestSolution(const double *solution)
CoinMessages * messagesPointer()
Return pointer to messages.
int moreSpecialOptions2() const
Get more special options2.
const double * getCbcRowActivity() const
Get pointer to array[getNumRows()] (for speed) of row activity levels.
double getObjValue() const
Get best objective function value.
int takeOffCuts(OsiCuts &cuts, bool allowResolve, OsiCuts *saveCuts, int numberNewCuts=0, const OsiRowCut **newCuts=NULL)
Remove inactive cuts from the model.
void setCurrentPassNumber(int value)
Set current cut pass number in this round of cuts.
bool allDynamic() const
Says whether all dynamic integers.
void setProblemStatus(int value)
const int * strongInfo() const
Return strong info.
void setCutoff(double value)
Set cutoff bound on the objective function.
void createContinuousSolver()
Create solver with continuous state.
void gutsOfDestructor()
Clears out as much as possible (except solver)
const char * getRowSense() const
Get pointer to array[getNumRows()] of row constraint senses.
CbcModel()
Default Constructor.
Abstract cut modifier base class.
CglStored * storedRowCuts() const
Get stored row cuts for donor/recipient CbcModel.
void addUpdateInformation(const CbcObjectUpdateData &data)
Adds an update information object.
double getCutoffIncrement() const
Get the CbcModel::CbcCutoffIncrement desired.
OsiObject * modifiableObject(int which) const
Get the specified object.
bool setInfeasibilityWeight(double value)
Set the weight per integer infeasibility .
const double * getColSolution() const
Get pointer to array[getNumCols()] of primal solution vector.
@ CbcAllowableFractionGap
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
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.
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.
void setObjectiveValue(CbcNode *thisNode, const CbcNode *parentNode) const
Set objective value in a node.
void passInSolverCharacteristics(OsiBabSolver *solverCharacteristics)
For advanced applications you may wish to modify the behavior of Cbc e.g.
void makePartialCut(const OsiRowCut *cut, const OsiSolverInterface *solver=NULL)
Make partial cut into a global cut and save.
void originalModel(CbcModel *presolvedModel, bool weak)
Put back information into the original model after integer presolve.
void setOriginalColumns(const int *originalColumns, int numberGood=COIN_INT_MAX)
Set original columns as created by preprocessing.
bool isAbandoned() const
Are there a numerical difficulties?
void resetModel()
Clears out enough to reset CbcModel cutoff etc.
CbcFeasibilityBase * problemFeasibility() const
void goToDantzig(int numberNodes, ClpDualRowPivot *&savePivotMethod)
Go to dantzig pivot selection if easy problem (clp only)
bool useElapsedTime() const
Get time method.
const double * getCbcRowUpper() const
Get pointer to array[getNumRows()] (for speed) of row upper bounds.
void setContinuousObjective(double value)
@ CbcCurrentMinimizationObjectiveValue
Current minimization objective value.
const std::vector< std::pair< std::string, double > > & getMIPStart()
int getStopNumberIterations() const
Get number of "iterations" to stop after.
void moveToModel(CbcModel *baseModel, int mode)
Move/copy information from one model to another -1 - initialization 0 - from base model 1 - to base m...
CbcRowCuts * globalCuts()
Global cuts.
const double * getCbcColUpper() const
Get pointer to array[getNumCols()] (for speed) of column upper bounds.
bool setDblParam(CbcDblParam key, double value)
Set a double parameter.
void setResolveAfterTakeOffCuts(bool yesNo)
CbcCompareBase * nodeComparison() const
int callCbc(const char *input2, OsiClpSolverInterface &solver1)
void setKeepNamesPreproc(bool _keep)
if original column names will be preserved in preprocessed problem
double getSolverObjValue() const
Get solver objective function value (as minimization)
@ CbcLastDblParam
Just a marker, so that a static sized array can store parameters.
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 incrementIterationCount(int value)
Increment how many iterations it took to solve the problem.
double getMinimizationObjValue() const
Get best objective function value as minimization.
void setTypePresolve(int value)
double sumChangeObjective() const
Sum of Changes to objective by first solve.
Class to deal with symmetry.
void zapGlobalCuts()
Get rid of global cuts.
void setPointers(const OsiSolverInterface *solver)
Set pointers for speed.
void deleteSavedSolution(int which)
Delete a saved solution and move others up.
CglPreProcess * preProcess() const
Returns CglPreProcess used before branch and bound.
CbcNodeInfo ** walkback() const
Get pointer to walkback.
CbcHeuristic * lastHeuristic() const
Pointer to heuristic solver which found last solution (or NULL)
CbcStrategy * strategy() const
Get the current strategy.
int getRandomSeed() const
Get random seed.
int numberExtraIterations() const
Number of extra iterations.
void passInMessageHandler(CoinMessageHandler *handler)
Pass in Message handler (not deleted at end)
int getIterationCount() const
Get how many iterations it took to solve the problem.
int getExtraNodeCount() const
Get how many Nodes were enumerated in complete fathoming B&B inside CLP.
void saveSolution(const OsiSolverInterface *osi, std::string fileName)
bool isIntegerNonBinary(int colIndex) const
Return true if variable is general integer.
OsiSolverInterface * swapSolver(OsiSolverInterface *solver)
Returns current solver - sets new one.
void incrementStrongInfo(int numberTimes, int numberIterations, int numberFixed, bool ifInfeasible)
Increment strong info.
bool integerPresolveThisModel(OsiSolverInterface *originalSolver, bool weak=false)
Do integer presolve, modifying the current model.
const int * hotstartPriorities() const
Get the hotstart priorities.
int getContinuousInfeasibilities() const
Number of infeasibilities at continuous.
double getHeuristicGap() const
Get the heuristic gap between the best known solution and the best possible solution.
bool isNodeLimitReached() const
Node limit reached?
int getCurrentPassNumber() const
Get current cut pass number in this round of cuts.
bool isInitialSolveProvenPrimalInfeasible() const
Is primal infeasiblity proven (for initialSolve) ?
CbcCutGenerator * virginCutGenerator(int i) const
Get the specified cut generator before any changes.
double getObjSense() const
Get objective function sense (1 for min (default), -1 for max)
int status() const
Final status of problem Some of these can be found out by is......
const double * getRowActivity() const
Get pointer to array[getNumRows()] of row activity levels.
int phase() const
Current phase (so heuristics etc etc can find out).
int continuousPriority() const
Get anything with priority >= this can be treated as continuous.
OsiSolverInterface * solver() const
Returns solver - has current state.
bool isContinuous(int colIndex) const
Return true if variable is continuous.
int typePresolve() const
Whether to automatically do presolve before branch and bound (subTrees).
const double * getColUpper() const
Get pointer to array[getNumCols()] of column upper bounds.
double getBestPossibleObjValue() const
Get best possible objective function value.
void setNumberHeuristics(int value)
Set the number of heuristics.
CbcCutGenerator * cutGenerator(int i) const
Get the specified cut generator.
int numberRowsAtContinuous() const
Number of rows in continuous (root) problem.
bool setIntParam(CbcIntParam key, int value)
Set an integer parameter.
int CbcMain(int argc, const char *argv[], OsiClpSolverInterface &solver, CbcModel **babSolver)
void deleteNode(CbcNode *node)
Delete a node and possibly null out currentNode_.
OsiObject ** objects() const
Get the array of objects.
bool normalSolver() const
Says if normal solver i.e. has well defined CoinPackedMatrix.
void setMinimumDrop(double value)
Set the minimum drop to continue cuts.
void convertToDynamic()
If numberBeforeTrust >0 then we are going to use CbcBranchDynamic.
void adjustHeuristics()
Adjust heuristics based on model.
bool isContinuousUnbounded() const
Was continuous solution unbounded.
const double * getColLower() const
Get pointer to array[getNumCols()] of column lower bounds.
CbcCutGenerator ** cutGenerators() const
Get the list of cut generators.
void redoWalkBack()
Redo walkback arrays.
void incrementUsed(const double *solution)
Increases usedInSolution for nonzeros.
bool ownObjects() const
Now we may not own objects - just point to solver's objects.
void synchronizeNumberBeforeTrust(int type=0)
Set numberBeforeTrust in all objects.
bool setCutoffIncrement(double value)
Set the CbcModel::CbcCutoffIncrement desired.
int callCbc1(const char *input2, CbcModel &babSolver)
int splitModel(int numberModels, CbcModel **model, int numberNodes)
Split up nodes.
double getDblParam(CbcDblParam key) const
Get a double parameter.
const CoinPackedMatrix * getMatrixByRow() const
Get pointer to row-wise copy of matrix.
bool defaultHandler() const
Check default handler.
const double * getCbcRowLower() const
Get pointer to array[getNumRows()] (for speed) of row lower bounds.
void setApplicationData(void *appData)
Set application data.
Simple Branch and bound class.
@ CbcMaxNumSol
The maximum number of solutions before terminating.
void setCutoffAsConstraint(bool yesNo)
Set cutoff as constraint.
int moreSpecialOptions() const
Get more special options.
void setCutModifier(CbcCutModifier *modifier)
Set the cut modifier method.
void clearContinuousSolver()
Clear solver with continuous state.
int * mutableStrongInfo()
Return mutable strong info.
void setSearchStrategy(int value)
Set strategy worked out - mainly at root node for use by CbcNode.
int numberStoppedSubTrees() const
Returns number of times any subtree stopped on nodes, time etc.
void setLogLevel(int value)
Set log level.
const double * getObjCoefficients() const
Get pointer to array[getNumCols()] of objective function coefficients.
CBC_Message
This deals with Cbc messages (as against Clp messages etc).
void assignSolver(OsiSolverInterface *&solver, bool deleteSolver=true)
Assign a solver to the model (model assumes ownership)
void clearNumberGlobalViolations()
bool isFreeBinary(int colIndex) const
Return true if variable is binary and not fixed at either bound.
void incrementExtra(int nodes, int iterations, int fathoms=1)
void incrementNodeCount(int value)
Increment how many nodes it took to solve the problem.
CbcEventHandler * getEventHandler() const
Retrieve a pointer to the event handler.
int getNumRows() const
Get number of rows.
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.
void passInSubTreeModel(CbcModel &model)
For passing in an CbcModel to do a sub Tree (with derived tree handlers).
int priority(int sequence) const
Returns priority level for an object (or 1000 if no priorities exist)
void setHowOftenGlobalScan(int number)
Set how often to scan global cuts.
void saveReferenceSolver()
Save a copy of the current solver so can be reset to.
CglTreeProbingInfo * probingInfo() const
Get a pointer to probing info.
@ CbcFathomDiscipline
Fathoming discipline.
const char * integerType() const
Whether or not integer.
void passInEventHandler(const CbcEventHandler *eventHandler)
Set an event handler.
@ CbcMaximumSeconds
The maximum number of seconds before terminating.
CbcModel * parentModel() const
Get the current parent model.
const double * getRowLower() const
Get pointer to array[getNumRows()] of row lower bounds.
@ CbcOptimizationDirection
Optimization direction - stored for speed.
@ CbcLastIntParam
Just a marker, so that a static sized array can store parameters.
void setTemporaryPointer(void *pointer)
Set useful temporary pointer.
CbcModel * subTreeModel(OsiSolverInterface *solver=NULL) const
For retrieving a copy of subtree model with given OsiSolver.
void deleteObjects(bool findIntegers=true)
Delete all object information (and just back to integers if true)
int parallelMode() const
Return -2 if deterministic threaded and main thread -1 if deterministic threaded and serial thread 0 ...
@ CbcCutoffIncrement
The amount by which to tighten the objective function cutoff when a new solution is discovered.
Using MS heap implementation.
bool setHeuristicGap(double value)
Set the heuristic gap between the best known solution and the best possible solution.
virtual CbcModel * clone(bool cloneHandler)
Clone.
bool setMaximumSeconds(double value)
Set the maximum number of seconds desired.
void setNumberHeuristicSolutions(int value)
Set number of heuristic solutions.
int maximumNumberIterations() const
Get maximum number of iterations (designed to be used in heuristics)
void getIntegerInformation(const OsiObject *object, double &originalLower, double &originalUpper)
So we can use osiObject or CbcObject during transition.
int specialOptions() const
Get special options.
void setHeuristicModel(CbcModel *model)
Set a pointer to model from CbcHeuristic.
int getMaximumCutPasses() const
Get the maximum number of cut passes at other nodes (default 10)
void setMIPStart(const std::vector< std::pair< std::string, double > > &mipstart)
void setMaximumCutPasses(int value)
Set the maximum number of cut passes at other nodes (default 10) Minimum drop can also be used for fi...
const double * getRowUpper() const
Get pointer to array[getNumRows()] of row upper bounds.
void setFastNodeDepth(int value)
Set depth for fast nodes.
void setPrintFrequency(int number)
Set the print frequency.
void setProblemFeasibility(CbcFeasibilityBase *feasibility)
bool isInteger(int colIndex) const
Return true if column is integer.
void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0)
Do heuristics at root.
const CoinPackedMatrix * getMatrixByCol() const
Get pointer to column-wise copy of matrix.
int fastNodeDepth() const
Get depth for fast nodes.
void newLanguage(CoinMessages::Language language)
Set language.
const double * getCbcReducedCost() const
Get a pointer to array[getNumCols()] (for speed) of reduced costs.
int * originalColumns() const
Original columns as created by integerPresolve or preprocessing.
const OsiBabSolver * solverCharacteristics() const
Get solver characteristics.
void reserveCurrentSolution(const double *solution=NULL)
Make sure region there and optionally copy solution.
void saveExtraSolution(const double *solution, double objectiveValue)
Save a solution to saved list.
bool setAllowablePercentageGap(double value)
Set the percentage allowable gap between the best known solution and the best possible solution.
@ CbcHeuristicFractionGap
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
Information required to recreate the subproblem at this node.
Base class for Cbc event handling.
void incrementSubTreeStopped()
Says a sub tree was stopped.
void passInTreeHandler(CbcTree &tree)
For modifying tree handling (original is cloned)
void setMinimizationObjValue(double value)
Set best objective function value as minimization.
void * getApplicationData() const
Get application data.
double getHeuristicFractionGap() const
Get the fraction heuristic gap between the best known solution and the best possible solution.
CbcModel & operator=(const CbcModel &rhs)
Assignment operator.
double * bestSolution() const
The best solution to the integer programming problem.
char integerType(int i) const
Whether or not integer.
double getAllowableFractionGap() const
Get the fraction allowable gap between the best known solution and the best possible solution.
void setNumberObjects(int number)
Set the number of objects.
double getInfeasibilityWeight() const
Get the weight per integer infeasibility .
CoinMessages & messages()
Return messages.
bool setAllowableFractionGap(double value)
Set the fraction allowable gap between the best known solution and the best possible solution.
void setRandomSeed(int value)
Set random seed.
void saveModel(OsiSolverInterface *saveSolver, double *checkCutoffForRestart, bool *feasible)
Save copy of the model.
int howOftenGlobalScan() const
Get how often to scan global cuts.
CbcAction
Action codes returned by the event handler.
int getMaximumNodes() const
Get the maximum node limit .
bool feasibleSolution(int &numberIntegerInfeasibilities, int &numberObjectInfeasibilities) const
Test the current solution for feasiblility.
double getContinuousObjective() const
Value of objective at continuous.
double getCutoff() const
Get the cutoff bound on the objective function - always as minimize.
bool isBinary(int colIndex) const
Return true if variable is binary.
void sayEventHappened()
Tell model to stop on event.
void gutsOfDestructor2()
Clears out enough to reset CbcModel as if no branch and bound done.
int getMultipleRootTries() const
Get multiple root tries.
bool isSecondsLimitReached() const
Time limit reached?
int getNumCols() const
Get number of columns.
int numberGlobalViolations() const
Number of times global cuts violated.
CoinWarmStartBasis & workingBasis()
Work basis for temporary use.
void setSecondaryStatus(int value)
void setContinuousInfeasibilities(int value)
void setPreferredWay(int value)
Set global preferred way to branch -1 down, +1 up, 0 no preference.
void setStoredRowCuts(CglStored *cuts)
Set stored row cuts for donor/recipient CbcModel.
bool isInitialSolveProvenOptimal() const
Is optimality proven (for initialSolve) ?
CbcThread * masterThread() const
Get pointer to masterthread.
const double * getRowRange() const
Get pointer to array[getNumRows()] of row ranges.
virtual CbcBranchDecision * clone() const =0
Clone.
void synchronizeHandlers(int makeDefault)
Makes all handlers same.
void setNumberThreads(int value)
Set number of threads.
@ CbcHeuristicGap
Stop doing heuristics when the gap between the objective value of the best known solution and the bes...
int maximumSavedSolutions() const
Maximum number of extra saved solutions.
void fillPseudoCosts(double *downCosts, double *upCosts, int *priority=NULL, int *numberDown=NULL, int *numberUp=NULL, int *numberDownInfeasible=NULL, int *numberUpInfeasible=NULL) const
Return pseudo costs If not all integers or not pseudo costs - returns all zero Length of arrays are n...
void setMaximumNumberIterations(int value)
Set maximum number of iterations (designed to be used in heuristics)
void setStrongStrategy(int value)
Set strong branching strategy.
int getMaximumCutPassesAtRoot() const
Get the maximum number of cut passes at root node.
int getThreadMode() const
Get thread mode.
void setNumberAnalyzeIterations(int number)
Number of analyze iterations to do.
CbcNode * currentNode() const
Get a pointer to current node (be careful)
int getNumberHeuristicSolutions() const
Get number of heuristic solutions.
void setWhenCuts(int value)
Set at which depths to do cuts.
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 addHeuristic(CbcHeuristic *generator, const char *name=NULL, int before=-1)
Add one heuristic - up to user to delete.
OsiRowCut * conflictCut(const OsiSolverInterface *solver, bool &localCuts)
Create conflict cut (well - most of)
Information required while the node is live.
void setDefaultHandler(bool yesNo)
Set flag to say if handler_ is the default handler.
For gathering statistics.
CbcCutModifier * cutModifier() const
Get the current cut modifier method.
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...
int numberStrong() const
Get the maximum number of candidates to be evaluated for strong branching.
bool waitingForMiniBranchAndBound() const
Says if model is sitting there waiting for mini branch and bound to finish This is because an event h...
int logLevel() const
Get log level.
int cliquePseudoCosts(int doStatistics)
Use cliques for pseudocost information - return nonzero if infeasible.
CbcModel * findCliques(bool makeEquality, int atLeastThisMany, int lessThanThis, int defaultValue=1000)
Identify cliques and construct corresponding objects.
void setInfoInChild(int type, CbcThread *info)
Set information in a child -3 pass pointer to child thread info -2 just stop -1 delete simple child s...
void setMaximumCutPassesAtRoot(int value)
Set the maximum number of cut passes at root node (default 20) Minimum drop can also be used for fine...
void setContinuousPriority(int value)
Set anything with priority >= this can be treated as continuous.
int getFathomCount() const
Get how many times complete fathoming B&B was done.
@ CbcStartSeconds
The time at start of model.
@ CbcAllowableGap
Stop when the gap between the objective value of the best known solution and the best bound on the ob...
void setNumberStrongIterations(int number)
Set the number of iterations done in strong branching.
const double * getRowPrice() const
Get pointer to array[getNumRows()] of dual prices.
int addCuts(CbcNode *node, CoinWarmStartBasis *&lastws)
Determine and install the active cuts that need to be added for the current subproblem.
virtual ~CbcModel()
Destructor.
void makeGlobalCuts()
Make partial cuts into global cuts.
CbcBranchDecision * branchingMethod() const
Get the current branching decision method.
CbcModel * heuristicModel() const
A pointer to model from CbcHeuristic.
double * currentSolution() const
Solution to the most recent lp relaxation.
bool resolveAfterTakeOffCuts() const
Whether to force a resolve after takeOffCuts.
CbcTree * tree() const
Tree method e.g. heap (which may be overridden by inheritance)
CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, double objValue, const double *solution)
Deals with event handler and solution.
void setStrategy(CbcStrategy *strategy)
Set the strategy. assigns.
@ CbcSmallestChange
Smallest non-zero change on a branch.
OsiSolverInterface * referenceSolver() const
A copy of the solver, taken at constructor or by saveReferenceSolver.
int numberObjects() const
Get the number of objects.
int numberSavedSolutions() const
Number of saved solutions (including best)
void pseudoShadow(int type)
Fill in useful estimates.
void CbcMain0(CbcModel &babSolver)
CbcEvent
Events known to cbc.
Information required to recreate the subproblem at this node.
CoinWarmStartBasis * getEmptyBasis(int ns=0, int na=0) const
Return an empty basis object of the specified size.
CbcHeuristic * heuristic(int i) const
Get the specified heuristic.
bool isInitialSolveAbandoned() const
Are there numerical difficulties (for initialSolve) ?
void setNumberStrong(int number)
Set the maximum number of candidates to be evaluated for strong branching.
Interface between Cbc and Cut Generation Library.
void setLanguage(CoinMessages::Language language)
int whenCuts() const
Get at which depths to do cuts.
CbcModel * integerPresolve(bool weak=false)
Do integer presolve, creating a new (presolved) model.
CbcBaseModel * master() const
Thread stuff for master.
@ CbcSmallChange
Small non-zero change on a branch to be used as guess.
void setBestObjectiveValue(double objectiveValue)
Just update objectiveValue.
double getInfinity() const
Get solver's value for infinity.
void setBranchingMethod(CbcBranchDecision *method)
Set the branching decision method.
int cleanBounds(OsiSolverInterface *solver, char *cleanVariables)
Clean model i.e.
int getPrintingMode() const
Get the printing mode.
void branchAndBound(int doStatistics=0)
Invoke the branch & cut algorithm.
void setSpecialOptions(int value)
Set special options 0 bit (1) - check if cuts valid (if on debugger list) 1 bit (2) - use current bas...
const int * whichGenerator() const
Which cut generator generated this cut.
CoinMessageHandler * messageHandler() const
Return handler.
void setBestSolutionBasis(const CoinWarmStartBasis &bestSolutionBasis)
Warm start object produced by heuristic or strong branching.
bool setMaximumSolutions(int value)
Set the maximum number of solutions desired.
void deleteSolutions()
Delete best and saved solutions.
int getIntParam(CbcIntParam key) const
Get an integer parameter.
bool modelOwnsSolver()
Get ownership of solver.
char * setupCleanVariables()
Sets up cleanVariables array (i.e. ones to be careful about)
bool isSolutionLimitReached() const
Solution limit reached?
double savedSolutionObjective(int which) const
Return a saved solution objective (0==best) - COIN_DBL_MAX if off end.
void setThreadMode(int value)
Set thread mode always use numberThreads for branching 1 set then deterministic 2 set then use number...
const double * testSolution() const
For testing infeasibilities - will point to currentSolution_ or solver-->getColSolution()
double getMaximumSeconds() const
Get the maximum number of seconds desired.
const double * getReducedCost() const
Get a pointer to array[getNumCols()] of reduced costs.
void synchronizeModel()
Ensure attached objects point to this model.
void setUseElapsedTime(bool yesNo)
Set time method.
int numberPenalties() const
get the number of variables for which to compute penalties in dynamic strong branching.
void AddIntegers()
Add additional integers.
void setCutAndHeuristicOptions(CbcModel &model)
bool getKeepNamesPreproc() const
int maximumRows() const
Maximum number of rows.
void mergeModels(int numberModel, CbcModel **model, int numberNodes)
Merge models.
void setStrategy(CbcStrategy &strategy)
Set the strategy. Clones.
A class to encapsulate thread stuff.
int strongStrategy() const
Stong branching strategy.
@ CbcLargestChange
Largest non-zero change on a branch.
void setPreProcess(CglPreProcess *preProcess)
Set CglPreProcess used before branch and bound.
int numberStrongIterations() const
Get the number of iterations done in strong branching.
void setStateOfSearch(int state)
const OsiObject * object(int which) const
Get the specified object.
int resolve(CbcNodeInfo *parent, int whereFrom, double *saveSolution=NULL, double *saveLower=NULL, double *saveUpper=NULL)
Reoptimise an LP relaxation.
CoinThreadRandom * randomNumberGenerator()
Thread specific random number generator.
void setMoreSpecialOptions(int value)
Set more special options at present bottom 6 bits used for shadow price mode 1024 for experimental ho...
const CbcFullNodeInfo * topOfTree() const
Pointer to top of tree.
bool setHeuristicFractionGap(double value)
Set the fraction heuristic gap between the best known solution and the best possible solution.
void saveBestSolution(const double *solution, double objectiveValue)
Save a solution to best and move current to saved.
int secondaryStatus() const
Secondary status of problem -1 unset (status_ will also be -1) 0 search completed with solution 1 lin...
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 ...
const double * getCbcRowPrice() const
Get pointer to array[getNumRows()] (for speed) of dual prices.
@ CbcMaxNumNode
The maximum number of nodes before terminating.
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 setBranchingMethod(CbcBranchDecision &method)
Set the branching method.
int numberHeuristics() const
Get the number of heuristics.
bool isProvenDualInfeasible() const
Was continuous solution unbounded.
double penaltyScaleFactor() const
Get scale factor to make penalties match strong.
void initialSolve()
Solve the initial LP relaxation.
void analyzeObjective()
Analyze problem to find a minimum change in the objective function.
int getNumberThreads() const
Get number of threads.
const double * getCbcColSolution() const
Get pointer to array[getNumCols()] (for speed) of primal solution vector.
@ CbcIntegerTolerance
The maximum amount the value of an integer variable can vary from integer and still be considered fea...
int CbcMain1(int argc, const char *argv[], CbcModel &babSolver)
int searchStrategy() const
Strategy worked out - mainly at root node for use by CbcNode.
@ CbcNumberBranches
Number of branches (may be more than number of nodes as may include strong branching)
void setLastHeuristic(CbcHeuristic *last)
set last heuristic which found a solution
double getIntegerTolerance() const
Get the integrality tolerance .
void setHotstartSolution(const double *solution, const int *priorities=NULL)
Pass in target solution and optional priorities.
double getAllowableGap() const
Get the allowable gap between the best known solution and the best possible solution.
void addObjects(int numberObjects, OsiObject **objects)
Add in object information.
int currentNumberCuts() const
Number of entries in the list returned by addedCuts()
bool isProvenInfeasible() const
Is infeasiblity proven (or none better than cutoff)?
void findIntegers(bool startAgain, int type=0)
Identify integer variables and create corresponding objects.
double getCurrentMinimizationObjValue() const
Get current minimization objective function value.