63 #define MAXNLPERRORS 10 64 #define MAXNCLOCKSKIPS 64 65 #define NINITCALLS 1000L 66 #define SAFETYFACTOR 1e-2 90 if( set->limitchanged )
93 set->limitchanged =
FALSE;
103 else if( set->istimelimitfinite )
119 if( (
SAFETYFACTOR * (set->limit_time - currtime) / (avgisstoppedfreq + 1e-6)) < nclockskips )
128 if( currtime >= set->limit_time )
155 else if( checknodelimits && set->limit_nodes >= 0 && stat->
nnodes >= set->limit_nodes )
157 else if( checknodelimits && set->limit_totalnodes >= 0 && stat->
ntotalnodes >= set->limit_totalnodes )
159 else if( checknodelimits && set->limit_stallnodes >= 0 && stat->
nnodes >= stat->
bestsolnode + set->limit_stallnodes )
165 if( !checknodelimits )
193 int lpstateforkdepth;
201 assert(primal !=
NULL);
211 assert(foundsol !=
NULL);
233 heurtiming &= ~SCIP_HEURTIMING_AFTERNODE;
236 assert(nextnode ==
NULL 262 lpstateforkdepth = -1;
269 assert(tree !=
NULL);
273 SCIPsetDebugMsg(
set,
"calling primal heuristics in depth %d (timing: %u)\n", depth, heurtiming);
295 else if( lp !=
NULL )
300 for( h = 0; h <
set->nheurs; ++h )
316 SCIPsetDebugMsg(
set,
" -> executing heuristic <%s> with priority %d\n",
322 SCIP_CALL(
SCIPheurExec(set->heurs[h],
set, primal, depth, lpstateforkdepth, heurtiming, nodeinfeasible,
323 &ndelayedheurs, &result) );
350 assert(0 <= ndelayedheurs && ndelayedheurs <= set->nheurs);
380 assert(delayed !=
NULL);
381 assert(propagain !=
NULL);
382 assert(cutoff !=
NULL);
383 assert(postpone !=
NULL);
397 for( i = 0; i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
448 for( i = 0; i <
set->nconshdlrs && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
473 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in propagation\n",
486 for( i = 0; i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
549 assert(tree !=
NULL);
551 assert(cutoff !=
NULL);
554 assert(node !=
NULL);
561 if( maxproprounds == 0 )
562 maxproprounds = (depth == 0 ?
set->prop_maxroundsroot :
set->prop_maxrounds);
563 if( maxproprounds == -1 )
564 maxproprounds = INT_MAX;
566 SCIPsetDebugMsg(
set,
"domain propagation of node %p in depth %d (using depth %d, maxrounds %d, proptiming %u)\n",
574 while( propagain && !(*cutoff) && !(*postpone) && propround < maxproprounds && !
SCIPsolveIsStopped(
set, stat,
FALSE) )
579 SCIP_CALL(
propagationRound(blkmem,
set, stat, primal, tree, depth, fullpropagation,
FALSE, &delayed, &propagain, timingmask, cutoff, postpone) );
582 while( delayed && (!propagain || propround >= maxproprounds) && !(*cutoff) )
585 SCIP_CALL(
propagationRound(blkmem,
set, stat, primal, tree, depth, fullpropagation,
TRUE, &delayed, &propagain, timingmask, cutoff, postpone) );
591 fullpropagation =
TRUE;
599 SCIPsetDebugMsg(
set,
" --> domain propagation of node %p finished: cutoff!\n", (
void*)node);
629 SCIP_CALL(
propagateDomains(blkmem,
set, stat, primal, tree, depth, maxproprounds,
TRUE, timingmask, cutoff, &postpone) );
632 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
720 assert(tree !=
NULL);
727 assert(tree->
path[actdepth] == focusnode);
758 node = tree->
path[d];
767 for( i = 0; i < nboundchgs; ++i )
769 var = boundchgs[i].
var;
785 updates[nupdates] = &boundchgs[i];
808 weight = (nvalidupdates > 0 ? 1.0 / (
SCIP_Real)nvalidupdates : 1.0);
810 lpgain =
MAX(lpgain, 0.0);
812 for( i = 0; i < nupdates; ++i )
816 var = updates[i]->
var;
824 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s>: sol: %g -> %g, LP: %e -> %e => solvaldelta = %g, gain=%g, weight: %g\n",
859 assert(set->branch_lpgainnorm ==
'd' || set->branch_lpgainnorm ==
's');
863 if( set->branch_lpgainnorm ==
'd' )
865 assert(!updates[i]->redundant);
873 for( j = nbdchginfos-1; j >= 0; --j )
890 assert(updates[i]->redundant);
897 assert(j >= 0 || updates[i]->redundant);
907 delta = updates[i]->
newbound - oldbound;
920 for( j = nbdchginfos-1; j >= 0; --j )
937 assert(updates[i]->redundant);
944 assert(j >= 0 || updates[i]->redundant);
954 delta = updates[i]->
newbound - oldbound;
996 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s> with strategy %c: domain: [%g,%g] -> [%g,%g], LP: %e -> %e => " 997 "delta = %g, gain=%g, weight: %g\n",
1004 delta, lpgain, weight);
1044 assert(focusnode !=
NULL);
1059 for( i = 0; i < nlpcands; ++i )
1066 estimate +=
MIN(pscdown, pscup);
1096 assert(
set !=
NULL);
1098 assert(cutoff !=
NULL);
1107 for( h = 0; h <
set->nconshdlrs && !(*cutoff); ++h )
1112 if( set->reopt_enable && set->reopt_usecuts && firstsubtreeinit && !(*cutoff) )
1116 eventfilter, lp, root) );
1122 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1163 assert(
set !=
NULL);
1164 assert(transprob !=
NULL);
1166 assert(cutoff !=
NULL);
1183 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1185 var = transprob->
vars[v];
1209 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
1210 eventfilter, cliquetable, root,
TRUE, cutoff) );
1238 assert(tree !=
NULL);
1239 assert(cutoff !=
NULL);
1252 SCIP_CALL(
initLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,
1253 eventqueue, eventfilter, cliquetable, initroot, cutoff) );
1255 else if( newinitconss )
1258 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
1281 assert(blkmem !=
NULL);
1282 assert(
set !=
NULL);
1283 assert(stat !=
NULL);
1284 assert(prob !=
NULL);
1285 assert(primal !=
NULL);
1286 assert(tree !=
NULL);
1309 nvars = prob->
nvars;
1321 for( i = 0; i < nvars; i++ )
1365 assert(stat !=
NULL);
1366 assert(tree !=
NULL);
1368 assert(cutoff !=
NULL);
1369 assert(lperror !=
NULL);
1377 SCIP_CALL(
SCIPconstructCurrentLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,
1378 branchcand, eventqueue, eventfilter, cliquetable, newinitconss, cutoff) );
1389 if( focusnode->
depth == 0 )
1400 assert(lp->
solved || *lperror);
1442 if( set->misc_exactsolve )
1476 assert(lperror !=
NULL);
1477 assert(mustsepa !=
NULL);
1478 assert(mustprice !=
NULL);
1485 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, set->lp_iterlim,
FALSE,
TRUE,
FALSE, lperror) );
1487 assert(lp->
solved || *lperror);
1528 assert(
set !=
NULL);
1530 assert(set->conshdlrs_sepa !=
NULL);
1531 assert(delayed !=
NULL);
1532 assert(enoughcuts !=
NULL);
1533 assert(cutoff !=
NULL);
1534 assert(lperror !=
NULL);
1536 root = (actdepth == 0);
1542 SCIPsetDebugMsg(
set,
"calling separators on LP solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1548 for( i = 0; i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1562 SCIPsetDebugMsg(
set,
" -> executing separator <%s> with priority %d\n",
1580 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1597 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1604 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1617 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1627 SCIPsetDebugMsg(
set,
" -> delayed constraint handler <%s> found a cut\n",
1635 for( i = 0; i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1645 SCIPsetDebugMsg(
set,
" -> executing separator <%s> with priority %d\n",
1657 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1676 assert(!onlydelayed);
1679 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1683 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1696 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1705 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, lpflushed=%u, cutoff=%u\n",
1706 *delayed, *enoughcuts, lp->
flushed, *cutoff);
1731 assert(
set !=
NULL);
1732 assert(set->conshdlrs_sepa !=
NULL);
1733 assert(delayed !=
NULL);
1734 assert(enoughcuts !=
NULL);
1735 assert(cutoff !=
NULL);
1738 *enoughcuts =
FALSE;
1740 root = (actdepth == 0);
1742 SCIPsetDebugMsg(
set,
"calling separators on primal solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1775 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*enoughcuts) && !
SCIPsolveIsStopped(
set, stat,
FALSE); ++i )
1788 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in separation\n",
1830 assert(!onlydelayed);
1833 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*enoughcuts) && !
SCIPsolveIsStopped(
set, stat,
FALSE); ++i )
1842 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in separation\n",
1848 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, cutoff=%u\n",
1849 *delayed, *enoughcuts, *cutoff);
1876 assert(delayed !=
NULL);
1877 assert(cutoff !=
NULL);
1893 SCIP_CALL(
separationRoundLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, actdepth, 0.0, onlydelayed, delayed, &enoughcuts,
1894 cutoff, &lperror, &mustsepa, &mustprice) );
1928 int* npricedcolvars,
1941 assert(transprob !=
NULL);
1945 assert(npricedcolvars !=
NULL);
1946 assert(mustsepa !=
NULL);
1947 assert(lperror !=
NULL);
1948 assert(aborted !=
NULL);
1952 *npricedcolvars = transprob->
ncolvars;
1965 if( maxpricerounds == -1 )
1966 maxpricerounds = INT_MAX;
1970 while( !(*lperror) && mustprice && npricerounds < maxpricerounds )
1997 FALSE, &foundsol, &unbounded) );
2004 *npricedcolvars = transprob->
ncolvars;
2015 stoppricing =
FALSE;
2016 for( p = 0; p <
set->nactivepricers && !enoughvars; ++p )
2020 SCIPsetDebugMsg(
set,
"pricing: pricer %s returned result = %s, lowerbound = %f\n",
2027 if( p == 0 && stopearly )
2031 if( stoppricing && !stopearly )
2032 stoppricing =
FALSE;
2044 *mustsepa = *mustsepa || !lp->
flushed;
2050 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
TRUE,
FALSE, lperror) );
2052 assert(lp->
solved || *lperror);
2062 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2063 eventfilter, cliquetable,
FALSE,
FALSE, &cutoff) );
2064 assert(cutoff ==
FALSE);
2066 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != *npricedcolvars);
2067 *mustsepa = *mustsepa || !lp->
flushed;
2072 SCIPsetDebugMsg(
set,
"pricing: stop pricing and perform early branching\n");
2078 SCIPsetDebugMsg(
set,
"pricing: solve LP after resetting bounds and adding new initial constraints\n");
2079 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, lperror) );
2081 assert(lp->
solved || *lperror);
2091 if( displayinfo && mustprice )
2101 mustprice = mustprice &&
2110 assert(lp->
solved || *lperror);
2139 if( (set->sepa_poolfreq == 0 && actdepth == 0)
2140 || (set->sepa_poolfreq > 0 && actdepth % set->sepa_poolfreq == 0) )
2150 SCIP_CALL(
SCIPcutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
NULL, cutpoolisdelayed, root, &result) );
2204 int nsepastallrounds;
2205 int maxnsepastallrounds;
2210 assert(
set !=
NULL);
2211 assert(blkmem !=
NULL);
2212 assert(stat !=
NULL);
2213 assert(transprob !=
NULL);
2214 assert(tree !=
NULL);
2216 assert(pricestore !=
NULL);
2217 assert(sepastore !=
NULL);
2218 assert(cutpool !=
NULL);
2219 assert(delayedcutpool !=
NULL);
2220 assert(primal !=
NULL);
2221 assert(cutoff !=
NULL);
2222 assert(unbounded !=
NULL);
2223 assert(lperror !=
NULL);
2226 assert(focusnode !=
NULL);
2229 root = (actdepth == 0);
2235 bounddist = (loclowerbound - glblowerbound)/(primal->
cutoffbound - glblowerbound);
2236 separate =
SCIPsetIsLE(
set, bounddist, set->sepa_maxbounddist);
2237 separate = separate && (
set->sepa_maxruns == -1 || stat->
nruns <=
set->sepa_maxruns);
2240 maxseparounds = (root ?
set->sepa_maxroundsroot :
set->sepa_maxrounds);
2241 if( maxseparounds == -1 )
2242 maxseparounds = INT_MAX;
2243 if( stat->
nruns > 1 && root && set->sepa_maxroundsrootsubrun >= 0 )
2244 maxseparounds =
MIN(maxseparounds, set->sepa_maxroundsrootsubrun);
2245 if( !fullseparation && set->sepa_maxaddrounds >= 0 )
2246 maxseparounds =
MIN(maxseparounds, stat->
nseparounds + set->sepa_maxaddrounds);
2247 maxnsepastallrounds =
set->sepa_maxstallrounds;
2248 if( maxnsepastallrounds == -1 )
2249 maxnsepastallrounds = INT_MAX;
2257 assert(lp->
solved || *lperror);
2263 npricedcolvars = transprob->
ncolvars;
2265 mustsepa = separate;
2266 delayedsepa =
FALSE;
2269 nsepastallrounds = 0;
2272 stallnfracs = INT_MAX;
2274 while( !(*cutoff) && !(*unbounded) && !(*lperror) && (mustprice || mustsepa || delayedsepa) )
2281 while( mustprice && !(*lperror) )
2283 SCIP_CALL(
SCIPpriceLoop(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2284 pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &npricedcolvars,
2285 &mustsepa, lperror, pricingaborted) );
2290 assert(lp->
solved || *lperror);
2293 if( !(*lperror) && !(*pricingaborted) &&
SCIPlpIsRelax(lp) )
2296 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2328 SCIPsetDebugMsg(
set,
" -> LP solved: call propagators that are applicable during LP solving loop\n");
2337 SCIPsetDebugMsg(
set,
"new initial constraints added during propagation: old=%" SCIP_LONGINT_FORMAT
", new=%" SCIP_LONGINT_FORMAT
"\n", oldninitconssadded, stat->
ninitconssadded);
2339 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2340 branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE, cutoff) );
2343 if( !(*cutoff) && !(*unbounded) )
2361 assert(lp->
solved || *lperror);
2367 *propagateagain =
TRUE;
2375 *propagateagain =
TRUE;
2383 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2403 FALSE, &foundsol, unbounded) );
2409 assert(lp->
flushed || *cutoff || *unbounded);
2410 assert(lp->
solved || *lperror || *cutoff || *unbounded);
2415 && nsepastallrounds < maxnsepastallrounds
2419 delayedsepa = delayedsepa && !mustsepa && !(*cutoff);
2420 mustsepa = mustsepa || delayedsepa;
2428 if( !separate || (*cutoff) || (*unbounded)
2434 delayedsepa =
FALSE;
2437 assert(!(*lperror));
2458 if( !enoughcuts && !delayedsepa )
2460 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2461 actdepth, &enoughcuts, cutoff) );
2476 if( !(*cutoff) && !(*lperror) && !enoughcuts && lp->
solved )
2480 lp, sepastore, actdepth, bounddist, delayedsepa,
2481 &delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );
2485 if( !(*cutoff) && !(*lperror) && !enoughcuts && lp->
solved 2487 && nsepastallrounds >= maxnsepastallrounds-1 && delayedsepa )
2490 tree, lp, sepastore, actdepth, bounddist, delayedsepa,
2491 &delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );
2499 assert( !(*lperror) );
2502 root, actdepth, &enoughcuts, cutoff) );
2506 SCIPsetDebugMsg(
set,
" -> delayed global cut pool detected cutoff\n");
2522 if( *cutoff || *lperror
2537 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != npricedcolvars);
2538 mustsepa = mustsepa || !lp->
flushed;
2543 SCIPsetDebugMsg(
set,
" -> separation changed bound: propagate again\n");
2545 *propagateagain =
TRUE;
2557 SCIPsetDebugMsg(
set,
"new initial constraints added during propagation: old=%" SCIP_LONGINT_FORMAT
", new=%" SCIP_LONGINT_FORMAT
"\n",
2560 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2561 branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE, cutoff) );
2573 assert(lp->
solved || *lperror);
2586 if( stat->
domchgcount != olddomchgcount && (!mustprice || mustsepa) && !(*cutoff)
2590 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2616 objreldiff =
SCIPrelDiff(lpobjval, stalllpobjval);
2617 SCIPsetDebugMsg(
set,
" -> LP bound moved from %g to %g (reldiff: %g)\n",
2618 stalllpobjval, lpobjval, objreldiff);
2621 objreldiff <= 1e-04 &&
2622 nfracs >= (0.9 - 0.1 * nsepastallrounds) * stallnfracs);
2624 stalllpobjval = lpobjval;
2625 stallnfracs = nfracs;
2634 nsepastallrounds = 0;
2644 if( nsepastallrounds >= maxnsepastallrounds-2 )
2646 SCIPsetDebugMsg(
set,
" -> nsepastallrounds=%d/%d\n", nsepastallrounds, maxnsepastallrounds);
2653 SCIPsetDebugMsg(
set,
"separation round %d/%d finished (%d/%d stall rounds): mustprice=%u, mustsepa=%u, delayedsepa=%u, propagateagain=%u\n",
2654 stat->
nseparounds, maxseparounds, nsepastallrounds, maxnsepastallrounds, mustprice, mustsepa, delayedsepa, *propagateagain);
2661 if ( nsepastallrounds >= maxnsepastallrounds )
2664 "Truncate separation round because of stalling (%d stall rounds).\n", maxnsepastallrounds);
2678 else if( !(*lperror) )
2706 lp, branchcand, eventqueue, cliquetable,
NULL) );
2719 SCIPsetDebugMsg(
set,
" -> final lower bound: %g (LP status: %d, LP obj: %g)\n",
2747 assert(transprob !=
NULL);
2748 assert(origprob !=
NULL);
2749 assert(primal !=
NULL);
2750 assert(cutoff !=
NULL);
2763 SCIPsetDebugMsg(
set,
" -> lower bound: %g [%g] (pseudoobj: %g [%g]), cutoff bound: %g [%g]\n",
2772 SCIPsetDebugMsg(
set,
"node is cut off by bounding (lower=%g, upper=%g)\n",
2780 SCIP_CALL(
SCIPconflictAnalyzePseudo(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable,
NULL) );
2797 assert(
set !=
NULL);
2798 assert(relaxation !=
NULL);
2802 for( r = 0; r <
set->nrelaxs; ++r )
2846 assert(stat !=
NULL);
2847 assert(tree !=
NULL);
2849 assert(cutoff !=
NULL);
2850 assert(unbounded !=
NULL);
2851 assert(lperror !=
NULL);
2852 assert(*cutoff ==
FALSE);
2853 assert(*unbounded ==
FALSE);
2854 assert(*lperror ==
FALSE);
2859 if( !initiallpsolved )
2862 SCIP_CALL(
solveNodeInitialLP(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2863 pricestore, sepastore, cutpool, branchcand, eventfilter, eventqueue, cliquetable, newinitconss, cutoff, lperror) );
2866 SCIPsetDebugMsg(
set,
"price-and-cut-loop: initial LP status: %d, LP obj: %g\n",
2890 checklprows =
FALSE;
2896 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
2903 SCIP_CALL(
SCIPsolCheck(sol,
set, messagehdlr, blkmem, stat, transprob,
FALSE,
FALSE,
TRUE,
TRUE,
2904 checklprows, &feasible) );
2910 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
2923 if( set->reopt_enable )
2925 assert(reopt !=
NULL);
2939 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
2945 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
2951 SCIPsetDebugMsg(
set,
"solution cuts off root node, stop solution process\n");
2960 if( !(*cutoff) && !(*lperror) )
2966 int oldncutsapplied;
2968 oldnpricedvars = transprob->
ncolvars;
2975 SCIP_CALL(
priceAndCutLoop(blkmem,
set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
2976 pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,
2977 eventqueue, cliquetable, fullseparation, propagateagain, cutoff, unbounded, lperror, pricingaborted) );
2984 *solverelaxagain =
TRUE;
3009 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, lperror) );
3014 SCIPsetDebugMsg(
set,
"re-optimized LP without cutoff bound: LP status: %d, LP obj: %g\n",
3071 assert(
set !=
NULL);
3072 assert(relaxation !=
NULL);
3073 assert(cutoff !=
NULL);
3074 assert(solvelpagain !=
NULL);
3075 assert(propagateagain !=
NULL);
3076 assert(solverelaxagain !=
NULL);
3077 assert(relaxcalled !=
NULL);
3083 for( r = 0; r <
set->nrelaxs && !(*cutoff); ++r )
3088 *relaxcalled =
TRUE;
3106 *solvelpagain =
TRUE;
3107 *propagateagain =
TRUE;
3111 *solvelpagain =
TRUE;
3112 *propagateagain =
TRUE;
3116 *solvelpagain =
TRUE;
3120 *solverelaxagain =
TRUE;
3137 assert(focusnode !=
NULL);
3142 SCIPsetDebugMsg(
set,
" -> new lower bound given by relaxator %s: %g\n",
3157 for( i = 0; i < transprob->
nvars; ++i )
3159 assert(transprob->
vars[i] !=
NULL);
3200 assert(
set !=
NULL);
3201 assert(stat !=
NULL);
3202 assert(tree !=
NULL);
3204 assert(branched !=
NULL);
3205 assert(cutoff !=
NULL);
3206 assert(infeasible !=
NULL);
3207 assert(propagateagain !=
NULL);
3208 assert(solvelpagain !=
NULL);
3209 assert(solverelaxagain !=
NULL);
3211 assert(!(*propagateagain));
3212 assert(!(*solvelpagain));
3213 assert(!(*solverelaxagain));
3224 for( h = 0; h <
set->nconshdlrs && enforcerelaxsol; ++h )
3226 if( set->conshdlrs_enfo[h]->consenforelax ==
NULL && ((! set->conshdlrs_enfo[h]->needscons) ||
3227 (set->conshdlrs_enfo[h]->nconss > 0)) )
3231 enforcerelaxsol =
FALSE;
3244 SCIPmessagePrintVerbInfo(messagehdlr, set->disp_verblevel, verblevel,
"Disable enforcement of relaxation solutions" 3245 " since constraint handler %s does not implement enforelax-callback\n",
3257 SCIPsetDebugMsg(
set,
"enforcing constraints on relaxation solution\n");
3267 objinfeasible =
FALSE;
3286 for( h = 0; h <
set->nconshdlrs && !resolved; ++h )
3291 if( enforcerelaxsol )
3312 objinfeasible, forced, &result) );
3315 SCIPerrorMessage(
"pseudo enforcing method of constraint handler <%s> separated cuts\n",
3329 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in enforcement\n",
3336 *propagateagain =
TRUE;
3337 *solvelpagain =
TRUE;
3338 *solverelaxagain =
TRUE;
3346 *propagateagain =
TRUE;
3347 *solvelpagain =
TRUE;
3348 *solverelaxagain =
TRUE;
3357 *solvelpagain =
TRUE;
3358 *solverelaxagain =
TRUE;
3381 *solvelpagain =
TRUE;
3403 assert(objinfeasible);
3408 SCIPerrorMessage(
"invalid result code <%d> from enforcing method of constraint handler <%s>\n",
3427 *propagateagain =
FALSE;
3428 *solvelpagain =
FALSE;
3431 assert(!(*branched) || (resolved && !(*cutoff) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3432 assert(!(*cutoff) || (resolved && !(*branched) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3433 assert(*infeasible || (!resolved && !(*branched) && !(*cutoff) && !(*propagateagain) && !(*solvelpagain)));
3434 assert(!(*propagateagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));
3435 assert(!(*solvelpagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));
3437 assert(!objinfeasible || *infeasible);
3438 assert(resolved == (*branched || *cutoff || *propagateagain || *solvelpagain));
3444 SCIPsetDebugMsg(
set,
" -> enforcing result: branched=%u, cutoff=%u, infeasible=%u, propagateagain=%u, solvelpagain=%u, resolved=%u\n",
3445 *branched, *cutoff, *infeasible, *propagateagain, *solvelpagain, resolved);
3475 assert(stat !=
NULL);
3476 assert(cutoff !=
NULL);
3477 assert(propagateagain !=
NULL);
3478 assert(solvelpagain !=
NULL);
3488 int oldncutsapplied;
3492 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
3493 eventqueue, eventfilter, cliquetable, root, efficiacychoice, cutoff) );
3494 *propagateagain = *propagateagain || (stat->
domchgcount != olddomchgcount);
3495 *solvelpagain =
TRUE;
3498 *solverelaxagain =
TRUE;
3521 assert(
set !=
NULL);
3522 assert(stat !=
NULL);
3523 assert(cutoff !=
NULL);
3524 assert(propagateagain !=
NULL);
3525 assert(solverelaxagain !=
NULL);
3528 *cutoff = *cutoff || (tree->
cutoffdepth <= depth);
3538 for( r = 0; r <
set->nrelaxs && !(*solverelaxagain); ++r )
3539 *solverelaxagain = *solverelaxagain || ( !
SCIPrelaxIsSolved(set->relaxs[r], stat) );
3544 *propagateagain =
FALSE;
3545 *solverelaxagain =
FALSE;
3602 assert(
set !=
NULL);
3603 assert(stat !=
NULL);
3604 assert(origprob !=
NULL);
3605 assert(transprob !=
NULL);
3606 assert(tree !=
NULL);
3608 assert(primal !=
NULL);
3609 assert(pricestore !=
NULL);
3610 assert(sepastore !=
NULL);
3612 assert(branchcand !=
NULL);
3613 assert(cutpool !=
NULL);
3614 assert(delayedcutpool !=
NULL);
3615 assert(conflict !=
NULL);
3617 assert(eventfilter !=
NULL);
3618 assert(eventqueue !=
NULL);
3619 assert(focusnode !=
NULL);
3620 assert(heurtiming !=
NULL);
3621 assert(nlperrors !=
NULL);
3622 assert(fullpropagation !=
NULL);
3623 assert(propagateagain !=
NULL);
3624 assert(afterlpproplps !=
NULL);
3625 assert(lpsolved !=
NULL);
3626 assert(solvelpagain !=
NULL);
3627 assert(solverelaxagain !=
NULL);
3628 assert(cutoff !=
NULL);
3629 assert(postpone !=
NULL);
3630 assert(unbounded !=
NULL);
3631 assert(lperror !=
NULL);
3632 assert(pricingaborted !=
NULL);
3633 assert(forcedenforcement !=
NULL);
3635 newinitconss =
FALSE;
3637 if( !(*cutoff) && !(*postpone) )
3648 if( ((*afterlpproplps) < stat->
nnodelps && (*lpsolved)) || (*relaxcalled) )
3655 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3657 propagate = propagate || (stat->
nboundchgs > oldnboundchgs);
3661 if( propagate && !(*cutoff) )
3669 *fullpropagation =
FALSE;
3672 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3677 solvelp = solvelp || (lpwasflushed && (!lp->
flushed || newinitconss));
3678 solverelax = solverelax || newinitconss;
3690 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
3708 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
3709 conflict, cliquetable, cutoff) );
3723 FALSE, propagateagain, unbounded) );
3751 if( *propagateagain )
3753 *solvelpagain = solvelp;
3754 *solverelaxagain = solverelax;
3761 *relaxcalled =
FALSE;
3762 if( solverelax && !(*cutoff) )
3771 cutoff, propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
3775 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3778 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3780 solvelpagain, solverelaxagain) );
3783 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
3794 SCIP_CALL(
solveNodeLP(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
3795 sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,
3796 initiallpsolved, fullseparation, newinitconss, propagateagain, solverelaxagain, cutoff, unbounded, lperror, pricingaborted) );
3799 *solvelpagain =
FALSE;
3800 SCIPsetDebugMsg(
set,
" -> LP status: %d, LP obj: %g, iter: %" SCIP_LONGINT_FORMAT
", count: %" SCIP_LONGINT_FORMAT
"\n",
3806 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3813 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
3820 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
3827 *forcedenforcement =
TRUE;
3830 "(node %" SCIP_LONGINT_FORMAT
") LP solver hit %s limit in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead\n",
3837 "(node %" SCIP_LONGINT_FORMAT
") LP relaxation is unbounded (LP %" SCIP_LONGINT_FORMAT
")\n", stat->
nnodes, stat->
nlps);
3848 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") could not prove infeasibility of LP %" SCIP_LONGINT_FORMAT
" (exactsolve=%u, pricingaborted=%u), all variables are fixed, %d continuous vars\n",
3850 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") -> have to call PerPlex() (feature not yet implemented)\n", stat->
nnodes);
3857 *forcedenforcement =
TRUE;
3860 "(node %" SCIP_LONGINT_FORMAT
") could not prove infeasibility of LP %" SCIP_LONGINT_FORMAT
" (exactsolve=%u, pricingaborted=%u) -- using pseudo solution (%d unfixed vars) instead\n",
3866 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
3867 cliquetable, cutoff) );
3875 *solverelaxagain = *solverelaxagain && *relaxcalled;
3878 if( solverelax && !(*cutoff) )
3881 propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
3885 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3888 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3890 solvelpagain, solverelaxagain) );
3893 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
3894 cliquetable, cutoff) );
3909 assert(
set !=
NULL);
3910 assert(stat !=
NULL);
3912 return (set->nactivepricers == 0 && !set->reopt_enable
3913 && (set->presol_maxrestarts == -1 || stat->
nruns <= set->presol_maxrestarts)
3914 && (set->limit_restarts == -1 || stat->
nruns <= set->limit_restarts));
3917 #define restartAllowed(set,stat) ((set)->nactivepricers == 0 && !set->reopt_enable && ((set)->presol_maxrestarts == -1 || (stat)->nruns <= (set)->presol_maxrestarts) \ 3918 && (set->limit_restarts == -1 || stat->nruns <= set->limit_restarts)) 3978 assert(
set !=
NULL);
3979 assert(stat !=
NULL);
3980 assert(origprob !=
NULL);
3981 assert(transprob !=
NULL);
3982 assert(tree !=
NULL);
3983 assert(primal !=
NULL);
3986 assert(cutoff !=
NULL);
3987 assert(postpone !=
NULL);
3988 assert(unbounded !=
NULL);
3989 assert(infeasible !=
NULL);
3990 assert(restart !=
NULL);
3991 assert(afternodeheur !=
NULL);
3996 *infeasible =
FALSE;
3998 *afternodeheur =
FALSE;
4000 pricingaborted =
FALSE;
4003 assert(focusnode !=
NULL);
4013 SCIPsetDebugMsg(
set,
"Processing node %" SCIP_LONGINT_FORMAT
" in depth %d, %d siblings\n",
4024 focusnodehaslp = (
set->lp_solvedepth == -1 || actdepth <=
set->lp_solvedepth);
4025 focusnodehaslp = focusnodehaslp && (
set->lp_solvefreq >= 1 && actdepth %
set->lp_solvefreq == 0);
4026 focusnodehaslp = focusnodehaslp || (actdepth == 0 &&
set->lp_solvefreq == 0);
4028 focusnodehaslp =
set->reopt_enable ? focusnodehaslp &&
SCIPreoptGetSolveLP(reopt,
set, focusnode) : focusnodehaslp;
4042 initiallpsolved =
FALSE;
4043 fullseparation =
TRUE;
4048 solverelaxagain =
TRUE;
4049 solvelpagain =
TRUE;
4050 propagateagain =
TRUE;
4051 fullpropagation =
TRUE;
4052 forcedlpsolve =
FALSE;
4059 while( !(*cutoff) && !(*postpone) && (solverelaxagain || solvelpagain || propagateagain) && nlperrors <
MAXNLPERRORS && !(*restart) )
4071 *infeasible =
FALSE;
4077 relaxcalled =
FALSE;
4078 forcedenforcement =
FALSE;
4079 afterlpproplps = -1L;
4081 while( !lperror && !(*cutoff) && (propagateagain || solvelpagain || solverelaxagain
4082 || (afterlpproplps < stat->nnodelps && lpsolved) || relaxcalled) )
4084 solverelax = solverelaxagain;
4085 solverelaxagain =
FALSE;
4086 solvelp = solvelpagain;
4087 solvelpagain =
FALSE;
4088 propagate = propagateagain;
4089 propagateagain =
FALSE;
4092 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4093 conflict, cliquetable, cutoff) );
4096 SCIPsetDebugMsg(
set,
" -> node solving loop: call propagators that are applicable before%s LP is solved\n",
4097 lpsolved ?
" and after" :
"");
4098 SCIP_CALL(
propAndSolve(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,
4099 relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,
4100 eventqueue, cliquetable, focusnode, actdepth, propagate, solvelp, solverelax, forcedlpsolve, initiallpsolved,
4101 fullseparation, &afterlpproplps, &heurtiming, &nlperrors, &fullpropagation, &propagateagain, &lpsolved, &relaxcalled,
4102 &solvelpagain, &solverelaxagain, cutoff, postpone, unbounded, stopped, &lperror, &pricingaborted, &forcedenforcement) );
4103 initiallpsolved |= lpsolved;
4110 fullseparation =
FALSE;
4118 for( i = 0; i < transprob->
nvars; ++i )
4120 assert(transprob->
vars[i] !=
NULL);
4131 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4140 if( actdepth == 0 && !(*afternodeheur) )
4144 *afternodeheur =
TRUE;
4149 *cutoff, &foundsol, unbounded) );
4154 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4162 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
4170 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
4186 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
4192 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
4200 propagateagain =
TRUE;
4201 solvelpagain =
TRUE;
4202 solverelaxagain =
TRUE;
4208 if( !(*postpone) && !(*cutoff) && !solverelaxagain && !solvelpagain && !propagateagain )
4219 *infeasible =
FALSE;
4224 branchcand, &branched, cutoff, infeasible, &propagateagain, &solvelpagain, &solverelaxagain,
4225 forcedenforcement) );
4226 assert(branched == (tree->
nchildren > 0));
4227 assert(!branched || (!(*cutoff) && *infeasible && !propagateagain && !solvelpagain));
4228 assert(!(*cutoff) || (!branched && *infeasible && !propagateagain && !solvelpagain));
4229 assert(*infeasible || (!branched && !(*cutoff) && !propagateagain && !solvelpagain));
4230 assert(!propagateagain || (!branched && !(*cutoff) && *infeasible));
4231 assert(!solvelpagain || (!branched && !(*cutoff) && *infeasible));
4236 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4238 &solvelpagain, &solverelaxagain) );
4241 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4244 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4253 if( pricingaborted && !(*infeasible) && !(*cutoff) && !(*postpone) )
4263 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4281 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4309 wasforcedlpsolve = forcedlpsolve;
4310 forcedlpsolve =
FALSE;
4311 if( (*infeasible) && !(*cutoff) && !(*postpone)
4313 && !solverelaxagain && !solvelpagain && !propagateagain && !branched )
4330 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on LP solution with %d fractionals\n",
4332 SCIP_CALL(
SCIPbranchExecLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4342 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on %d external branching candidates.\n",
4344 SCIP_CALL(
SCIPbranchExecExtern(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4352 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on pseudo solution with %d unfixed integers\n",
4354 SCIP_CALL(
SCIPbranchExecPseudo(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
4368 "Starting spatial branch-and-bound on unbounded variable <%s> ([%g,%g]) - cannot guarantee finite termination.\n",
4386 SCIPerrorMessage(
"LP branching rule added constraint, which was not allowed this time\n");
4389 propagateagain =
TRUE;
4390 solvelpagain =
TRUE;
4391 solverelaxagain =
TRUE;
4396 propagateagain =
TRUE;
4397 solvelpagain =
TRUE;
4398 solverelaxagain =
TRUE;
4404 solvelpagain =
TRUE;
4405 solverelaxagain =
TRUE;
4429 if( transprob->
ncontvars == 0 && set->nactivepricers == 0 )
4432 SCIPsetDebugMsg(
set,
" -> cutoff because all variables are fixed in current node\n");
4458 if( pricingaborted )
4460 SCIPerrorMessage(
"pricing was aborted, but no branching could be created!\n");
4464 if( wasforcedlpsolve )
4467 SCIPerrorMessage(
"LP was solved, all integers fixed, some constraint still infeasible, but no branching could be created!\n");
4484 "(node %" SCIP_LONGINT_FORMAT
") forcing the solution of an LP (last LP %" SCIP_LONGINT_FORMAT
")...\n", stat->
nnodes, stat->
nlps);
4488 solvelpagain =
TRUE;
4489 forcedlpsolve =
TRUE;
4494 SCIPerrorMessage(
"invalid result code <%d> from SCIPbranchLP(), SCIPbranchExt() or SCIPbranchPseudo()\n", result);
4497 assert(*cutoff || solvelpagain || propagateagain || branched);
4498 assert(!(*cutoff) || (!solvelpagain && !propagateagain && !branched));
4499 assert(!solvelpagain || (!(*cutoff) && !branched));
4500 assert(!propagateagain || (!(*cutoff) && !branched));
4501 assert(!branched || (!solvelpagain && !propagateagain));
4502 assert(branched == (tree->
nchildren > 0));
4505 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4507 &solvelpagain, &solverelaxagain) );
4510 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4513 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4521 SCIPsetDebugMsg(
set,
"node solving iteration %d finished: cutoff=%u, postpone=%u, propagateagain=%u, solverelaxagain=%u, solvelpagain=%u, nlperrors=%d, restart=%u\n",
4522 nloops, *cutoff, *postpone, propagateagain, solverelaxagain, solvelpagain, nlperrors, *restart);
4528 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
4533 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- aborting\n", stat->
nnodes, stat->
nlps);
4538 restartfac =
set->presol_subrestartfac;
4540 restartfac =
MIN(restartfac, set->presol_restartfac);
4546 if( actdepth == 0 && !(*cutoff) && !(*unbounded) && !(*postpone) )
4613 if( checksol || set->misc_exactsolve )
4616 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4622 SCIP_CALL(
SCIPprimalAddSol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4650 if( checksol || set->misc_exactsolve )
4653 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4658 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4659 eventqueue, eventfilter, &sol, &foundsol) );
4683 if( checksol || set->misc_exactsolve )
4686 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4691 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4692 eventqueue, eventfilter, &sol, &foundsol) );
4754 assert(
set !=
NULL);
4755 assert(blkmem !=
NULL);
4756 assert(stat !=
NULL);
4757 assert(transprob !=
NULL);
4758 assert(tree !=
NULL);
4760 assert(pricestore !=
NULL);
4761 assert(sepastore !=
NULL);
4762 assert(branchcand !=
NULL);
4763 assert(cutpool !=
NULL);
4764 assert(delayedcutpool !=
NULL);
4765 assert(primal !=
NULL);
4766 assert(eventfilter !=
NULL);
4767 assert(eventqueue !=
NULL);
4768 assert(restart !=
NULL);
4771 restartfac =
set->presol_subrestartfac;
4773 restartfac =
MIN(restartfac, set->presol_restartfac);
4779 if( set->conf_restartnum > 0 )
4783 restartconfnum = (
SCIP_Real)set->conf_restartnum;
4784 for( i = 0; i < stat->nconfrestarts; ++i )
4785 restartconfnum *=
set->conf_restartfac;
4789 assert(restartconfnum >= 0.0);
4827 if( nextnode ==
NULL )
4832 focusnode = nextnode;
4840 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt,
4841 lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
4856 if( focusnode ==
NULL )
4879 SCIP_CALL(
solveNode(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,
4880 pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,
4881 cliquetable, &cutoff, &postpone, &unbounded, &infeasible, restart, &afternodeheur, &stopped) );
4882 assert(!cutoff || infeasible);
4893 if( !(*restart) && !postpone )
4936 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,
4937 lp, eventqueue, eventfilter,
FALSE) );
4940 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &cutoff) );
4951 if( set->reopt_enable )
4953 assert(reopt !=
NULL);
4960 else if( !unbounded )
4981 if( set->reopt_enable )
4983 assert(reopt !=
NULL);
5003 if( set->reopt_enable )
5005 assert(reopt !=
NULL);
5030 assert(set->misc_exactsolve);
5040 SCIPerrorMessage(
"cannot branch on all-fixed LP -- have to call PerPlex instead\n");
5063 if( !afternodeheur && (!cutoff || nnodes > 0) && !stopped )
5066 cutoff, &foundsol, &unbounded) );
5080 else if( !infeasible && !postpone )
5086 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,
5087 eventqueue, eventfilter,
TRUE) );
5089 if( set->reopt_enable )
5091 assert(reopt !=
NULL);
5103 SCIP_CALL(
SCIPnodeFocus(&newfocusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5104 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
TRUE,
FALSE) );
5112 if( nsuccessconflicts >= restartconfnum &&
restartAllowed(
set, stat) )
5115 "(run %d, node %" SCIP_LONGINT_FORMAT
") restarting after %" SCIP_LONGINT_FORMAT
" successful conflict analysis calls\n",
5129 "(run %d, node %" SCIP_LONGINT_FORMAT
") restarting: triggering parameter controlled restart)\n",
5145 SCIPsetDebugMsg(
set,
"Processing of node %" SCIP_LONGINT_FORMAT
" in depth %d finished. %d siblings, %d children, %d leaves left\n",
5147 SCIPsetDebugMsg(
set,
"**********************************************************************\n");
5173 if( set->reopt_enable )
5175 assert(reopt !=
NULL);
5182 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5183 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
5195 if( primal->
nsols > 0 )
enum SCIP_Result SCIP_RESULT
internal methods for separators
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_HEURTIMING_DURINGLPLOOP
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
void SCIPpricestoreEndInitialLP(SCIP_PRICESTORE *pricestore)
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
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)
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)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Longint ninfeasleaves
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)
#define SCIP_EVENTTYPE_LPSOLVED
SCIP_Real firstlpdualbound
SCIP_Bool SCIPrelaxIncludesLp(SCIP_RELAX *relax)
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)
internal methods for managing events
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_Longint nnodelpiterations
static void markRelaxsUnsolved(SCIP_SET *set, SCIP_RELAXATION *relaxation)
int SCIPheurGetPriority(SCIP_HEUR *heur)
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 onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice)
SCIP_BRANCHINGDATA branchingdata
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_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_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Longint nlpsolsfound
internal methods for storing primal CIP solutions
SCIP_Bool SCIPtreeHasFocusNodeLP(SCIP_TREE *tree)
SCIP_Longint nlpiterations
const char * SCIPpricerGetName(SCIP_PRICER *pricer)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
#define SCIPdebugRemoveNode(blkmem, set, node)
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)
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
SCIP_Longint externmemestim
internal methods for branch and bound tree
void SCIPtreeSetFocusNodeLP(SCIP_TREE *tree, SCIP_Bool solvelp)
SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
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)
enum SCIP_Efficiacychoice SCIP_EFFICIACYCHOICE
int SCIPgetNConcurrentSolvers(SCIP *scip)
unsigned int boundchgtype
int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
void SCIPprobUpdateBestRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE updateEstimate(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)
SCIP_Longint ninitconssadded
static SCIP_Bool isPseudocostUpdateValid(SCIP_VAR *var, SCIP_SET *set, SCIP_Real oldlpsolval, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous)
SCIP_RETCODE SCIPtreeSetNodesel(SCIP_TREE *tree, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_NODESEL *nodesel)
SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
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)
internal methods for clocks and timing issues
void SCIPstatUpdateMemsaveMode(SCIP_STAT *stat, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_MEM *mem)
int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)
unsigned int SCIP_HEURTIMING
SCIP_BOUNDCHG * boundchgs
SCIP_Real lastbranchvalue
SCIP_Longint nrootfirstlpiterations
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
int SCIPpropGetPriority(SCIP_PROP *prop)
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
#define SCIP_HEURTIMING_BEFORENODE
void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid)
SCIP_BRANCHDIR lastbranchdir
void SCIPsepastoreStartForceCuts(SCIP_SEPASTORE *sepastore)
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)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Real SCIPrelaxationGetBestRelaxSolObj(SCIP_RELAXATION *relaxation)
SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)
#define SCIP_PROPTIMING_DURINGLPLOOP
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPsetSortHeurs(SCIP_SET *set)
SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
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)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPresetInterrupted(void)
SCIP_Bool SCIPreoptGetSolveLP(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node)
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 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)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
enum SCIP_Retcode SCIP_RETCODE
SCIP_RETCODE SCIPtreeLoadLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
#define SCIP_HEURTIMING_AFTERNODE
#define SCIP_EVENTTYPE_NODEFOCUSED
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
#define SCIPsetAllocBufferArray(set, ptr, num)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
SCIP_RETCODE SCIPsolSetUnknown(SCIP_SOL *sol, SCIP_STAT *stat, SCIP_TREE *tree)
int SCIPvarGetProbindex(SCIP_VAR *var)
enum SCIP_VerbLevel SCIP_VERBLEVEL
internal methods for branching rules and branching candidate storage
void SCIPbranchcandClearExternCands(SCIP_BRANCHCAND *branchcand)
#define SCIP_HEURTIMING_AFTERLPLOOP
SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)
void SCIPregressionAddObservation(SCIP_REGRESSION *regression, SCIP_Real x, SCIP_Real y)
SCIP_RETCODE SCIPeventChgNode(SCIP_EVENT *event, SCIP_NODE *node)
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)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
#define SCIP_HEURTIMING_DURINGPRICINGLOOP
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)
void SCIPvisualSolvedNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)
SCIP_Longint nnodesaboverefbound
SCIP_SOL * SCIPrelaxationGetBestRelaxSol(SCIP_RELAXATION *relaxation)
SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)
int SCIPnodeGetDepth(SCIP_NODE *node)
methods for creating output for visualization tools (VBC, BAK)
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
#define SCIPsetFreeBufferArray(set, ptr)
enum SCIP_LPSolStat SCIP_LPSOLSTAT
static void updateLoopStatus(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_Longint nlpbestsolsfound
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)
#define SCIPstatIncrement(stat, set, field)
internal methods for LP management
SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)
void SCIPpricestoreStartInitialLP(SCIP_PRICESTORE *pricestore)
int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)
static SCIP_RETCODE enforceConstraints(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, 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)
SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)
int SCIPpricestoreGetNBoundResets(SCIP_PRICESTORE *pricestore)
internal methods for collecting primal CIP solutions and primal informations
#define SCIP_HEURTIMING_AFTERPSEUDOPLUNGE
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)
SCIP_RETCODE SCIPnodeselSelect(SCIP_NODESEL *nodesel, SCIP_SET *set, SCIP_NODE **selnode)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
internal methods for propagators
void SCIPrelaxationSetBestRelaxSolObj(SCIP_RELAXATION *relaxation, SCIP_Real obj)
#define SCIP_EVENTTYPE_NODEFEASIBLE
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
SCIP_RETCODE SCIPsepaExecSol(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)
#define SCIP_EVENTTYPE_NODEBRANCHED
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 SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)
int SCIPbranchcandGetNExternCands(SCIP_BRANCHCAND *branchcand)
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 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)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPclockGetLastTime(SCIP_CLOCK *clck)
SCIP_Bool forcinglpmessage
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
void SCIPnodeUpdateLowerbound(SCIP_NODE *node, SCIP_STAT *stat, SCIP_SET *set, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real newbound)
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
SCIP_Longint npssolsfound
const char * SCIPheurGetName(SCIP_HEUR *heur)
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)
internal methods for storing and manipulating the main problem
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_Longint nbestsolsfound
methods for block memory pools and memory buffers
#define SCIP_HEURTIMING_AFTERLPNODE
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)
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_CLOCK * pseudosoltime
void SCIPnodeMarkPropagated(SCIP_NODE *node, SCIP_TREE *tree)
SCIP_Longint nrelaxbestsolsfound
SCIP_NODE * focuslpstatefork
SCIP_RETCODE SCIPsolSetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real val)
int SCIPrelaxGetPriority(SCIP_RELAX *relax)
SCIP_Longint ninitlpiterations
int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
static SCIP_RETCODE propagationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, 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)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
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 SCIPnodeIsPropagatedAgain(SCIP_NODE *node)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
#define SCIPsetReallocBufferArray(set, ptr, num)
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)
SCIP_REGRESSION * regressioncandsobjval
SCIP_RETCODE SCIPtreeLoadLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool *initroot)
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
internal methods for node selectors and node priority queues
internal methods for variable pricers
const char * SCIPrelaxGetName(SCIP_RELAX *relax)
#define SCIP_PROPTIMING_AFTERLPLOOP
void SCIPsetSortProps(SCIP_SET *set)
internal methods for global SCIP settings
SCIP_Real SCIPgetLowerbound(SCIP *scip)
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)
#define SCIP_HEURTIMING_DURINGPRESOLLOOP
int SCIPlpGetNRows(SCIP_LP *lp)
void SCIPrelaxMarkUnsolved(SCIP_RELAX *relax)
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)
enum PseudocostFlag PSEUDOCOSTFLAG
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
#define SCIP_HEURTIMING_BEFOREPRESOL
internal methods for storing priced variables
internal methods for relaxators
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
internal methods for storing separated cuts
void SCIPsetSortRelaxs(SCIP_SET *set)
methods for catching the user CTRL-C interrupt
data structures and methods for collecting reoptimization information
internal methods for problem variables
the function declarations for the synchronization store
void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)
SCIP_Bool SCIPsepaWasLPDelayed(SCIP_SEPA *sepa)
SCIP_Longint nisstoppedcalls
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)
public data structures and miscellaneous methods
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
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)
SCIP_Bool SCIPinterrupted(void)
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_Bool SCIPrelaxIsSolved(SCIP_RELAX *relax, SCIP_STAT *stat)
SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
SCIP_Bool branchedunbdvar
SCIP_RETCODE SCIPsolCreate(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Bool SCIPheurShouldBeExecuted(SCIP_HEUR *heur, int depth, int lpstateforkdepth, SCIP_HEURTIMING heurtiming, SCIP_Bool *delayed)
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)
static SCIP_Bool restartAllowed(SCIP_SET *set, SCIP_STAT *stat)
#define SCIP_EVENTTYPE_NODEINFEASIBLE
SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
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)
static SCIP_RETCODE propagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, int depth, int maxproprounds, SCIP_Bool fullpropagation, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone)
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)
SCIP_RETCODE SCIPpropagateDomains(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, int depth, int maxproprounds, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPsepaExecLP(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Real bounddist, SCIP_Bool execdelayed, SCIP_RESULT *result)
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
#define SCIP_PROPTIMING_BEFORELP
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 onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)
internal methods for storing cuts in a cut pool
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
void SCIPsepastoreEndInitialLP(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
#define SCIP_EVENTTYPE_FIRSTLPSOLVED
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_CLOCK * relaxsoltime
void SCIPsepastoreStartInitialLP(SCIP_SEPASTORE *sepastore)
void SCIPprobStoreRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool roothaslp)
helper functions for concurrent scip solvers
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)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
SCIP_Longint nrootlpiterations
SCIP_RETCODE SCIPpricestoreResetBounds(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
SCIP_DOMCHGBOUND domchgbound
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)
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)
SCIP_Bool SCIPsepaWasSolDelayed(SCIP_SEPA *sepa)
SCIP_Bool SCIPpropWasDelayed(SCIP_PROP *prop)
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
unsigned int SCIP_PROPTIMING
internal methods for conflict analysis
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)
internal methods for main solving loop and node processing
size_t BMSgetNUsedBufferMemory(BMS_BUFMEM *buffer)
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_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
SCIP_PROPTIMING SCIPpropGetTimingmask(SCIP_PROP *prop)
unsigned int pseudocostflag
SCIP_Longint npsbestsolsfound
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)
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)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPprimalAddSol(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)
#define SCIP_HEURTIMING_AFTERPSEUDONODE
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)
void SCIPvisualCutoffNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node, SCIP_Bool infeasible)
internal methods for problem statistics
void SCIPstatUpdatePrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
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)
SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)
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)
void SCIPsetSortPricers(SCIP_SET *set)
SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
SCIP_Longint ntotalinternalnodes
internal methods for constraints and constraint handlers
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
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 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)
SCIP_Bool SCIPsyncstoreSolveIsStopped(SCIP_SYNCSTORE *syncstore)
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
SCIP_Bool SCIPnodeIsActive(SCIP_NODE *node)
SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Bool disableenforelaxmsg
SCIP_CLOCK * nodeactivationtime
#define SCIP_HEURTIMING_AFTERLPPLUNGE
SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)
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_Longint ninternalnodes
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
SCIP_RETCODE SCIPtreeCutoff(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real cutoffbound)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
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)
#define BMSclearMemoryArray(ptr, num)
common defines and data types used in all packages of SCIP
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)
struct BMS_BlkMem BMS_BLKMEM
int SCIPtreeGetNLeaves(SCIP_TREE *tree)
internal methods for primal heuristics
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPsepastoreClearCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
SCIP_Longint nrelaxsolsfound
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)
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)
int SCIPtreeGetNNodes(SCIP_TREE *tree)
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)
SCIP_Longint nlimsolsfound
void SCIPsetSortSepas(SCIP_SET *set)
static SCIP_RETCODE separationRoundSol(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff)
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)
void SCIPsepastoreEndForceCuts(SCIP_SEPASTORE *sepastore)
SCIP_RETCODE SCIPrelaxExec(SCIP_RELAX *relax, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Real *lowerbound, SCIP_RESULT *result)
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
#define SCIP_HEURTIMING_AFTERPROPLOOP
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)
SCIP_Longint ndelayedcutoffs
SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)
int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)
internal methods for displaying runtime statistics