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,
1215 oldnvars = transprob->
nvars;
1222 for( v = 0; v < transprob->
nvars; ++v )
1253 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
1254 eventfilter, cliquetable, root,
TRUE,
cutoff) );
1260 if( root && transprob->
nvars > oldnvars )
1266 for( v = 0; v < transprob->
nvars; ++v )
1310 SCIP_Bool newinitconss,
1314 SCIP_Bool initroot =
FALSE;
1351 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1366 SCIP_CALL(
initLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,
1367 eventqueue, eventfilter, cliquetable, initroot,
cutoff) );
1370 else if( newinitconss )
1373 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
1470 SCIP_Bool newinitconss,
1476 SCIP_Real starttime = 0.0;
1492 SCIP_CALL(
SCIPconstructCurrentLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,
1493 branchcand, eventqueue, eventfilter, cliquetable, newinitconss,
cutoff) );
1504 if( focusnode->
depth == 0 )
1553 SCIP_Real lowerbound;
1558 if(
set->misc_exactsolve )
1587 SCIP_Bool* mustsepa,
1588 SCIP_Bool* mustprice
1601 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob,
set->lp_iterlim,
FALSE,
TRUE,
FALSE,
lperror) );
1629 SCIP_Real bounddist,
1630 SCIP_Bool allowlocal,
1631 SCIP_Bool onlydelayed,
1633 SCIP_Bool* enoughcuts,
1636 SCIP_Bool* mustsepa,
1637 SCIP_Bool* mustprice
1642 SCIP_Bool consadded;
1653 root = (actdepth == 0);
1658 *enoughcuts =
FALSE;
1665 SCIPsetDebugMsg(
set,
"calling separators on LP solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1671 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1712 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1729 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1736 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1758 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1776 for(
i = 0;
i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1807 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1829 for(
i = 0;
i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved
1833 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1855 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp,
lperror, mustsepa, mustprice) );
1864 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, lpflushed=%u, cutoff=%u\n",
1879 SCIP_Bool allowlocal,
1880 SCIP_Bool onlydelayed,
1882 SCIP_Bool* enoughcuts,
1888 SCIP_Bool consadded;
1898 *enoughcuts =
FALSE;
1900 root = (actdepth == 0);
1902 SCIPsetDebugMsg(
set,
"calling separators on primal solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
2044 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, cutoff=%u\n",
2045 *delayed, *enoughcuts, *
cutoff);
2065 SCIP_Bool allowlocal,
2066 SCIP_Bool onlydelayed,
2071 SCIP_Bool enoughcuts;
2084 SCIP_Bool mustprice;
2090 SCIP_CALL(
separationRoundLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, \
2091 actdepth, 0.0, allowlocal, onlydelayed, delayed, &enoughcuts,
cutoff, \
2092 &
lperror, &mustsepa, &mustprice) );
2097 SCIP_CALL(
separationRoundSol(blkmem,
set, stat, sepastore,
sol, actdepth, allowlocal, onlydelayed, delayed, &enoughcuts,
cutoff) );
2122 SCIP_Bool pretendroot,
2123 SCIP_Bool displayinfo,
2126 int* npricedcolvars,
2127 SCIP_Bool* mustsepa,
2135 SCIP_Bool mustprice;
2137 SCIP_Bool unbounded;
2150 *npricedcolvars = transprob->
ncolvars;
2163 if( maxpricerounds == -1 )
2164 maxpricerounds = INT_MAX;
2168 while( !(*
lperror) && mustprice && npricerounds < maxpricerounds )
2170 SCIP_Bool enoughvars;
2174 SCIP_Bool stopearly;
2175 SCIP_Bool stoppricing;
2195 FALSE, &foundsol, &unbounded) );
2202 *npricedcolvars = transprob->
ncolvars;
2213 stoppricing =
FALSE;
2214 for( p = 0; p <
set->nactivepricers && !enoughvars; ++p )
2225 if( p == 0 && stopearly )
2229 if( stoppricing && !stopearly )
2230 stoppricing =
FALSE;
2242 *mustsepa = *mustsepa || !lp->
flushed;
2248 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
TRUE,
FALSE,
lperror) );
2260 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2264 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != *npricedcolvars);
2265 *mustsepa = *mustsepa || !lp->
flushed;
2276 SCIPsetDebugMsg(
set,
"pricing: solve LP after resetting bounds and adding new initial constraints\n");
2277 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
2289 if( displayinfo && mustprice )
2299 mustprice = mustprice &&
2330 SCIP_Bool cutpoolisdelayed,
2333 SCIP_Bool* enoughcuts,
2337 if( (
set->sepa_poolfreq == 0 && actdepth == 0)
2338 || (
set->sepa_poolfreq > 0 && actdepth %
set->sepa_poolfreq == 0) )
2342 SCIP_CALL(
SCIPcutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
NULL, cutpoolisdelayed, root, &
result) );
2383 SCIP_Bool fullseparation,
2384 SCIP_Bool* propagateagain,
2386 SCIP_Bool* unbounded,
2388 SCIP_Bool* pricingaborted
2396 SCIP_Real loclowerbound;
2397 SCIP_Real glblowerbound;
2398 SCIP_Real bounddist;
2399 SCIP_Real stalllpobjval;
2401 SCIP_Bool mustprice;
2403 SCIP_Bool delayedsepa;
2405 SCIP_Bool allowlocal;
2407 int nsepastallrounds;
2408 int maxnsepastallrounds;
2432 root = (actdepth == 0);
2438 bounddist = (loclowerbound - glblowerbound)/(primal->
cutoffbound - glblowerbound);
2440 separate = (
set->sepa_maxruns == -1 || stat->
nruns <
set->sepa_maxruns);
2443 maxseparounds = (root ?
set->sepa_maxroundsroot :
set->sepa_maxrounds);
2444 if( maxseparounds == -1 )
2445 maxseparounds = INT_MAX;
2446 if( stat->
nruns > 1 && root &&
set->sepa_maxroundsrootsubrun >= 0 )
2447 maxseparounds =
MIN(maxseparounds,
set->sepa_maxroundsrootsubrun);
2448 if( !fullseparation &&
set->sepa_maxaddrounds >= 0 )
2450 maxnsepastallrounds = root ?
set->sepa_maxstallroundsroot :
set->sepa_maxstallrounds;
2451 if( maxnsepastallrounds == -1 )
2452 maxnsepastallrounds = INT_MAX;
2465 npricedcolvars = transprob->
ncolvars;
2467 mustsepa = separate;
2468 delayedsepa =
FALSE;
2471 nsepastallrounds = 0;
2474 stallnfracs = INT_MAX;
2476 while( !(*
cutoff) && !(*unbounded) && !(*
lperror) && (mustprice || mustsepa || delayedsepa) )
2483 while( mustprice && !(*
lperror) )
2485 SCIP_CALL(
SCIPpriceLoop(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2486 pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &npricedcolvars,
2487 &mustsepa,
lperror, pricingaborted) );
2523 SCIP_Longint oldnboundchgs;
2524 SCIP_Longint oldninitconssadded;
2530 SCIPsetDebugMsg(
set,
" -> LP solved: call propagators that are applicable during LP solving loop\n");
2541 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2545 if( !(*
cutoff) && !(*unbounded) )
2569 *propagateagain =
TRUE;
2577 *propagateagain =
TRUE;
2605 FALSE, &foundsol, unbounded) );
2617 && nsepastallrounds < maxnsepastallrounds
2621 delayedsepa = delayedsepa && !mustsepa && !(*cutoff);
2622 mustsepa = mustsepa || delayedsepa;
2630 if( !separate || (*
cutoff) || (*unbounded)
2636 delayedsepa =
FALSE;
2645 SCIP_Longint olddomchgcount;
2646 SCIP_Longint oldninitconssadded;
2647 SCIP_Bool enoughcuts;
2662 if( !enoughcuts && !delayedsepa )
2664 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2665 actdepth, &enoughcuts,
cutoff) );
2678 if( !(*
cutoff) && !enoughcuts )
2685 lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2686 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2692 && nsepastallrounds >= maxnsepastallrounds-1 && delayedsepa )
2695 tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2696 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2704 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2705 actdepth, &enoughcuts,
cutoff) );
2717 root, actdepth, &enoughcuts,
cutoff) );
2732 tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2733 &delayedsepa, &enoughcuts,
cutoff,
lperror, &mustsepa, &mustprice) );
2742 root, actdepth, &enoughcuts,
cutoff) );
2778 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != npricedcolvars);
2779 mustsepa = mustsepa || !lp->
flushed;
2786 *propagateagain =
TRUE;
2801 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2827 if( stat->
domchgcount != olddomchgcount && (!mustprice || mustsepa) && !(*
cutoff)
2850 SCIP_Real objreldiff;
2857 objreldiff =
SCIPrelDiff(lpobjval, stalllpobjval);
2859 stalllpobjval, lpobjval, objreldiff);
2862 objreldiff <= 1e-04 &&
2863 nfracs >= (0.9 - 0.1 * nsepastallrounds) * stallnfracs);
2865 stalllpobjval = lpobjval;
2866 stallnfracs = nfracs;
2875 nsepastallrounds = 0;
2885 if( nsepastallrounds >= maxnsepastallrounds-2 )
2887 SCIPsetDebugMsg(
set,
" -> nsepastallrounds=%d/%d\n", nsepastallrounds, maxnsepastallrounds);
2894 SCIPsetDebugMsg(
set,
"separation round %d/%d finished (%d/%d stall rounds): mustprice=%u, mustsepa=%u, delayedsepa=%u, propagateagain=%u\n",
2895 stat->
nseparounds, maxseparounds, nsepastallrounds, maxnsepastallrounds, mustprice, mustsepa, delayedsepa, *propagateagain);
2902 if( root && nsepastallrounds >= maxnsepastallrounds )
2905 "Truncate separation round because of stalling (%d stall rounds).\n", maxnsepastallrounds);
2943 lp, branchcand, eventqueue, cliquetable,
NULL) );
2996 SCIP_Real pseudoobjval;
3004 SCIPsetDebugMsg(
set,
" -> lower bound: %g [%g] (pseudoobj: %g [%g]), cutoff bound: %g [%g]\n",
3016 SCIP_CALL(
SCIPconflictAnalyzePseudo(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable,
NULL) );
3040 for(
r = 0;
r <
set->nrelaxs; ++
r )
3069 SCIP_Bool initiallpsolved,
3070 SCIP_Bool fullseparation,
3071 SCIP_Bool newinitconss,
3072 SCIP_Bool* propagateagain,
3073 SCIP_Bool* solverelaxagain,
3075 SCIP_Bool* unbounded,
3077 SCIP_Bool* pricingaborted
3083 SCIP_Longint nzeroitlps;
3099 if( !initiallpsolved )
3102 SCIP_CALL(
solveNodeInitialLP(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
3103 pricestore, sepastore, cutpool, branchcand, eventfilter, eventqueue, cliquetable, newinitconss,
cutoff,
lperror) );
3122 SCIP_Bool checklprows;
3130 checklprows =
FALSE;
3136 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3143 SCIP_CALL(
SCIPsolCheck(
sol,
set, messagehdlr, blkmem, stat, transprob,
FALSE,
FALSE,
TRUE,
TRUE,
3144 checklprows, &feasible) );
3150 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
3163 if(
set->reopt_enable )
3179 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
3185 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
3202 SCIP_Longint oldninitconssadded;
3203 SCIP_Longint oldnboundchgs;
3204 SCIP_Longint olddomchgcount;
3206 int oldncutsapplied;
3208 oldnpricedvars = transprob->
ncolvars;
3215 SCIP_CALL(
priceAndCutLoop(blkmem,
set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
3216 pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,
3217 eventqueue, cliquetable, fullseparation, propagateagain,
cutoff, unbounded,
lperror, pricingaborted) );
3224 *solverelaxagain =
TRUE;
3241 SCIP_Real tmpcutoff;
3248 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE,
lperror) );
3253 SCIPsetDebugMsg(
set,
"re-optimized LP without cutoff bound: LP status: %d, LP obj: %g\n",
3300 SCIP_Bool* propagateagain,
3301 SCIP_Bool* solvelpagain,
3302 SCIP_Bool* solverelaxagain,
3304 SCIP_Bool* relaxcalled
3309 SCIP_Real lowerbound;
3324 for(
r = 0;
r <
set->nrelaxs && !(*cutoff); ++
r )
3329 *relaxcalled =
TRUE;
3344 *solvelpagain =
TRUE;
3345 *propagateagain =
TRUE;
3349 *solvelpagain =
TRUE;
3350 *propagateagain =
TRUE;
3354 *solvelpagain =
TRUE;
3358 *solverelaxagain =
TRUE;
3402 SCIP_Bool* branched,
3404 SCIP_Bool* infeasible,
3405 SCIP_Bool* propagateagain,
3406 SCIP_Bool* solvelpagain,
3407 SCIP_Bool* solverelaxagain,
3413 SCIP_Real pseudoobjval;
3415 SCIP_Bool objinfeasible;
3416 SCIP_Bool enforcerelaxsol;
3430 assert(!(*propagateagain));
3431 assert(!(*solvelpagain));
3432 assert(!(*solverelaxagain));
3442 for(
h = 0;
h <
set->nconshdlrs && enforcerelaxsol; ++
h )
3444 if(
set->conshdlrs_enfo[
h]->consenforelax ==
NULL && ((!
set->conshdlrs_enfo[
h]->needscons) ||
3445 (
set->conshdlrs_enfo[
h]->nconss > 0)) )
3449 enforcerelaxsol =
FALSE;
3463 " since constraint handler %s does not implement enforelax-callback\n",
3472 if( enforcerelaxsol )
3484 objinfeasible =
FALSE;
3504 if( enforcerelaxsol )
3509 for(
h = 0;
h <
set->nconshdlrs && !resolved; ++
h )
3514 if( enforcerelaxsol )
3519 relaxsol, *infeasible, &
result) );
3534 objinfeasible, forced, &
result) );
3537 SCIPerrorMessage(
"pseudo enforcing method of constraint handler <%s> separated cuts\n",
3558 *propagateagain =
TRUE;
3559 *solvelpagain =
TRUE;
3560 *solverelaxagain =
TRUE;
3568 *propagateagain =
TRUE;
3569 *solvelpagain =
TRUE;
3570 *solverelaxagain =
TRUE;
3579 *solvelpagain =
TRUE;
3580 *solverelaxagain =
TRUE;
3604 *solvelpagain =
TRUE;
3631 SCIPerrorMessage(
"invalid result code <%d> from enforcing method of constraint handler <%s>\n",
3650 *propagateagain =
FALSE;
3651 *solvelpagain =
FALSE;
3654 assert(!(*branched) || (resolved && !(*
cutoff) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3655 assert(!(*
cutoff) || (resolved && !(*branched) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3656 assert(*infeasible || (!resolved && !(*branched) && !(*
cutoff) && !(*propagateagain) && !(*solvelpagain)));
3657 assert(!(*propagateagain) || (resolved && !(*branched) && !(*
cutoff) && *infeasible));
3658 assert(!(*solvelpagain) || (resolved && !(*branched) && !(*
cutoff) && *infeasible));
3660 assert(!objinfeasible || *infeasible);
3661 assert(resolved == (*branched || *
cutoff || *propagateagain || *solvelpagain));
3665 if( enforcerelaxsol )
3673 SCIPsetDebugMsg(
set,
" -> enforcing result: branched=%u, cutoff=%u, infeasible=%u, propagateagain=%u, solvelpagain=%u, resolved=%u\n",
3674 *branched, *
cutoff, *infeasible, *propagateagain, *solvelpagain, resolved);
3699 SCIP_Bool* propagateagain,
3700 SCIP_Bool* solvelpagain,
3701 SCIP_Bool* solverelaxagain
3716 SCIP_Longint olddomchgcount;
3717 int oldncutsapplied;
3721 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
3722 eventqueue, eventfilter, cliquetable, root, efficiacychoice,
cutoff) );
3723 *propagateagain = *propagateagain || (stat->
domchgcount != olddomchgcount);
3724 *solvelpagain =
TRUE;
3727 *solverelaxagain =
TRUE;
3743 SCIP_Bool* propagateagain,
3744 SCIP_Bool* solverelaxagain
3767 for(
r = 0;
r <
set->nrelaxs && !(*solverelaxagain); ++
r )
3773 *propagateagain =
FALSE;
3774 *solverelaxagain =
FALSE;
3807 SCIP_Bool solverelax,
3808 SCIP_Bool forcedlpsolve,
3809 SCIP_Bool initiallpsolved,
3810 SCIP_Bool fullseparation,
3811 SCIP_Longint* afterlpproplps,
3814 SCIP_Bool* fullpropagation,
3815 SCIP_Bool* propagateagain,
3816 SCIP_Bool* lpsolved,
3817 SCIP_Bool* relaxcalled,
3818 SCIP_Bool* solvelpagain,
3819 SCIP_Bool* solverelaxagain,
3821 SCIP_Bool* postpone,
3822 SCIP_Bool* unbounded,
3825 SCIP_Bool* pricingaborted,
3826 SCIP_Bool* forcedenforcement
3829 SCIP_Bool newinitconss;
3864 newinitconss =
FALSE;
3866 if( !(*
cutoff) && !(*postpone) )
3868 SCIP_Longint oldninitconssadded;
3869 SCIP_Longint oldnboundchgs;
3870 SCIP_Bool lpwasflushed;
3877 if( ((*afterlpproplps) < stat->
nnodelps && (*lpsolved)) || (*relaxcalled) )
3898 *fullpropagation =
FALSE;
3906 solvelp = solvelp || (lpwasflushed && (!lp->
flushed || newinitconss));
3907 solverelax = solverelax || newinitconss;
3937 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
3938 conflict, cliquetable,
cutoff) );
3952 FALSE, propagateagain, unbounded) );
3981 if( *propagateagain )
3983 *solvelpagain = solvelp;
3984 *solverelaxagain = solverelax;
3991 *relaxcalled =
FALSE;
3992 if( solverelax && !(*
cutoff) )
3998 cutoff, propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
4005 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4007 solvelpagain, solverelaxagain) );
4010 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4021 SCIP_CALL(
solveNodeLP(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
4022 sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,
4023 initiallpsolved, fullseparation, newinitconss, propagateagain, solverelaxagain,
cutoff, unbounded,
lperror, pricingaborted) );
4026 *solvelpagain =
FALSE;
4054 *forcedenforcement =
TRUE;
4084 *forcedenforcement =
TRUE;
4093 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
4102 *solverelaxagain = *solverelaxagain && *relaxcalled;
4105 if( solverelax && !(*
cutoff) )
4108 propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
4115 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4117 solvelpagain, solverelaxagain) );
4120 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
4139 return set->nactivepricers == 0 && !
set->reopt_enable
4140 && (
set->presol_maxrestarts == -1 || stat->
nruns <=
set->presol_maxrestarts );
4143#define restartAllowed(set,stat) ((set)->nactivepricers == 0 && !set->reopt_enable && ((set)->presol_maxrestarts == -1 || (stat)->nruns <= (set)->presol_maxrestarts))
4172 SCIP_Bool* postpone,
4173 SCIP_Bool* unbounded,
4174 SCIP_Bool* infeasible,
4176 SCIP_Bool* afternodeheur,
4181 SCIP_Longint lastdomchgcount;
4182 SCIP_Longint afterlpproplps;
4183 SCIP_Real restartfac;
4184 SCIP_Longint lastlpcount;
4190 SCIP_Bool focusnodehaslp;
4192 SCIP_Bool initiallpsolved;
4193 SCIP_Bool fullseparation;
4194 SCIP_Bool solverelaxagain;
4195 SCIP_Bool solvelpagain;
4196 SCIP_Bool propagateagain;
4197 SCIP_Bool fullpropagation;
4199 SCIP_Bool forcedlpsolve;
4200 SCIP_Bool wasforcedlpsolve;
4201 SCIP_Bool pricingaborted;
4221 *infeasible =
FALSE;
4223 *afternodeheur =
FALSE;
4225 pricingaborted =
FALSE;
4249 focusnodehaslp = (
set->lp_solvedepth == -1 || actdepth <=
set->lp_solvedepth);
4250 focusnodehaslp = focusnodehaslp && (
set->lp_solvefreq >= 1 && actdepth %
set->lp_solvefreq == 0);
4251 focusnodehaslp = focusnodehaslp || (actdepth == 0 &&
set->lp_solvefreq == 0);
4267 initiallpsolved =
FALSE;
4268 fullseparation =
TRUE;
4273 solverelaxagain =
TRUE;
4274 solvelpagain =
TRUE;
4275 propagateagain =
TRUE;
4276 fullpropagation =
TRUE;
4277 forcedlpsolve =
FALSE;
4280 while( !(*
cutoff) && !(*postpone) && (solverelaxagain || solvelpagain || propagateagain) && nlperrors <
MAXNLPERRORS && !(*restart) )
4283 SCIP_Bool solverelax;
4286 SCIP_Bool forcedenforcement;
4287 SCIP_Bool relaxcalled;
4292 *infeasible =
FALSE;
4298 relaxcalled =
FALSE;
4299 forcedenforcement =
FALSE;
4300 afterlpproplps = -1L;
4302 while( !
lperror && !(*
cutoff) && (propagateagain || solvelpagain || solverelaxagain
4303 || (afterlpproplps < stat->nnodelps && lpsolved) || relaxcalled) )
4305 solverelax = solverelaxagain;
4306 solverelaxagain =
FALSE;
4307 solvelp = solvelpagain;
4308 solvelpagain =
FALSE;
4310 propagateagain =
FALSE;
4313 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4314 conflict, cliquetable,
cutoff) );
4317 SCIPsetDebugMsg(
set,
" -> node solving loop: call propagators that are applicable before%s LP is solved\n",
4318 lpsolved ?
" and after" :
"");
4319 SCIP_CALL(
propAndSolve(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,
4320 relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,
4321 eventqueue, cliquetable, focusnode, actdepth,
propagate, solvelp, solverelax, forcedlpsolve, initiallpsolved,
4322 fullseparation, &afterlpproplps, &heurtiming, &nlperrors, &fullpropagation, &propagateagain, &lpsolved, &relaxcalled,
4323 &solvelpagain, &solverelaxagain,
cutoff, postpone, unbounded, stopped, &
lperror, &pricingaborted, &forcedenforcement) );
4324 initiallpsolved |= lpsolved;
4334 fullseparation =
FALSE;
4346 if( actdepth == 0 && !(*afternodeheur) )
4350 *afternodeheur =
TRUE;
4355 *
cutoff, &foundsol, unbounded) );
4360 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4403 if( foundsol && !(*
cutoff) )
4405 propagateagain =
TRUE;
4406 solvelpagain =
TRUE;
4407 solverelaxagain =
TRUE;
4418 if( !(*postpone) && !(*restart) && !(*
cutoff) && !solverelaxagain && !solvelpagain && !propagateagain )
4429 *infeasible =
FALSE;
4433 SCIP_CALL(
enforceConstraints(blkmem,
set, messagehdlr, stat, transprob, primal, tree, lp, relaxation, sepastore,
4434 branchcand, &branched,
cutoff, infeasible, &propagateagain, &solvelpagain, &solverelaxagain,
4435 forcedenforcement) );
4437 assert(!branched || (!(*
cutoff) && *infeasible && !propagateagain && !solvelpagain));
4438 assert(!(*
cutoff) || (!branched && *infeasible && !propagateagain && !solvelpagain));
4439 assert(*infeasible || (!branched && !(*
cutoff) && !propagateagain && !solvelpagain));
4440 assert(!propagateagain || (!branched && !(*
cutoff) && *infeasible));
4441 assert(!solvelpagain || (!branched && !(*
cutoff) && *infeasible));
4446 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4448 &solvelpagain, &solverelaxagain) );
4451 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4463 if( pricingaborted && !(*infeasible) && !(*
cutoff) && !(*postpone) && !(*restart) )
4477 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4497 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4525 wasforcedlpsolve = forcedlpsolve;
4526 forcedlpsolve =
FALSE;
4527 if( (*infeasible) && !(*
cutoff) && !(*postpone) && !(*restart)
4529 && !solverelaxagain && !solvelpagain && !propagateagain && !branched )
4551 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on LP solution with %d fractionals\n",
4553 SCIP_CALL(
SCIPbranchExecLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4564 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on %d external branching candidates.\n",
4566 SCIP_CALL(
SCIPbranchExecExtern(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4575 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on pseudo solution with %d unfixed integers\n",
4577 SCIP_CALL(
SCIPbranchExecPseudo(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
4591 "Starting spatial branch-and-bound on unbounded variable <%s> ([%g,%g]) - cannot guarantee finite termination.\n",
4608 SCIPerrorMessage(
"LP branching rule added constraint, which was not allowed this time\n");
4611 propagateagain =
TRUE;
4612 solvelpagain =
TRUE;
4613 solverelaxagain =
TRUE;
4618 propagateagain =
TRUE;
4619 solvelpagain =
TRUE;
4620 solverelaxagain =
TRUE;
4626 solvelpagain =
TRUE;
4627 solverelaxagain =
TRUE;
4651 if( transprob->
ncontvars == 0 &&
set->nactivepricers == 0 )
4654 SCIPsetDebugMsg(
set,
" -> cutoff because all variables are fixed in current node\n");
4680 if( pricingaborted )
4682 SCIPerrorMessage(
"pricing was aborted, but no branching could be created!\n");
4686 if( wasforcedlpsolve )
4689 SCIPerrorMessage(
"LP was solved, all integers fixed, some constraint still infeasible, but no branching could be created!\n");
4710 solvelpagain =
TRUE;
4711 forcedlpsolve =
TRUE;
4716 SCIPerrorMessage(
"invalid result code <%d> from SCIPbranchLP(), SCIPbranchExt() or SCIPbranchPseudo()\n",
result);
4719 assert(*
cutoff || solvelpagain || propagateagain || branched);
4720 assert(!(*
cutoff) || (!solvelpagain && !propagateagain && !branched));
4723 assert(!branched || (!solvelpagain && !propagateagain));
4727 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4729 &solvelpagain, &solverelaxagain) );
4732 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable,
cutoff) );
4743 SCIPsetDebugMsg(
set,
"node solving iteration %d finished: cutoff=%u, postpone=%u, propagateagain=%u, solverelaxagain=%u, solvelpagain=%u, nlperrors=%d, restart=%u\n",
4744 nloops, *
cutoff, *postpone, propagateagain, solverelaxagain, solvelpagain, nlperrors, *restart);
4750 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
4760 restartfac =
set->presol_subrestartfac;
4762 restartfac =
MIN(restartfac,
set->presol_restartfac);
4768 if( actdepth == 0 && !(*
cutoff) && !(*unbounded) && !(*postpone) )
4842 if( checksol ||
set->misc_exactsolve )
4845 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4850 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4851 eventqueue, eventfilter, &
sol, &foundsol) );
4880 if( checksol ||
set->misc_exactsolve )
4883 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4888 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4889 eventqueue, eventfilter, &
sol, &foundsol) );
4916 if( checksol ||
set->misc_exactsolve )
4919 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4924 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4925 eventqueue, eventfilter, &
sol, &foundsol) );
4977 SCIP_Real restartfac;
4978 SCIP_Real restartconfnum;
4983 SCIP_Bool unbounded;
4984 SCIP_Bool infeasible;
5004 restartfac =
set->presol_subrestartfac;
5006 restartfac =
MIN(restartfac,
set->presol_restartfac);
5012 if(
set->conf_restartnum > 0 )
5018 restartconfnum *=
set->conf_restartfac;
5022 assert(restartconfnum >= 0.0);
5034 SCIP_Longint nsuccessconflicts;
5035 SCIP_Bool afternodeheur;
5060 if( nextnode ==
NULL )
5065 focusnode = nextnode;
5073 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt,
5074 lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5089 if( focusnode ==
NULL )
5112 SCIP_CALL(
solveNode(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,
5113 pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,
5114 cliquetable, &
cutoff, &postpone, &unbounded, &infeasible, restart, &afternodeheur, &stopped) );
5126 if( !(*restart) && !postpone )
5169 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,
5170 lp, eventqueue, eventfilter,
FALSE) );
5179 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &
cutoff) );
5185 if(
set->reopt_enable )
5194 else if( !unbounded || branched )
5215 if(
set->reopt_enable )
5237 if(
set->reopt_enable )
5274 SCIPerrorMessage(
"cannot branch on all-fixed LP -- have to call PerPlex instead\n");
5297 if( !afternodeheur && (!
cutoff ||
nnodes > 0) && !stopped )
5300 cutoff, &foundsol, &unbounded) );
5314 else if( !infeasible && !postpone )
5320 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,
5321 eventqueue, eventfilter,
TRUE) );
5323 if(
set->reopt_enable )
5337 SCIP_CALL(
SCIPnodeFocus(&newfocusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5338 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
TRUE,
FALSE) );
5363 "(run %d, node %" SCIP_LONGINT_FORMAT ") restarting: triggering parameter controlled restart)\n",
5381 SCIPsetDebugMsg(
set,
"**********************************************************************\n");
5407 if(
set->reopt_enable )
5416 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5417 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5429 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 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 SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsDualfeasLT(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)
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::@314101335070107373341204020356162321174046011342 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_RETCODE SCIPnodeCutoff(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, BMS_BLKMEM *blkmem)
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)