94#define MAXNLPERRORS 10
95#define MAXNCLOCKSKIPS 64
96#define NINITCALLS 1000L
97#define SAFETYFACTOR 1e-2
105 SCIP_Bool checknodelimits
121 if(
set->limitchanged )
133 if(
set->misc_catchctrlc )
145 else if(
set->istimelimitfinite )
155 SCIP_Real avgisstoppedfreq;
161 if( (
SAFETYFACTOR * (
set->limit_time - currtime) / (avgisstoppedfreq + 1e-6)) < nclockskips )
170 if( currtime >=
set->limit_time )
201 else if( checknodelimits &&
set->limit_nodes >= 0 && stat->
nnodes >=
set->limit_nodes )
203 else if( checknodelimits &&
set->limit_totalnodes >= 0 && stat->
ntotalnodes >=
set->limit_totalnodes )
205 else if( checknodelimits &&
set->limit_stallnodes >= 0 && stat->
nnodes >= stat->
bestsolnode +
set->limit_stallnodes )
211 if( !checknodelimits )
228 SCIP_Bool nodeinfeasible,
234 SCIP_Longint oldnbestsolsfound;
235 SCIP_Real lowerbound;
238 int lpstateforkdepth;
275 SCIP_Bool pseudonode;
278 heurtiming &= ~SCIP_HEURTIMING_AFTERNODE;
307 lpstateforkdepth = -1;
340 else if( lp !=
NULL )
345 for(
h = 0;
h <
set->nheurs; ++
h )
368 &ndelayedheurs, &
result) );
395 assert(0 <= ndelayedheurs && ndelayedheurs <= set->nheurs);
410 SCIP_Bool fullpropagation,
411 SCIP_Bool onlydelayed,
413 SCIP_Bool* propagain,
420 SCIP_Bool abortoncutoff;
441 for(
i = 0;
i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++
i )
492 for(
i = 0;
i <
set->nconshdlrs && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++
i )
530 for(
i = 0;
i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++
i )
580 SCIP_Bool fullpropagation,
603 if( maxproprounds == 0 )
604 maxproprounds = (
depth == 0 ?
set->prop_maxroundsroot :
set->prop_maxrounds);
605 if( maxproprounds == -1 )
606 maxproprounds = INT_MAX;
608 SCIPsetDebugMsg(
set,
"domain propagation of node %p in depth %d (using depth %d, maxrounds %d, proptiming %u)\n",
621 SCIP_CALL(
propagationRound(blkmem,
set, stat, tree,
depth, fullpropagation,
FALSE, &delayed, &propagain, timingmask,
cutoff, postpone) );
624 while( delayed && (!propagain || propround >= maxproprounds) && !(*
cutoff) )
627 SCIP_CALL(
propagationRound(blkmem,
set, stat, tree,
depth, fullpropagation,
TRUE, &delayed, &propagain, timingmask,
cutoff, postpone) );
633 fullpropagation =
TRUE;
641 SCIPsetDebugMsg(
set,
" --> domain propagation of node %p finished: cutoff!\n", (
void*)node);
673 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
683 SCIP_Real oldlpsolval,
684 SCIP_Bool updateintegers,
685 SCIP_Bool updatecontinuous
688 SCIP_Real newlpsolval;
753 SCIP_Bool updateintegers,
754 SCIP_Bool updatecontinuous
799 node = tree->
path[d];
808 for(
i = 0;
i < nboundchgs; ++
i )
826 updates[nupdates] = &boundchgs[
i];
849 weight = (nvalidupdates > 0 ? 1.0 / (
SCIP_Real)nvalidupdates : 1.0);
851 lpgain =
MAX(lpgain, 0.0);
853 for(
i = 0;
i < nupdates; ++
i )
865 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s>: sol: %g -> %g, LP: %e -> %e => solvaldelta = %g, gain=%g, weight: %g\n",
900 assert(
set->branch_lpgainnorm ==
'd' ||
set->branch_lpgainnorm ==
's');
904 if(
set->branch_lpgainnorm ==
'd' )
906 assert(!updates[
i]->redundant);
914 for( j = nbdchginfos-1; j >= 0; --j )
938 assert(j >= 0 || updates[
i]->redundant);
960 for( j = nbdchginfos-1; j >= 0; --j )
984 assert(j >= 0 || updates[
i]->redundant);
1036 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s> with strategy %c: domain: [%g,%g] -> [%g,%g], LP: %e -> %e => "
1037 "delta = %g, gain=%g, weight: %g\n",
1044 delta, lpgain, weight);
1104 estimate +=
MIN(pscdown, pscup);
1128 SCIP_Bool firstsubtreeinit,
1145 for(
h = 0;
h <
set->nconshdlrs && !(*cutoff); ++
h )
1150 if(
set->reopt_enable &&
set->reopt_usecuts && firstsubtreeinit && !(*
cutoff) )
1154 eventfilter, lp, root) );
1160 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1217 oldnvars = transprob->
nvars;
1224 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1250 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
1251 eventfilter, cliquetable, root,
TRUE,
cutoff) );
1254 if( root && !(*
cutoff) && transprob->
nvars > oldnvars )
1260 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1301 SCIP_Bool newinitconss,
1305 SCIP_Bool initroot =
FALSE;
1342 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1357 SCIP_CALL(
initLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,
1358 eventqueue, eventfilter, cliquetable, initroot,
cutoff) );
1361 else if( newinitconss )
1364 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
1461 SCIP_Bool newinitconss,
1467 SCIP_Real starttime = 0.0;
1483 SCIP_CALL(
SCIPconstructCurrentLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,
1484 branchcand, eventqueue, eventfilter, cliquetable, newinitconss,
cutoff) );
1495 if( focusnode->
depth == 0 )
1544 SCIP_Real lowerbound;
1549 if(
set->misc_exactsolve )
1578 SCIP_Bool* mustsepa,
1579 SCIP_Bool* mustprice
1592 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob,
set->lp_iterlim,
FALSE,
TRUE,
FALSE,
lperror) );
1620 SCIP_Real bounddist,
1621 SCIP_Bool allowlocal,
1622 SCIP_Bool onlydelayed,
1624 SCIP_Bool* enoughcuts,
1627 SCIP_Bool* mustsepa,
1628 SCIP_Bool* mustprice
1633 SCIP_Bool consadded;
1644 root = (actdepth == 0);
1649 *enoughcuts =
FALSE;
1656 SCIPsetDebugMsg(
set,
"calling separators on LP solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1662 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1703 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1720 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1727 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1749 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1767 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1798 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1820 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1824 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1846 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1855 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, lpflushed=%u, cutoff=%u\n",
1870 SCIP_Bool allowlocal,
1871 SCIP_Bool onlydelayed,
1873 SCIP_Bool* enoughcuts,
1879 SCIP_Bool consadded;
1889 *enoughcuts =
FALSE;
1891 root = (actdepth == 0);
1893 SCIPsetDebugMsg(
set,
"calling separators on primal solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
2035 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, cutoff=%u\n",
2036 *delayed, *enoughcuts, *
cutoff);
2056 SCIP_Bool allowlocal,
2057 SCIP_Bool onlydelayed,
2062 SCIP_Bool enoughcuts;
2075 SCIP_Bool mustprice;
2081 SCIP_CALL(
separationRoundLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, \
2082 actdepth, 0.0, allowlocal, onlydelayed, delayed, &enoughcuts,
cutoff, \
2083 &
lperror, &mustsepa, &mustprice) );
2088 SCIP_CALL(
separationRoundSol(blkmem,
set, stat, sepastore,
sol, actdepth, allowlocal, onlydelayed, delayed, &enoughcuts,
cutoff) );
2113 SCIP_Bool pretendroot,
2114 SCIP_Bool displayinfo,
2117 int* npricedcolvars,
2118 SCIP_Bool* mustsepa,
2126 SCIP_Bool mustprice;
2128 SCIP_Bool unbounded;
2141 *npricedcolvars = transprob->
ncolvars;
2154 if( maxpricerounds == -1 )
2155 maxpricerounds = INT_MAX;
2159 while( !(*
lperror) && mustprice && npricerounds < maxpricerounds )
2161 SCIP_Bool enoughvars;
2165 SCIP_Bool stopearly;
2166 SCIP_Bool stoppricing;
2186 FALSE, &foundsol, &unbounded) );
2193 *npricedcolvars = transprob->
ncolvars;
2204 stoppricing =
FALSE;
2205 for( p = 0; p <
set->nactivepricers && !enoughvars; ++p )
2216 if( p == 0 && stopearly )
2220 if( stoppricing && !stopearly )
2221 stoppricing =
FALSE;
2233 *mustsepa = *mustsepa || !lp->
flushed;
2239 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
TRUE,
FALSE,
lperror) );
2251 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2255 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != *npricedcolvars);
2256 *mustsepa = *mustsepa || !lp->
flushed;
2267 SCIPsetDebugMsg(
set,
"pricing: solve LP after resetting bounds and adding new initial constraints\n");
2268 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
2280 if( displayinfo && mustprice )
2290 mustprice = mustprice &&
2321 SCIP_Bool cutpoolisdelayed,
2324 SCIP_Bool* enoughcuts,
2328 if( (
set->sepa_poolfreq == 0 && actdepth == 0)
2329 || (
set->sepa_poolfreq > 0 && actdepth %
set->sepa_poolfreq == 0) )
2333 SCIP_CALL(
SCIPcutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
NULL, cutpoolisdelayed, root, &
result) );
2374 SCIP_Bool fullseparation,
2375 SCIP_Bool* propagateagain,
2377 SCIP_Bool* unbounded,
2379 SCIP_Bool* pricingaborted
2387 SCIP_Real loclowerbound;
2388 SCIP_Real glblowerbound;
2389 SCIP_Real bounddist;
2390 SCIP_Real stalllpobjval;
2392 SCIP_Bool mustprice;
2394 SCIP_Bool delayedsepa;
2396 SCIP_Bool allowlocal;
2398 int nsepastallrounds;
2399 int maxnsepastallrounds;
2423 root = (actdepth == 0);
2429 bounddist = (loclowerbound - glblowerbound)/(primal->
cutoffbound - glblowerbound);
2431 separate = (
set->sepa_maxruns == -1 || stat->
nruns <
set->sepa_maxruns);
2434 maxseparounds = (root ?
set->sepa_maxroundsroot :
set->sepa_maxrounds);
2435 if( maxseparounds == -1 )
2436 maxseparounds = INT_MAX;
2437 if( stat->
nruns > 1 && root &&
set->sepa_maxroundsrootsubrun >= 0 )
2438 maxseparounds =
MIN(maxseparounds,
set->sepa_maxroundsrootsubrun);
2439 if( !fullseparation &&
set->sepa_maxaddrounds >= 0 )
2441 maxnsepastallrounds = root ?
set->sepa_maxstallroundsroot :
set->sepa_maxstallrounds;
2442 if( maxnsepastallrounds == -1 )
2443 maxnsepastallrounds = INT_MAX;
2456 npricedcolvars = transprob->
ncolvars;
2458 mustsepa = separate;
2459 delayedsepa =
FALSE;
2462 nsepastallrounds = 0;
2465 stallnfracs = INT_MAX;
2467 while( !(*
cutoff) && !(*unbounded) && !(*
lperror) && (mustprice || mustsepa || delayedsepa) )
2474 while( mustprice && !(*
lperror) )
2476 SCIP_CALL(
SCIPpriceLoop(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2477 pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &npricedcolvars,
2478 &mustsepa,
lperror, pricingaborted) );
2514 SCIP_Longint oldnboundchgs;
2515 SCIP_Longint oldninitconssadded;
2521 SCIPsetDebugMsg(
set,
" -> LP solved: call propagators that are applicable during LP solving loop\n");
2532 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2536 if( !(*
cutoff) && !(*unbounded) )
2560 *propagateagain =
TRUE;
2568 *propagateagain =
TRUE;
2596 FALSE, &foundsol, unbounded) );
2608 && nsepastallrounds < maxnsepastallrounds
2612 delayedsepa = delayedsepa && !mustsepa && !(*cutoff);
2613 mustsepa = mustsepa || delayedsepa;
2621 if( !separate || (*
cutoff) || (*unbounded)
2627 delayedsepa =
FALSE;
2636 SCIP_Longint olddomchgcount;
2637 SCIP_Longint oldninitconssadded;
2638 SCIP_Bool enoughcuts;
2653 if( !enoughcuts && !delayedsepa )
2655 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2656 actdepth, &enoughcuts,
cutoff) );
2669 if( !(*
cutoff) && !enoughcuts )
2676 lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2677 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2683 && nsepastallrounds >= maxnsepastallrounds-1 && delayedsepa )
2686 tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2687 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2695 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2696 actdepth, &enoughcuts,
cutoff) );
2708 root, actdepth, &enoughcuts,
cutoff) );
2723 tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2724 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2733 root, actdepth, &enoughcuts,
cutoff) );
2769 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != npricedcolvars);
2770 mustsepa = mustsepa || !lp->
flushed;
2777 *propagateagain =
TRUE;
2792 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2818 if( stat->
domchgcount != olddomchgcount && (!mustprice || mustsepa) && !(*
cutoff)
2841 SCIP_Real objreldiff;
2848 objreldiff =
SCIPrelDiff(lpobjval, stalllpobjval);
2850 stalllpobjval, lpobjval, objreldiff);
2853 objreldiff <= 1e-04 &&
2854 nfracs >= (0.9 - 0.1 * nsepastallrounds) * stallnfracs);
2856 stalllpobjval = lpobjval;
2857 stallnfracs = nfracs;
2866 nsepastallrounds = 0;
2876 if( nsepastallrounds >= maxnsepastallrounds-2 )
2878 SCIPsetDebugMsg(
set,
" -> nsepastallrounds=%d/%d\n", nsepastallrounds, maxnsepastallrounds);
2885 SCIPsetDebugMsg(
set,
"separation round %d/%d finished (%d/%d stall rounds): mustprice=%u, mustsepa=%u, delayedsepa=%u, propagateagain=%u\n",
2886 stat->
nseparounds, maxseparounds, nsepastallrounds, maxnsepastallrounds, mustprice, mustsepa, delayedsepa, *propagateagain);
2893 if( root && nsepastallrounds >= maxnsepastallrounds )
2896 "Truncate separation round because of stalling (%d stall rounds).\n", maxnsepastallrounds);
2938 lp, branchcand, eventqueue, cliquetable,
NULL) );
2987 SCIP_Real pseudoobjval;
2995 SCIPsetDebugMsg(
set,
" -> lower bound: %g [%g] (pseudoobj: %g [%g]), cutoff bound: %g [%g]\n",
3012 SCIP_CALL(
SCIPconflictAnalyzePseudo(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable,
NULL) );
3034 for(
r = 0;
r <
set->nrelaxs; ++
r )
3063 SCIP_Bool initiallpsolved,
3064 SCIP_Bool fullseparation,
3065 SCIP_Bool newinitconss,
3066 SCIP_Bool* propagateagain,
3067 SCIP_Bool* solverelaxagain,
3069 SCIP_Bool* unbounded,
3071 SCIP_Bool* pricingaborted
3077 SCIP_Longint nzeroitlps;
3093 if( !initiallpsolved )
3096 SCIP_CALL(
solveNodeInitialLP(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
3097 pricestore, sepastore, cutpool, branchcand, eventfilter, eventqueue, cliquetable, newinitconss,
cutoff,
lperror) );
3116 SCIP_Bool checklprows;
3124 checklprows =
FALSE;
3130 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3137 SCIP_CALL(
SCIPsolCheck(
sol,
set, messagehdlr, blkmem, stat, transprob,
FALSE,
FALSE,
TRUE,
TRUE,
3138 checklprows, &feasible) );
3144 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3157 if(
set->reopt_enable )
3173 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
3179 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
3196 SCIP_Longint oldninitconssadded;
3197 SCIP_Longint oldnboundchgs;
3198 SCIP_Longint olddomchgcount;
3200 int oldncutsapplied;
3202 oldnpricedvars = transprob->
ncolvars;
3209 SCIP_CALL(
priceAndCutLoop(blkmem,
set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
3210 pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,
3211 eventqueue, cliquetable, fullseparation, propagateagain,
cutoff, unbounded,
lperror, pricingaborted) );
3218 *solverelaxagain =
TRUE;
3235 SCIP_Real tmpcutoff;
3242 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
3247 SCIPsetDebugMsg(
set,
"re-optimized LP without cutoff bound: LP status: %d, LP obj: %g\n",
3294 SCIP_Bool* propagateagain,
3295 SCIP_Bool* solvelpagain,
3296 SCIP_Bool* solverelaxagain,
3298 SCIP_Bool* relaxcalled
3303 SCIP_Real lowerbound;
3318 for(
r = 0;
r <
set->nrelaxs && !(*cutoff); ++
r )
3323 *relaxcalled =
TRUE;
3338 *solvelpagain =
TRUE;
3339 *propagateagain =
TRUE;
3343 *solvelpagain =
TRUE;
3344 *propagateagain =
TRUE;
3348 *solvelpagain =
TRUE;
3352 *solverelaxagain =
TRUE;
3396 SCIP_Bool* branched,
3398 SCIP_Bool* infeasible,
3399 SCIP_Bool* propagateagain,
3400 SCIP_Bool* solvelpagain,
3401 SCIP_Bool* solverelaxagain,
3407 SCIP_Real pseudoobjval;
3409 SCIP_Bool objinfeasible;
3410 SCIP_Bool enforcerelaxsol;
3424 assert(!(*propagateagain));
3425 assert(!(*solvelpagain));
3426 assert(!(*solverelaxagain));
3436 for(
h = 0;
h <
set->nconshdlrs && enforcerelaxsol; ++
h )
3438 if(
set->conshdlrs_enfo[
h]->consenforelax ==
NULL && ((!
set->conshdlrs_enfo[
h]->needscons) ||
3439 (
set->conshdlrs_enfo[
h]->nconss > 0)) )
3443 enforcerelaxsol =
FALSE;
3457 " since constraint handler %s does not implement enforelax-callback\n",
3466 if( enforcerelaxsol )
3478 objinfeasible =
FALSE;
3498 if( enforcerelaxsol )
3503 for(
h = 0;
h <
set->nconshdlrs && !resolved; ++
h )
3508 if( enforcerelaxsol )
3513 relaxsol, *infeasible, &
result) );
3528 objinfeasible, forced, &
result) );
3531 SCIPerrorMessage(
"pseudo enforcing method of constraint handler <%s> separated cuts\n",
3552 *propagateagain =
TRUE;
3553 *solvelpagain =
TRUE;
3554 *solverelaxagain =
TRUE;
3562 *propagateagain =
TRUE;
3563 *solvelpagain =
TRUE;
3564 *solverelaxagain =
TRUE;
3573 *solvelpagain =
TRUE;
3574 *solverelaxagain =
TRUE;
3598 *solvelpagain =
TRUE;
3625 SCIPerrorMessage(
"invalid result code <%d> from enforcing method of constraint handler <%s>\n",
3644 *propagateagain =
FALSE;
3645 *solvelpagain =
FALSE;
3648 assert(!(*branched) || (resolved && !(*
cutoff) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3649 assert(!(*
cutoff) || (resolved && !(*branched) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3650 assert(*infeasible || (!resolved && !(*branched) && !(*
cutoff) && !(*propagateagain) && !(*solvelpagain)));
3651 assert(!(*propagateagain) || (resolved && !(*branched) && !(*
cutoff) && *infeasible));
3652 assert(!(*solvelpagain) || (resolved && !(*branched) && !(*
cutoff) && *infeasible));
3654 assert(!objinfeasible || *infeasible);
3655 assert(resolved == (*branched || *
cutoff || *propagateagain || *solvelpagain));
3659 if( enforcerelaxsol )
3667 SCIPsetDebugMsg(
set,
" -> enforcing result: branched=%u, cutoff=%u, infeasible=%u, propagateagain=%u, solvelpagain=%u, resolved=%u\n",
3668 *branched, *
cutoff, *infeasible, *propagateagain, *solvelpagain, resolved);
3693 SCIP_Bool* propagateagain,
3694 SCIP_Bool* solvelpagain,
3695 SCIP_Bool* solverelaxagain
3710 SCIP_Longint olddomchgcount;
3711 int oldncutsapplied;
3715 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
3716 eventqueue, eventfilter, cliquetable, root, efficiacychoice,
cutoff) );
3717 *propagateagain = *propagateagain || (stat->
domchgcount != olddomchgcount);
3718 *solvelpagain =
TRUE;
3721 *solverelaxagain =
TRUE;
3737 SCIP_Bool* propagateagain,
3738 SCIP_Bool* solverelaxagain
3761 for(
r = 0;
r <
set->nrelaxs && !(*solverelaxagain); ++
r )
3767 *propagateagain =
FALSE;
3768 *solverelaxagain =
FALSE;
3801 SCIP_Bool solverelax,
3802 SCIP_Bool forcedlpsolve,
3803 SCIP_Bool initiallpsolved,
3804 SCIP_Bool fullseparation,
3805 SCIP_Longint* afterlpproplps,
3808 SCIP_Bool* fullpropagation,
3809 SCIP_Bool* propagateagain,
3810 SCIP_Bool* lpsolved,
3811 SCIP_Bool* relaxcalled,
3812 SCIP_Bool* solvelpagain,
3813 SCIP_Bool* solverelaxagain,
3815 SCIP_Bool* postpone,
3816 SCIP_Bool* unbounded,
3819 SCIP_Bool* pricingaborted,
3820 SCIP_Bool* forcedenforcement
3823 SCIP_Bool newinitconss;
3858 newinitconss =
FALSE;
3860 if( !(*
cutoff) && !(*postpone) )
3862 SCIP_Longint oldninitconssadded;
3863 SCIP_Longint oldnboundchgs;
3864 SCIP_Bool lpwasflushed;
3871 if( ((*afterlpproplps) < stat->
nnodelps && (*lpsolved)) || (*relaxcalled) )
3892 *fullpropagation =
FALSE;
3900 solvelp = solvelp || (lpwasflushed && (!lp->
flushed || newinitconss));
3901 solverelax = solverelax || newinitconss;
3931 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
3932 conflict, cliquetable,
cutoff) );
3946 FALSE, propagateagain, unbounded) );
3975 if( *propagateagain )
3977 *solvelpagain = solvelp;
3978 *solverelaxagain = solverelax;
3985 *relaxcalled =
FALSE;
3986 if( solverelax && !(*
cutoff) )
3992 cutoff, propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
3999 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4001 solvelpagain, solverelaxagain) );
4004 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4015 SCIP_CALL(
solveNodeLP(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
4016 sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,
4017 initiallpsolved, fullseparation, newinitconss, propagateagain, solverelaxagain,
cutoff, unbounded,
lperror, pricingaborted) );
4020 *solvelpagain =
FALSE;
4048 *forcedenforcement =
TRUE;
4078 *forcedenforcement =
TRUE;
4087 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
4096 *solverelaxagain = *solverelaxagain && *relaxcalled;
4099 if( solverelax && !(*
cutoff) )
4102 propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
4109 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4111 solvelpagain, solverelaxagain) );
4114 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
4133 return set->nactivepricers == 0 && !
set->reopt_enable
4134 && (
set->presol_maxrestarts == -1 || stat->
nruns <=
set->presol_maxrestarts );
4137#define restartAllowed(set,stat) ((set)->nactivepricers == 0 && !set->reopt_enable && ((set)->presol_maxrestarts == -1 || (stat)->nruns <= (set)->presol_maxrestarts))
4166 SCIP_Bool* postpone,
4167 SCIP_Bool* unbounded,
4168 SCIP_Bool* infeasible,
4170 SCIP_Bool* afternodeheur,
4175 SCIP_Longint lastdomchgcount;
4176 SCIP_Longint afterlpproplps;
4177 SCIP_Real restartfac;
4178 SCIP_Longint lastlpcount;
4184 SCIP_Bool focusnodehaslp;
4186 SCIP_Bool initiallpsolved;
4187 SCIP_Bool fullseparation;
4188 SCIP_Bool solverelaxagain;
4189 SCIP_Bool solvelpagain;
4190 SCIP_Bool propagateagain;
4191 SCIP_Bool fullpropagation;
4193 SCIP_Bool forcedlpsolve;
4194 SCIP_Bool wasforcedlpsolve;
4195 SCIP_Bool pricingaborted;
4215 *infeasible =
FALSE;
4217 *afternodeheur =
FALSE;
4219 pricingaborted =
FALSE;
4243 focusnodehaslp = (
set->lp_solvedepth == -1 || actdepth <=
set->lp_solvedepth);
4244 focusnodehaslp = focusnodehaslp && (
set->lp_solvefreq >= 1 && actdepth %
set->lp_solvefreq == 0);
4245 focusnodehaslp = focusnodehaslp || (actdepth == 0 &&
set->lp_solvefreq == 0);
4261 initiallpsolved =
FALSE;
4262 fullseparation =
TRUE;
4267 solverelaxagain =
TRUE;
4268 solvelpagain =
TRUE;
4269 propagateagain =
TRUE;
4270 fullpropagation =
TRUE;
4271 forcedlpsolve =
FALSE;
4274 while( !(*
cutoff) && !(*postpone) && (solverelaxagain || solvelpagain || propagateagain) && nlperrors <
MAXNLPERRORS && !(*restart) )
4277 SCIP_Bool solverelax;
4280 SCIP_Bool forcedenforcement;
4281 SCIP_Bool relaxcalled;
4286 *infeasible =
FALSE;
4292 relaxcalled =
FALSE;
4293 forcedenforcement =
FALSE;
4294 afterlpproplps = -1L;
4296 while( !
lperror && !(*
cutoff) && (propagateagain || solvelpagain || solverelaxagain
4297 || (afterlpproplps < stat->nnodelps && lpsolved) || relaxcalled) )
4299 solverelax = solverelaxagain;
4300 solverelaxagain =
FALSE;
4301 solvelp = solvelpagain;
4302 solvelpagain =
FALSE;
4304 propagateagain =
FALSE;
4307 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4308 conflict, cliquetable,
cutoff) );
4311 SCIPsetDebugMsg(
set,
" -> node solving loop: call propagators that are applicable before%s LP is solved\n",
4312 lpsolved ?
" and after" :
"");
4313 SCIP_CALL(
propAndSolve(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,
4314 relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,
4315 eventqueue, cliquetable, focusnode, actdepth,
propagate, solvelp, solverelax, forcedlpsolve, initiallpsolved,
4316 fullseparation, &afterlpproplps, &heurtiming, &nlperrors, &fullpropagation, &propagateagain, &lpsolved, &relaxcalled,
4317 &solvelpagain, &solverelaxagain,
cutoff, postpone, unbounded, stopped, &
lperror, &pricingaborted, &forcedenforcement) );
4318 initiallpsolved |= lpsolved;
4328 fullseparation =
FALSE;
4340 if( actdepth == 0 && !(*afternodeheur) )
4344 *afternodeheur =
TRUE;
4349 *
cutoff, &foundsol, unbounded) );
4354 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4397 if( foundsol && !(*
cutoff) )
4399 propagateagain =
TRUE;
4400 solvelpagain =
TRUE;
4401 solverelaxagain =
TRUE;
4412 if( !(*postpone) && !(*restart) && !(*
cutoff) && !solverelaxagain && !solvelpagain && !propagateagain )
4423 *infeasible =
FALSE;
4427 SCIP_CALL(
enforceConstraints(blkmem,
set, messagehdlr, stat, transprob, primal, tree, lp, relaxation, sepastore,
4428 branchcand, &branched,
cutoff, infeasible, &propagateagain, &solvelpagain, &solverelaxagain,
4429 forcedenforcement) );
4431 assert(!branched || (!(*
cutoff) && *infeasible && !propagateagain && !solvelpagain));
4432 assert(!(*
cutoff) || (!branched && *infeasible && !propagateagain && !solvelpagain));
4433 assert(*infeasible || (!branched && !(*
cutoff) && !propagateagain && !solvelpagain));
4434 assert(!propagateagain || (!branched && !(*
cutoff) && *infeasible));
4435 assert(!solvelpagain || (!branched && !(*
cutoff) && *infeasible));
4440 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4442 &solvelpagain, &solverelaxagain) );
4445 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4457 if( pricingaborted && !(*infeasible) && !(*
cutoff) && !(*postpone) && !(*restart) )
4471 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4491 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4519 wasforcedlpsolve = forcedlpsolve;
4520 forcedlpsolve =
FALSE;
4521 if( (*infeasible) && !(*
cutoff) && !(*postpone) && !(*restart)
4523 && !solverelaxagain && !solvelpagain && !propagateagain && !branched )
4545 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on LP solution with %d fractionals\n",
4547 SCIP_CALL(
SCIPbranchExecLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4558 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on %d external branching candidates.\n",
4560 SCIP_CALL(
SCIPbranchExecExtern(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4569 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on pseudo solution with %d unfixed integers\n",
4571 SCIP_CALL(
SCIPbranchExecPseudo(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
4585 "Starting spatial branch-and-bound on unbounded variable <%s> ([%g,%g]) - cannot guarantee finite termination.\n",
4602 SCIPerrorMessage(
"LP branching rule added constraint, which was not allowed this time\n");
4605 propagateagain =
TRUE;
4606 solvelpagain =
TRUE;
4607 solverelaxagain =
TRUE;
4612 propagateagain =
TRUE;
4613 solvelpagain =
TRUE;
4614 solverelaxagain =
TRUE;
4620 solvelpagain =
TRUE;
4621 solverelaxagain =
TRUE;
4645 if( transprob->
ncontvars == 0 &&
set->nactivepricers == 0 )
4648 SCIPsetDebugMsg(
set,
" -> cutoff because all variables are fixed in current node\n");
4674 if( pricingaborted )
4676 SCIPerrorMessage(
"pricing was aborted, but no branching could be created!\n");
4680 if( wasforcedlpsolve )
4683 SCIPerrorMessage(
"LP was solved, all integers fixed, some constraint still infeasible, but no branching could be created!\n");
4704 solvelpagain =
TRUE;
4705 forcedlpsolve =
TRUE;
4710 SCIPerrorMessage(
"invalid result code <%d> from SCIPbranchLP(), SCIPbranchExt() or SCIPbranchPseudo()\n",
result);
4713 assert(*
cutoff || solvelpagain || propagateagain || branched);
4714 assert(!(*
cutoff) || (!solvelpagain && !propagateagain && !branched));
4717 assert(!branched || (!solvelpagain && !propagateagain));
4721 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4723 &solvelpagain, &solverelaxagain) );
4726 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4737 SCIPsetDebugMsg(
set,
"node solving iteration %d finished: cutoff=%u, postpone=%u, propagateagain=%u, solverelaxagain=%u, solvelpagain=%u, nlperrors=%d, restart=%u\n",
4738 nloops, *
cutoff, *postpone, propagateagain, solverelaxagain, solvelpagain, nlperrors, *restart);
4744 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
4754 restartfac =
set->presol_subrestartfac;
4756 restartfac =
MIN(restartfac,
set->presol_restartfac);
4762 if( actdepth == 0 && !(*
cutoff) && !(*unbounded) && !(*postpone) )
4839 if( checksol ||
set->misc_exactsolve )
4842 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4847 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4848 eventqueue, eventfilter, &
sol, &foundsol) );
4877 if( checksol ||
set->misc_exactsolve )
4880 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4885 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4886 eventqueue, eventfilter, &
sol, &foundsol) );
4913 if( checksol ||
set->misc_exactsolve )
4916 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4921 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4922 eventqueue, eventfilter, &
sol, &foundsol) );
4974 SCIP_Real restartfac;
4975 SCIP_Real restartconfnum;
4980 SCIP_Bool unbounded;
4981 SCIP_Bool infeasible;
5001 restartfac =
set->presol_subrestartfac;
5003 restartfac =
MIN(restartfac,
set->presol_restartfac);
5009 if(
set->conf_restartnum > 0 )
5015 restartconfnum *=
set->conf_restartfac;
5019 assert(restartconfnum >= 0.0);
5031 SCIP_Longint nsuccessconflicts;
5032 SCIP_Bool afternodeheur;
5057 if( nextnode ==
NULL )
5062 focusnode = nextnode;
5070 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt,
5071 lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5086 if( focusnode ==
NULL )
5109 SCIP_CALL(
solveNode(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,
5110 pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,
5111 cliquetable, &
cutoff, &postpone, &unbounded, &infeasible, restart, &afternodeheur, &stopped) );
5123 if( !(*restart) && !postpone )
5166 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,
5167 lp, eventqueue, eventfilter,
FALSE) );
5170 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &
cutoff) );
5180 if(
set->reopt_enable )
5189 else if( !unbounded || branched )
5210 if(
set->reopt_enable )
5232 if(
set->reopt_enable )
5269 SCIPerrorMessage(
"cannot branch on all-fixed LP -- have to call PerPlex instead\n");
5292 if( !afternodeheur && (!
cutoff ||
nnodes > 0) && !stopped )
5295 cutoff, &foundsol, &unbounded) );
5309 else if( !infeasible && !postpone )
5315 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,
5316 eventqueue, eventfilter,
TRUE) );
5318 if(
set->reopt_enable )
5332 SCIP_CALL(
SCIPnodeFocus(&newfocusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5333 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
TRUE,
FALSE) );
5358 "(run %d, node %" SCIP_LONGINT_FORMAT ") restarting: triggering parameter controlled restart)\n",
5376 SCIPsetDebugMsg(
set,
"**********************************************************************\n");
5402 if(
set->reopt_enable )
5411 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5412 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5424 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
internal methods for conflict analysis
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
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)
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_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)
#define SCIP_LONGINT_FORMAT
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_OBJSENSE SCIPgetObjsense(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 SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Real SCIPgetDualbound(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)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
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_Real SCIPsetGetSepaMaxcutsGenFactor(SCIP_SET *set, SCIP_Bool root)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
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)
unsigned int boundchgtype
SCIP_BRANCHINGDATA branchingdata
SCIP_BOUNDCHG * boundchgs
union SCIP_Node::@19 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_PRIMALLIMIT
@ 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)