94#define MAXNLPERRORS 10
95#define MAXNCLOCKSKIPS 64
96#define NINITCALLS 1000L
97#define SAFETYFACTOR 1e-2
121 if(
set->limitchanged )
133 if(
set->misc_catchctrlc )
145 else if(
set->istimelimitfinite )
231 SCIP_Real lowerbound;
336 else if( lp !=
NULL )
341 for(
h = 0;
h <
set->nheurs; ++
h )
599 if( maxproprounds == 0 )
600 maxproprounds = (
depth == 0 ?
set->prop_maxroundsroot :
set->prop_maxrounds);
601 if( maxproprounds == -1 )
604 SCIPsetDebugMsg(
set,
"domain propagation of node %p in depth %d (using depth %d, maxrounds %d, proptiming %u)\n",
617 SCIP_CALL(
propagationRound(blkmem,
set, stat, tree,
depth,
fullpropagation,
FALSE, &
delayed, &
propagain, timingmask,
cutoff,
postpone) );
623 SCIP_CALL(
propagationRound(blkmem,
set, stat, tree,
depth,
fullpropagation,
TRUE, &
delayed, &
propagain, timingmask,
cutoff,
postpone) );
637 SCIPsetDebugMsg(
set,
" --> domain propagation of node %p finished: cutoff!\n", (
void*)node);
669 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
795 node = tree->
path[
d];
804 for(
i = 0;
i < nboundchgs; ++
i )
861 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s>: sol: %g -> %g, LP: %e -> %e => solvaldelta = %g, gain=%g, weight: %g\n",
896 assert(
set->branch_lpgainnorm ==
'd' ||
set->branch_lpgainnorm ==
's');
900 if(
set->branch_lpgainnorm ==
'd' )
910 for(
j = nbdchginfos-1;
j >= 0; --
j )
944 delta =
updates[
i]->newbound - oldbound;
956 for(
j = nbdchginfos-1;
j >= 0; --
j )
990 delta =
updates[
i]->newbound - oldbound;
1032 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s> with strategy %c: domain: [%g,%g] -> [%g,%g], LP: %e -> %e => "
1033 "delta = %g, gain=%g, weight: %g\n",
1141 for(
h = 0;
h <
set->nconshdlrs && !(*cutoff); ++
h )
1150 eventfilter, lp, root) );
1156 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1220 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1246 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
1247 eventfilter, cliquetable, root,
TRUE,
cutoff) );
1256 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1338 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1353 SCIP_CALL(
initLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,
1360 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
1463 SCIP_Real starttime = 0.0;
1479 SCIP_CALL(
SCIPconstructCurrentLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,
1491 if( focusnode->
depth == 0 )
1540 SCIP_Real lowerbound;
1545 if(
set->misc_exactsolve )
1588 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob,
set->lp_iterlim,
FALSE,
TRUE,
FALSE,
lperror) );
1616 SCIP_Real bounddist,
1617 SCIP_Bool allowlocal,
1629 SCIP_Bool consadded;
1652 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1684 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror,
mustsepa,
mustprice) );
1701 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1708 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1721 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror,
mustsepa,
mustprice) );
1739 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1761 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror,
mustsepa,
mustprice) );
1783 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1787 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1800 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror,
mustsepa,
mustprice) );
1809 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, lpflushed=%u, cutoff=%u\n",
1824 SCIP_Bool allowlocal,
1833 SCIP_Bool consadded;
1953 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, cutoff=%u\n",
1974 SCIP_Bool allowlocal,
1999 SCIP_CALL(
separationRoundLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, \
2006 SCIP_CALL(
separationRoundSol(blkmem,
set, stat, sepastore,
sol,
actdepth, allowlocal,
onlydelayed,
delayed, &
enoughcuts,
cutoff) );
2157 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
TRUE,
FALSE,
lperror) );
2169 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2185 SCIPsetDebugMsg(
set,
"pricing: solve LP after resetting bounds and adding new initial constraints\n");
2186 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
2247 || (
set->sepa_poolfreq > 0 &&
actdepth %
set->sepa_poolfreq == 0) )
2251 SCIP_CALL(
SCIPcutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
NULL,
cutpoolisdelayed, root, &
result) );
2298 SCIP_Real bounddist;
2305 SCIP_Bool allowlocal;
2340 separate = (
set->sepa_maxruns == -1 || stat->
nruns <=
set->sepa_maxruns);
2343 maxseparounds = (root ?
set->sepa_maxroundsroot :
set->sepa_maxrounds);
2344 if( maxseparounds == -1 )
2346 if( stat->
nruns > 1 && root &&
set->sepa_maxroundsrootsubrun >= 0 )
2347 maxseparounds =
MIN(maxseparounds,
set->sepa_maxroundsrootsubrun);
2385 SCIP_CALL(
SCIPpriceLoop(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2386 pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &
npricedcolvars,
2430 SCIPsetDebugMsg(
set,
" -> LP solved: call propagators that are applicable during LP solving loop\n");
2441 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2562 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2601 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2675 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2768 SCIPsetDebugMsg(
set,
"separation round %d/%d finished (%d/%d stall rounds): mustprice=%u, mustsepa=%u, delayedsepa=%u, propagateagain=%u\n",
2779 "Truncate separation round because of stalling (%d stall rounds).\n",
maxnsepastallrounds);
2821 lp, branchcand, eventqueue, cliquetable,
NULL) );
2870 SCIP_Real pseudoobjval;
2878 SCIPsetDebugMsg(
set,
" -> lower bound: %g [%g] (pseudoobj: %g [%g]), cutoff bound: %g [%g]\n",
2895 SCIP_CALL(
SCIPconflictAnalyzePseudo(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable,
NULL) );
2917 for(
r = 0;
r <
set->nrelaxs; ++
r )
2979 SCIP_CALL(
solveNodeInitialLP(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
3013 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3020 SCIP_CALL(
SCIPsolCheck(
sol,
set, messagehdlr, blkmem, stat, transprob,
FALSE,
FALSE,
TRUE,
TRUE,
3027 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3040 if(
set->reopt_enable )
3056 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
3062 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
3092 SCIP_CALL(
priceAndCutLoop(blkmem,
set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
3093 pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,
3125 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
3130 SCIPsetDebugMsg(
set,
"re-optimized LP without cutoff bound: LP status: %d, LP obj: %g\n",
3186 SCIP_Real lowerbound;
3201 for(
r = 0;
r <
set->nrelaxs && !(*cutoff); ++
r )
3281 SCIP_Bool* infeasible,
3290 SCIP_Real pseudoobjval;
3321 if(
set->conshdlrs_enfo[
h]->consenforelax ==
NULL && ((!
set->conshdlrs_enfo[
h]->needscons) ||
3322 (
set->conshdlrs_enfo[
h]->nconss > 0)) )
3340 " since constraint handler %s does not implement enforelax-callback\n",
3396 relaxsol, *infeasible, &
result) );
3414 SCIPerrorMessage(
"pseudo enforcing method of constraint handler <%s> separated cuts\n",
3508 SCIPerrorMessage(
"invalid result code <%d> from enforcing method of constraint handler <%s>\n",
3550 SCIPsetDebugMsg(
set,
" -> enforcing result: branched=%u, cutoff=%u, infeasible=%u, propagateagain=%u, solvelpagain=%u, resolved=%u\n",
3598 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
3644 for(
r = 0;
r <
set->nrelaxs && !(*solverelaxagain); ++
r )
3814 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
3815 conflict, cliquetable,
cutoff) );
3882 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3887 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
3898 SCIP_CALL(
solveNodeLP(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
3899 sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,
3970 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
3992 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3997 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
4016 return (
set->nactivepricers == 0 && !
set->reopt_enable
4017 && (
set->presol_maxrestarts == -1 || stat->
nruns <=
set->presol_maxrestarts)
4018 && (
set->limit_restarts == -1 || stat->
nruns <=
set->limit_restarts));
4021#define restartAllowed(set,stat) ((set)->nactivepricers == 0 && !set->reopt_enable && ((set)->presol_maxrestarts == -1 || (stat)->nruns <= (set)->presol_maxrestarts) \
4022 && (set->limit_restarts == -1 || stat->nruns <= set->limit_restarts))
4053 SCIP_Bool* infeasible,
4069 SCIP_Bool focusnodehaslp;
4100 *infeasible =
FALSE;
4128 focusnodehaslp = (
set->lp_solvedepth == -1 ||
actdepth <=
set->lp_solvedepth);
4129 focusnodehaslp = focusnodehaslp && (
set->lp_solvefreq >= 1 &&
actdepth %
set->lp_solvefreq == 0);
4130 focusnodehaslp = focusnodehaslp || (
actdepth == 0 &&
set->lp_solvefreq == 0);
4171 *infeasible =
FALSE;
4192 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4193 conflict, cliquetable,
cutoff) );
4196 SCIPsetDebugMsg(
set,
" -> node solving loop: call propagators that are applicable before%s LP is solved\n",
4198 SCIP_CALL(
propAndSolve(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,
4199 relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,
4239 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4308 *infeasible =
FALSE;
4312 SCIP_CALL(
enforceConstraints(blkmem,
set, messagehdlr, stat, transprob, primal, tree, lp, relaxation, sepastore,
4325 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4330 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4356 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4376 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4430 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on LP solution with %d fractionals\n",
4432 SCIP_CALL(
SCIPbranchExecLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4443 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on %d external branching candidates.\n",
4445 SCIP_CALL(
SCIPbranchExecExtern(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4454 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on pseudo solution with %d unfixed integers\n",
4456 SCIP_CALL(
SCIPbranchExecPseudo(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
4470 "Starting spatial branch-and-bound on unbounded variable <%s> ([%g,%g]) - cannot guarantee finite termination.\n",
4487 SCIPerrorMessage(
"LP branching rule added constraint, which was not allowed this time\n");
4530 if( transprob->
ncontvars == 0 &&
set->nactivepricers == 0 )
4533 SCIPsetDebugMsg(
set,
" -> cutoff because all variables are fixed in current node\n");
4561 SCIPerrorMessage(
"pricing was aborted, but no branching could be created!\n");
4568 SCIPerrorMessage(
"LP was solved, all integers fixed, some constraint still infeasible, but no branching could be created!\n");
4595 SCIPerrorMessage(
"invalid result code <%d> from SCIPbranchLP(), SCIPbranchExt() or SCIPbranchPseudo()\n",
result);
4606 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4611 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4622 SCIPsetDebugMsg(
set,
"node solving iteration %d finished: cutoff=%u, postpone=%u, propagateagain=%u, solverelaxagain=%u, solvelpagain=%u, nlperrors=%d, restart=%u\n",
4629 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
4647 if(
actdepth == 0 && !(*
cutoff) && !(*unbounded) && !(*postpone) )
4727 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4732 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4765 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4770 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4801 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4806 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4866 SCIP_Bool infeasible;
4894 if(
set->conf_restartnum > 0 )
4955 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt,
4956 lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
4971 if( focusnode ==
NULL )
4994 SCIP_CALL(
solveNode(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,
4995 pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,
5051 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,
5052 lp, eventqueue, eventfilter,
FALSE) );
5055 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &
cutoff) );
5065 if(
set->reopt_enable )
5095 if(
set->reopt_enable )
5117 if(
set->reopt_enable )
5154 SCIPerrorMessage(
"cannot branch on all-fixed LP -- have to call PerPlex instead\n");
5194 else if( !infeasible && !
postpone )
5200 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,
5201 eventqueue, eventfilter,
TRUE) );
5203 if(
set->reopt_enable )
5217 SCIP_CALL(
SCIPnodeFocus(&
newfocusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5218 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
TRUE,
FALSE) );
5243 "(run %d, node %" SCIP_LONGINT_FORMAT ") restarting: triggering parameter controlled restart)\n",
5261 SCIPsetDebugMsg(
set,
"**********************************************************************\n");
5287 if(
set->reopt_enable )
5296 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5297 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5309 if( primal->
nsols > 0 )
SCIP_RETCODE SCIPbranchcandGetLPCands(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
int SCIPbranchcandGetNExternCands(SCIP_BRANCHCAND *branchcand)
SCIP_RETCODE SCIPbranchExecPseudo(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
int SCIPbranchcandGetNPrioExternCands(SCIP_BRANCHCAND *branchcand)
void SCIPbranchcandClearExternCands(SCIP_BRANCHCAND *branchcand)
int SCIPbranchcandGetExternMaxPrio(SCIP_BRANCHCAND *branchcand)
int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)
int SCIPbranchcandGetNPrioLPCands(SCIP_BRANCHCAND *branchcand)
SCIP_RETCODE SCIPbranchExecExtern(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
SCIP_RETCODE SCIPbranchExecLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)
int SCIPbranchcandGetLPMaxPrio(SCIP_BRANCHCAND *branchcand)
internal methods for branching rules and branching candidate storage
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetLastTime(SCIP_CLOCK *clck)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
internal methods for clocks and timing issues
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
int SCIPgetNConcurrentSolvers(SCIP *scip)
helper functions for concurrent scip solvers
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictAnalyzePseudo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
internal methods for conflict analysis
SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPcutpoolSeparate(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, SCIP_RESULT *result)
internal methods for storing cuts in a cut pool
#define SCIPdebugRemoveNode(blkmem, set, node)
SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)
internal methods for displaying runtime statistics
SCIP_RETCODE SCIPeventChgNode(SCIP_EVENT *event, SCIP_NODE *node)
SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)
internal methods for managing events
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)
int SCIPheurGetPriority(SCIP_HEUR *heur)
const char * SCIPheurGetName(SCIP_HEUR *heur)
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
SCIP_Bool SCIPnodeIsActive(SCIP_NODE *node)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_Bool SCIPnodeIsPropagatedAgain(SCIP_NODE *node)
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
SCIP_Bool SCIPpropWasDelayed(SCIP_PROP *prop)
const char * SCIPpropGetName(SCIP_PROP *prop)
int SCIPpropGetPriority(SCIP_PROP *prop)
SCIP_PROPTIMING SCIPpropGetTimingmask(SCIP_PROP *prop)
void SCIPrelaxMarkUnsolved(SCIP_RELAX *relax)
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
int SCIPrelaxGetPriority(SCIP_RELAX *relax)
SCIP_Bool SCIPsepaWasSolDelayed(SCIP_SEPA *sepa)
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
SCIP_Bool SCIPsepaWasLPDelayed(SCIP_SEPA *sepa)
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
void SCIPregressionAddObservation(SCIP_REGRESSION *regression, SCIP_Real x, SCIP_Real y)
SCIP_RETCODE SCIPheurExec(SCIP_HEUR *heur, SCIP_SET *set, SCIP_PRIMAL *primal, int depth, int lpstateforkdepth, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, int *ndelayedheurs, SCIP_RESULT *result)
SCIP_Bool SCIPheurShouldBeExecuted(SCIP_HEUR *heur, int depth, int lpstateforkdepth, SCIP_HEURTIMING heurtiming, SCIP_Bool *delayed)
internal methods for primal heuristics
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
void SCIPresetInterrupted(void)
SCIP_Bool SCIPterminated(void)
SCIP_Bool SCIPinterrupted(void)
methods for catching the user CTRL-C interrupt
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
int SCIPlpGetNRows(SCIP_LP *lp)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
internal methods for LP management
interface methods for specific LP solvers
size_t BMSgetNUsedBufferMemory(BMS_BUFMEM *buffer)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_RETCODE SCIPnodeselSelect(SCIP_NODESEL *nodesel, SCIP_SET *set, SCIP_NODE **selnode)
internal methods for node selectors and node priority queues
SCIP_RETCODE SCIPpricerExec(SCIP_PRICER *pricer, SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_Real *lowerbound, SCIP_Bool *stopearly, SCIP_RESULT *result)
internal methods for variable pricers
void SCIPpricestoreStartInitialLP(SCIP_PRICESTORE *pricestore)
SCIP_RETCODE SCIPpricestoreApplyVars(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)
int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)
SCIP_RETCODE SCIPpricestoreAddProbVars(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPpricestoreAddVar(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_VAR *var, SCIP_Real score, SCIP_Bool root)
int SCIPpricestoreGetNBoundResets(SCIP_PRICESTORE *pricestore)
void SCIPpricestoreEndInitialLP(SCIP_PRICESTORE *pricestore)
SCIP_RETCODE SCIPpricestoreResetBounds(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
internal methods for storing priced variables
SCIP_RETCODE SCIPprimalTrySolFree(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE SCIPprimalTrySol(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE SCIPprimalAddSolFree(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL **sol, SCIP_Bool *stored)
internal methods for collecting primal CIP solutions and primal informations
SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
void SCIPprobStoreRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool roothaslp)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
void SCIPprobUpdateBestRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
internal methods for storing and manipulating the main problem
SCIP_RETCODE SCIPpropExec(SCIP_PROP *prop, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
internal methods for propagators
public methods for managing constraints
public methods for primal heuristics
public methods for message output
public data structures and miscellaneous methods
public methods for variable pricers
public methods for propagators
public methods for relaxation handlers
public methods for separators
public methods for branch and bound tree
public methods for problem variables
void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)
SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)
SCIP_Bool SCIPrelaxIsSolved(SCIP_RELAX *relax, SCIP_STAT *stat)
SCIP_RETCODE SCIPrelaxExec(SCIP_RELAX *relax, SCIP_SET *set, SCIP_TREE *tree, SCIP_STAT *stat, int depth, SCIP_Real *lowerbound, SCIP_RESULT *result)
SCIP_Bool SCIPrelaxationIsLpIncludedForSol(SCIP_RELAXATION *relaxation)
SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)
internal methods for relaxators
SCIP_RETCODE SCIPreoptCheckCutoff(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_EVENTTYPE eventtype, SCIP_LP *lp, SCIP_LPSOLSTAT lpsolstat, SCIP_Bool isrootnode, SCIP_Bool isfocusnode, SCIP_Real lowerbound, int effectiverootdepth)
SCIP_RETCODE SCIPreoptApplyCuts(SCIP_REOPT *reopt, SCIP_NODE *node, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool root)
SCIP_Bool SCIPreoptGetSolveLP(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node)
data structures and methods for collecting reoptimization information
public methods for concurrent solving mode
public methods for memory management
public methods for global and local (sub)problems
public methods for solutions
public methods for querying solving statistics
SCIP_RETCODE SCIPsepaExecLP(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_RETCODE SCIPsepaExecSol(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)
internal methods for separators
void SCIPsepastoreEndInitialLP(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPsepastoreClearCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPsepastoreAddCut(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool root, SCIP_Bool *infeasible)
void SCIPsepastoreStartForceCuts(SCIP_SEPASTORE *sepastore)
void SCIPsepastoreEndForceCuts(SCIP_SEPASTORE *sepastore)
void SCIPsepastoreStartInitialLP(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPsepastoreApplyCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice, SCIP_Bool *cutoff)
int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)
internal methods for storing separated cuts
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
void SCIPsetSortRelaxs(SCIP_SET *set)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
void SCIPsetSortPricers(SCIP_SET *set)
void SCIPsetSortSepas(SCIP_SET *set)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
void SCIPsetSortProps(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
void SCIPsetSortHeurs(SCIP_SET *set)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define SCIPsetReallocBufferArray(set, ptr, num)
SCIP_RETCODE SCIPsolCreateRelaxSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsolCheck(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)
SCIP_RETCODE SCIPsolCreateCurrentSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsolSetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPsolCreatePseudoSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsolCreateLPSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
SCIP_RETCODE SCIPsolCreate(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)
internal methods for storing primal CIP solutions
static SCIP_RETCODE cutpoolSeparate(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, int actdepth, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff)
static SCIP_RETCODE enforceConstraints(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_Bool *branched, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool forced)
static SCIP_RETCODE updateEstimate(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)
enum PseudocostFlag PSEUDOCOSTFLAG
static SCIP_RETCODE applyBounding(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)
static SCIP_RETCODE solveNodeInitialLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff, SCIP_Bool *lperror)
static SCIP_RETCODE updatePseudocost(SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous)
SCIP_RETCODE SCIPsolveCIP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *restart)
static SCIP_RETCODE separationRoundSol(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff)
static void updateLoopStatus(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain)
static SCIP_RETCODE propAndSolve(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_NODE *focusnode, int actdepth, SCIP_Bool propagate, SCIP_Bool solvelp, SCIP_Bool solverelax, SCIP_Bool forcedlpsolve, SCIP_Bool initiallpsolved, SCIP_Bool fullseparation, SCIP_Longint *afterlpproplps, SCIP_HEURTIMING *heurtiming, int *nlperrors, SCIP_Bool *fullpropagation, SCIP_Bool *propagateagain, SCIP_Bool *lpsolved, SCIP_Bool *relaxcalled, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *stopped, SCIP_Bool *lperror, SCIP_Bool *pricingaborted, SCIP_Bool *forcedenforcement)
SCIP_RETCODE SCIPpropagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, int depth, int maxproprounds, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff)
static SCIP_RETCODE separationRoundLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, int actdepth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice)
static SCIP_RETCODE solveNodeLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool initiallpsolved, SCIP_Bool fullseparation, SCIP_Bool newinitconss, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted)
SCIP_RETCODE SCIPinitConssLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool firstsubtreeinit, SCIP_Bool *cutoff)
static SCIP_RETCODE solveNodeRelax(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_PROB *origprob, int depth, SCIP_Bool beforelp, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *relaxcalled)
static SCIP_RETCODE applyCuts(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain)
static SCIP_RETCODE propagationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool fullpropagation, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *propagain, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone)
static SCIP_RETCODE propagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, int maxproprounds, SCIP_Bool fullpropagation, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone)
SCIP_RETCODE SCIPpriceLoop(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, int *npricedcolvars, SCIP_Bool *mustsepa, SCIP_Bool *lperror, SCIP_Bool *aborted)
SCIP_RETCODE SCIPconstructCurrentLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff)
static SCIP_RETCODE addCurrentSolution(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_RELAXATION *relaxation, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool checksol)
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
static SCIP_RETCODE priceAndCutLoop(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool fullseparation, SCIP_Bool *propagateagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted)
static SCIP_RETCODE solveNode(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *restart, SCIP_Bool *afternodeheur, SCIP_Bool *stopped)
static SCIP_RETCODE updatePrimalRay(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool lperror)
static void markRelaxsUnsolved(SCIP_SET *set, SCIP_RELAXATION *relaxation)
SCIP_RETCODE SCIPseparationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
static SCIP_Bool restartAllowed(SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE initLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool *cutoff)
static SCIP_RETCODE separationRoundResolveLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice)
static SCIP_Bool isPseudocostUpdateValid(SCIP_VAR *var, SCIP_SET *set, SCIP_Real oldlpsolval, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous)
SCIP_RETCODE SCIPprimalHeuristics(SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_NODE *nextnode, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_Bool *foundsol, SCIP_Bool *unbounded)
internal methods for main solving loop and node processing
void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
void SCIPstatUpdateMemsaveMode(SCIP_STAT *stat, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_MEM *mem)
internal methods for problem statistics
#define SCIPstatIncrement(stat, set, field)
SCIP_BRANCHINGDATA branchingdata
SCIP_BOUNDCHG * boundchgs
union SCIP_Node::@18 data
SCIP_Longint nbestsolsfound
SCIP_Longint nlimsolsfound
SCIP_Longint nrelaxsolsfound
SCIP_Longint nprimalzeroitlps
SCIP_REGRESSION * regressioncandsobjval
SCIP_Bool disableenforelaxmsg
SCIP_Longint ninfeasleaves
SCIP_Longint ndelayedcutoffs
SCIP_CLOCK * nodeactivationtime
SCIP_Longint externmemestim
SCIP_Longint nrootfirstlpiterations
SCIP_Longint ninitconssadded
SCIP_Longint nlpiterations
SCIP_Longint nnodesaboverefbound
SCIP_Real firstlpdualbound
SCIP_Longint nrootlpiterations
SCIP_Longint ninternalnodes
SCIP_CLOCK * relaxsoltime
SCIP_Longint ntotalinternalnodes
SCIP_BRANCHDIR lastbranchdir
SCIP_CLOCK * pseudosoltime
SCIP_Longint nlpbestsolsfound
SCIP_Longint nrelaxbestsolsfound
SCIP_Longint npsbestsolsfound
SCIP_Longint nisstoppedcalls
SCIP_Longint ndualzeroitlps
SCIP_Longint nnodelpiterations
SCIP_Longint nnodezeroitlps
SCIP_Longint npssolsfound
SCIP_Longint nbarrierzeroitlps
SCIP_Bool branchedunbdvar
SCIP_Longint nlpsolsfound
SCIP_Real lastbranchvalue
SCIP_Longint ninitlpiterations
SCIP_NODE * focuslpstatefork
SCIP_Bool forcinglpmessage
unsigned int pseudocostflag
datastructures for constraints and constraint handlers
datastructures for managing events
data structures for LP management
datastructures for block memory pools and memory buffers
datastructures for collecting primal CIP solutions and primal informations
datastructures for storing and manipulating the main problem
datastructures for global SCIP settings
datastructures for problem statistics
data structures for branch and bound tree
datastructures for problem variables
SCIP_Bool SCIPsyncstoreSolveIsStopped(SCIP_SYNCSTORE *syncstore)
the function declarations for the synchronization store
void SCIPnodeUpdateLowerbound(SCIP_NODE *node, SCIP_STAT *stat, SCIP_SET *set, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real newbound)
SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)
SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
SCIP_RETCODE SCIPtreeSetNodesel(SCIP_TREE *tree, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_NODESEL *nodesel)
void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
void SCIPnodeMarkPropagated(SCIP_NODE *node, SCIP_TREE *tree)
int SCIPtreeGetNLeaves(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeCreateChild(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
void SCIPtreeSetFocusNodeLP(SCIP_TREE *tree, SCIP_Bool solvelp)
int SCIPtreeGetNNodes(SCIP_TREE *tree)
SCIP_Bool SCIPtreeHasFocusNodeLP(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeFocus(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool postponed, SCIP_Bool exitsolve)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeUpdateLowerboundLP(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp)
SCIP_RETCODE SCIPtreeCutoff(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real cutoffbound)
SCIP_RETCODE SCIPtreeLoadLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPtreeLoadLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool *initroot)
internal methods for branch and bound tree
#define SCIP_EVENTTYPE_FIRSTLPSOLVED
#define SCIP_EVENTTYPE_NODEFEASIBLE
#define SCIP_EVENTTYPE_NODEFOCUSED
#define SCIP_EVENTTYPE_NODEINFEASIBLE
#define SCIP_EVENTTYPE_NODEBRANCHED
#define SCIP_EVENTTYPE_LPSOLVED
enum SCIP_LPSolStat SCIP_LPSOLSTAT
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_VerbLevel SCIP_VERBLEVEL
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_EFFICIACYCHOICE_LP
@ SCIP_EFFICIACYCHOICE_RELAX
enum SCIP_Efficiacychoice SCIP_EFFICIACYCHOICE
@ SCIP_STATUS_TOTALNODELIMIT
@ SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_USERINTERRUPT
@ SCIP_STATUS_STALLNODELIMIT
@ SCIP_STATUS_RESTARTLIMIT
#define SCIP_HEURTIMING_BEFOREPRESOL
#define SCIP_HEURTIMING_DURINGPRICINGLOOP
#define SCIP_HEURTIMING_AFTERPSEUDONODE
#define SCIP_HEURTIMING_AFTERPROPLOOP
unsigned int SCIP_PROPTIMING
unsigned int SCIP_HEURTIMING
#define SCIP_HEURTIMING_DURINGLPLOOP
#define SCIP_HEURTIMING_DURINGPRESOLLOOP
#define SCIP_HEURTIMING_AFTERNODE
#define SCIP_PROPTIMING_AFTERLPLOOP
#define SCIP_HEURTIMING_AFTERLPPLUNGE
#define SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
#define SCIP_PROPTIMING_BEFORELP
#define SCIP_HEURTIMING_AFTERLPNODE
#define SCIP_HEURTIMING_AFTERLPLOOP
#define SCIP_HEURTIMING_BEFORENODE
#define SCIP_PROPTIMING_DURINGLPLOOP
@ SCIP_NODETYPE_REFOCUSNODE
@ SCIP_NODETYPE_PROBINGNODE
@ SCIP_NODETYPE_FOCUSNODE
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_BRANCHING
SCIP_DOMCHGBOUND domchgbound
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
internal methods for problem variables
void SCIPvisualSolvedNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)
void SCIPvisualCutoffNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node, SCIP_Bool infeasible)
methods for creating output for visualization tools (VBC, BAK)