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;
102 if( set->misc_catchctrlc )
108 else if( set->istimelimitfinite )
124 if( (
SAFETYFACTOR * (set->limit_time - currtime) / (avgisstoppedfreq + 1e-6)) < nclockskips )
133 if( currtime >= set->limit_time )
160 else if( checknodelimits && set->limit_nodes >= 0 && stat->
nnodes >= set->limit_nodes )
162 else if( checknodelimits && set->limit_totalnodes >= 0 && stat->
ntotalnodes >= set->limit_totalnodes )
164 else if( checknodelimits && set->limit_stallnodes >= 0 && stat->
nnodes >= stat->
bestsolnode + set->limit_stallnodes )
170 if( !checknodelimits )
198 int lpstateforkdepth;
206 assert(primal != NULL);
216 assert(foundsol != NULL);
238 heurtiming &= ~SCIP_HEURTIMING_AFTERNODE;
241 assert(nextnode == NULL
267 lpstateforkdepth = -1;
274 assert(tree != NULL);
278 SCIPsetDebugMsg(
set,
"calling primal heuristics in depth %d (timing: %u)\n", depth, heurtiming);
300 else if( lp != NULL )
305 for( h = 0; h <
set->nheurs; ++h )
321 SCIPsetDebugMsg(
set,
" -> executing heuristic <%s> with priority %d\n",
327 SCIP_CALL(
SCIPheurExec(set->heurs[h],
set, primal, depth, lpstateforkdepth, heurtiming, nodeinfeasible,
328 &ndelayedheurs, &result) );
355 assert(0 <= ndelayedheurs && ndelayedheurs <= set->nheurs);
385 assert(delayed != NULL);
386 assert(propagain != NULL);
387 assert(cutoff != NULL);
388 assert(postpone != NULL);
402 for( i = 0; i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
453 for( i = 0; i <
set->nconshdlrs && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
478 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in propagation\n",
491 for( i = 0; i <
set->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )
554 assert(tree != NULL);
556 assert(cutoff != NULL);
565 if( maxproprounds == 0 )
566 maxproprounds = (depth == 0 ?
set->prop_maxroundsroot :
set->prop_maxrounds);
567 if( maxproprounds == -1 )
568 maxproprounds = INT_MAX;
570 SCIPsetDebugMsg(
set,
"domain propagation of node %p in depth %d (using depth %d, maxrounds %d, proptiming %u)\n",
578 while( propagain && !(*cutoff) && !(*postpone) && propround < maxproprounds && !
SCIPsolveIsStopped(
set, stat,
FALSE) )
583 SCIP_CALL(
propagationRound(blkmem,
set, stat, primal, tree, depth, fullpropagation,
FALSE, &delayed, &propagain, timingmask, cutoff, postpone) );
586 while( delayed && (!propagain || propround >= maxproprounds) && !(*cutoff) )
589 SCIP_CALL(
propagationRound(blkmem,
set, stat, primal, tree, depth, fullpropagation,
TRUE, &delayed, &propagain, timingmask, cutoff, postpone) );
595 fullpropagation =
TRUE;
603 SCIPsetDebugMsg(
set,
" --> domain propagation of node %p finished: cutoff!\n", (
void*)node);
633 SCIP_CALL(
propagateDomains(blkmem,
set, stat, primal, tree, depth, maxproprounds,
TRUE, timingmask, cutoff, &postpone) );
636 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
724 assert(tree != NULL);
725 assert(tree->
path != NULL);
731 assert(tree->
path[actdepth] == focusnode);
762 node = tree->
path[d];
764 if( node->
domchg != NULL )
771 for( i = 0; i < nboundchgs; ++i )
773 var = boundchgs[i].
var;
789 updates[nupdates] = &boundchgs[i];
812 weight = (nvalidupdates > 0 ? 1.0 / (
SCIP_Real)nvalidupdates : 1.0);
814 lpgain =
MAX(lpgain, 0.0);
816 for( i = 0; i < nupdates; ++i )
820 var = updates[i]->
var;
828 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s>: sol: %g -> %g, LP: %e -> %e => solvaldelta = %g, gain=%g, weight: %g\n",
863 assert(set->branch_lpgainnorm ==
'd' || set->branch_lpgainnorm ==
's');
867 if( set->branch_lpgainnorm ==
'd' )
869 assert(!updates[i]->redundant);
877 for( j = nbdchginfos-1; j >= 0; --j )
894 assert(updates[i]->redundant);
901 assert(j >= 0 || updates[i]->redundant);
911 delta = updates[i]->
newbound - oldbound;
924 for( j = nbdchginfos-1; j >= 0; --j )
941 assert(updates[i]->redundant);
948 assert(j >= 0 || updates[i]->redundant);
958 delta = updates[i]->
newbound - oldbound;
1000 SCIPsetDebugMsg(
set,
"updating pseudocosts of <%s> with strategy %c: domain: [%g,%g] -> [%g,%g], LP: %e -> %e => " 1001 "delta = %g, gain=%g, weight: %g\n",
1008 delta, lpgain, weight);
1046 assert(focusnode != NULL);
1061 for( i = 0; i < nlpcands; ++i )
1068 estimate += MIN(pscdown, pscup);
1098 assert(
set != NULL);
1100 assert(cutoff != NULL);
1109 for( h = 0; h <
set->nconshdlrs && !(*cutoff); ++h )
1114 if( set->reopt_enable && set->reopt_usecuts && firstsubtreeinit && !(*cutoff) )
1118 eventfilter, lp, root) );
1124 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1165 assert(
set != NULL);
1166 assert(transprob != NULL);
1168 assert(cutoff != NULL);
1185 for( v = 0; v < transprob->
nvars && !(*cutoff); ++v )
1187 var = transprob->
vars[v];
1211 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
1212 eventfilter, cliquetable, root,
TRUE, cutoff) );
1240 assert(tree != NULL);
1241 assert(cutoff != NULL);
1259 SCIP_CALL(
SCIPsepastoreAddCut(sepastore, blkmem,
set, stat, eventqueue, eventfilter, lp, lp->
rows[i],
TRUE, (
SCIPtreeGetCurrentDepth(tree) == 0), cutoff) );
1273 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
1288 SCIP_CALL(
initLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,
1289 eventqueue, eventfilter, cliquetable, initroot, cutoff) );
1292 else if( newinitconss )
1295 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
1318 assert(blkmem != NULL);
1319 assert(
set != NULL);
1320 assert(stat != NULL);
1321 assert(prob != NULL);
1322 assert(primal != NULL);
1323 assert(tree != NULL);
1346 nvars = prob->
nvars;
1358 for( i = 0; i < nvars; i++ )
1402 assert(stat != NULL);
1403 assert(tree != NULL);
1405 assert(cutoff != NULL);
1406 assert(lperror != NULL);
1414 SCIP_CALL(
SCIPconstructCurrentLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,
1415 branchcand, eventqueue, eventfilter, cliquetable, newinitconss, cutoff) );
1426 if( focusnode->
depth == 0 )
1437 assert(lp->
solved || *lperror);
1480 if( set->misc_exactsolve )
1514 assert(lperror != NULL);
1515 assert(mustsepa != NULL);
1516 assert(mustprice != NULL);
1523 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob, set->lp_iterlim,
FALSE,
TRUE,
FALSE, lperror) );
1525 assert(lp->
solved || *lperror);
1567 assert(
set != NULL);
1569 assert(set->conshdlrs_sepa != NULL);
1570 assert(delayed != NULL);
1571 assert(enoughcuts != NULL);
1572 assert(cutoff != NULL);
1573 assert(lperror != NULL);
1575 root = (actdepth == 0);
1581 SCIPsetDebugMsg(
set,
"calling separators on LP solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1587 for( i = 0; i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1601 SCIPsetDebugMsg(
set,
" -> executing separator <%s> with priority %d\n",
1603 SCIP_CALL(
SCIPsepaExecLP(set->sepas[i],
set, stat, sepastore, actdepth, bounddist, allowlocal, onlydelayed, &result) );
1619 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1636 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1643 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1656 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1666 SCIPsetDebugMsg(
set,
" -> delayed constraint handler <%s> found a cut\n",
1674 for( i = 0; i <
set->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1684 SCIPsetDebugMsg(
set,
" -> executing separator <%s> with priority %d\n",
1686 SCIP_CALL(
SCIPsepaExecLP(set->sepas[i],
set, stat, sepastore, actdepth, bounddist, allowlocal, onlydelayed, &result) );
1696 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1715 assert(!onlydelayed);
1718 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->
flushed && lp->
solved 1722 SCIPsetDebugMsg(
set,
" -> executing separation of constraint handler <%s> with priority %d\n",
1735 SCIP_CALL(
separationRoundResolveLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );
1744 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, lpflushed=%u, cutoff=%u\n",
1745 *delayed, *enoughcuts, lp->
flushed, *cutoff);
1771 assert(
set != NULL);
1772 assert(set->conshdlrs_sepa != NULL);
1773 assert(delayed != NULL);
1774 assert(enoughcuts != NULL);
1775 assert(cutoff != NULL);
1778 *enoughcuts =
FALSE;
1780 root = (actdepth == 0);
1782 SCIPsetDebugMsg(
set,
"calling separators on primal solution in depth %d (onlydelayed: %u)\n", actdepth, onlydelayed);
1796 SCIP_CALL(
SCIPsepaExecSol(set->sepas[i],
set, stat, sepastore, sol, actdepth, allowlocal, onlydelayed, &result) );
1815 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*enoughcuts) && !
SCIPsolveIsStopped(
set, stat,
FALSE); ++i )
1828 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in separation\n",
1849 SCIP_CALL(
SCIPsepaExecSol(set->sepas[i],
set, stat, sepastore, sol, actdepth, allowlocal, onlydelayed, &result) );
1870 assert(!onlydelayed);
1873 for( i = 0; i <
set->nconshdlrs && !(*cutoff) && !(*enoughcuts) && !
SCIPsolveIsStopped(
set, stat,
FALSE); ++i )
1882 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in separation\n",
1888 SCIPsetDebugMsg(
set,
" -> separation round finished: delayed=%u, enoughcuts=%u, cutoff=%u\n",
1889 *delayed, *enoughcuts, *cutoff);
1917 assert(delayed != NULL);
1918 assert(cutoff != NULL);
1934 SCIP_CALL(
separationRoundLP(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, \
1935 actdepth, 0.0, allowlocal, onlydelayed, delayed, &enoughcuts, cutoff, \
1936 &lperror, &mustsepa, &mustprice) );
1941 SCIP_CALL(
separationRoundSol(blkmem,
set, stat, sepastore, sol, actdepth, allowlocal, onlydelayed, delayed, &enoughcuts, cutoff) );
1970 int* npricedcolvars,
1983 assert(transprob != NULL);
1987 assert(npricedcolvars != NULL);
1988 assert(mustsepa != NULL);
1989 assert(lperror != NULL);
1990 assert(aborted != NULL);
1994 *npricedcolvars = transprob->
ncolvars;
2007 if( maxpricerounds == -1 )
2008 maxpricerounds = INT_MAX;
2012 while( !(*lperror) && mustprice && npricerounds < maxpricerounds )
2039 FALSE, &foundsol, &unbounded) );
2046 *npricedcolvars = transprob->
ncolvars;
2057 stoppricing =
FALSE;
2058 for( p = 0; p <
set->nactivepricers && !enoughvars; ++p )
2062 SCIPsetDebugMsg(
set,
"pricing: pricer %s returned result = %s, lowerbound = %f\n",
2069 if( p == 0 && stopearly )
2073 if( stoppricing && !stopearly )
2074 stoppricing =
FALSE;
2086 *mustsepa = *mustsepa || !lp->
flushed;
2092 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
TRUE,
FALSE, lperror) );
2094 assert(lp->
solved || *lperror);
2104 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2105 eventfilter, cliquetable,
FALSE,
FALSE, &cutoff) );
2106 assert(cutoff ==
FALSE);
2108 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != *npricedcolvars);
2109 *mustsepa = *mustsepa || !lp->
flushed;
2114 SCIPsetDebugMsg(
set,
"pricing: stop pricing and perform early branching\n");
2120 SCIPsetDebugMsg(
set,
"pricing: solve LP after resetting bounds and adding new initial constraints\n");
2121 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, lperror) );
2123 assert(lp->
solved || *lperror);
2133 if( displayinfo && mustprice )
2143 mustprice = mustprice &&
2152 assert(lp->
solved || *lperror);
2181 if( (set->sepa_poolfreq == 0 && actdepth == 0)
2182 || (set->sepa_poolfreq > 0 && actdepth % set->sepa_poolfreq == 0) )
2186 SCIP_CALL(
SCIPcutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore, NULL, cutpoolisdelayed, root, &result) );
2242 int maxincseparounds;
2243 int nsepastallrounds;
2244 int maxnsepastallrounds;
2249 assert(
set != NULL);
2250 assert(blkmem != NULL);
2251 assert(stat != NULL);
2252 assert(transprob != NULL);
2253 assert(tree != NULL);
2255 assert(pricestore != NULL);
2256 assert(sepastore != NULL);
2257 assert(cutpool != NULL);
2258 assert(delayedcutpool != NULL);
2259 assert(primal != NULL);
2260 assert(cutoff != NULL);
2261 assert(unbounded != NULL);
2262 assert(lperror != NULL);
2265 assert(focusnode != NULL);
2268 root = (actdepth == 0);
2274 bounddist = (loclowerbound - glblowerbound)/(primal->
cutoffbound - glblowerbound);
2275 allowlocal =
SCIPsetIsLE(
set, bounddist, set->sepa_maxlocalbounddist);
2276 separate = (
set->sepa_maxruns == -1 || stat->
nruns <=
set->sepa_maxruns);
2279 maxseparounds = (root ?
set->sepa_maxroundsroot :
set->sepa_maxrounds);
2280 if( maxseparounds == -1 )
2281 maxseparounds = INT_MAX;
2282 if( stat->
nruns > 1 && root && set->sepa_maxroundsrootsubrun >= 0 )
2283 maxseparounds = MIN(maxseparounds, set->sepa_maxroundsrootsubrun);
2284 if( !fullseparation && set->sepa_maxaddrounds >= 0 )
2285 maxseparounds = MIN(maxseparounds, stat->
nseparounds + set->sepa_maxaddrounds);
2286 maxnsepastallrounds = root ?
set->sepa_maxstallroundsroot :
set->sepa_maxstallrounds;
2287 if( maxnsepastallrounds == -1 )
2288 maxnsepastallrounds = INT_MAX;
2289 maxincseparounds =
set->sepa_maxincrounds;
2290 if( maxincseparounds == -1 )
2291 maxincseparounds = INT_MAX;
2299 assert(lp->
solved || *lperror);
2305 npricedcolvars = transprob->
ncolvars;
2307 mustsepa = separate;
2308 delayedsepa =
FALSE;
2311 nsepastallrounds = 0;
2314 stallnfracs = INT_MAX;
2316 while( !(*cutoff) && !(*unbounded) && !(*lperror) && (mustprice || mustsepa || delayedsepa) )
2323 while( mustprice && !(*lperror) )
2325 SCIP_CALL(
SCIPpriceLoop(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2326 pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &npricedcolvars,
2327 &mustsepa, lperror, pricingaborted) );
2332 assert(lp->
solved || *lperror);
2335 if( !(*lperror) && !(*pricingaborted) &&
SCIPlpIsRelax(lp) )
2338 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2370 SCIPsetDebugMsg(
set,
" -> LP solved: call propagators that are applicable during LP solving loop\n");
2379 SCIPsetDebugMsg(
set,
"new initial constraints added during propagation: old=%" SCIP_LONGINT_FORMAT
", new=%" SCIP_LONGINT_FORMAT
"\n", oldninitconssadded, stat->
ninitconssadded);
2381 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2382 branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE, cutoff) );
2385 if( !(*cutoff) && !(*unbounded) )
2403 assert(lp->
solved || *lperror);
2409 *propagateagain =
TRUE;
2417 *propagateagain =
TRUE;
2425 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2445 FALSE, &foundsol, unbounded) );
2451 assert(lp->
flushed || *cutoff || *unbounded);
2452 assert(lp->
solved || *lperror || *cutoff || *unbounded);
2458 && nsepastallrounds < maxnsepastallrounds
2462 delayedsepa = delayedsepa && !mustsepa && !(*cutoff);
2463 mustsepa = mustsepa || delayedsepa;
2471 if( !separate || (*cutoff) || (*unbounded)
2477 delayedsepa =
FALSE;
2480 assert(!(*lperror));
2500 oldnlprows = lp->
nrows;
2503 if( !enoughcuts && !delayedsepa )
2505 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2506 actdepth, &enoughcuts, cutoff) );
2521 if( !(*cutoff) && !(*lperror) && !enoughcuts && lp->
solved )
2525 lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2526 &delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );
2530 if( !(*cutoff) && !(*lperror) && !enoughcuts && lp->
solved 2532 && nsepastallrounds >= maxnsepastallrounds-1 && delayedsepa )
2535 tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,
2536 &delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );
2544 SCIP_CALL(
cutpoolSeparate(cutpool, blkmem,
set, stat, eventqueue, eventfilter, lp, sepastore,
FALSE, root,
2545 actdepth, &enoughcuts, cutoff) );
2556 assert( !(*lperror) );
2559 root, actdepth, &enoughcuts, cutoff) );
2563 SCIPsetDebugMsg(
set,
" -> delayed global cut pool detected cutoff\n");
2579 if( *cutoff || *lperror
2594 mustprice = mustprice || !lp->
flushed || (transprob->
ncolvars != npricedcolvars);
2595 mustsepa = mustsepa || !lp->
flushed;
2600 SCIPsetDebugMsg(
set,
" -> separation changed bound: propagate again\n");
2602 *propagateagain =
TRUE;
2614 SCIPsetDebugMsg(
set,
"new initial constraints added during propagation: old=%" SCIP_LONGINT_FORMAT
", new=%" SCIP_LONGINT_FORMAT
"\n",
2617 SCIP_CALL(
SCIPinitConssLP(blkmem,
set, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,
2618 branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE, cutoff) );
2630 assert(lp->
solved || *lperror);
2643 if( stat->
domchgcount != olddomchgcount && (!mustprice || mustsepa) && !(*cutoff)
2647 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
2673 objreldiff =
SCIPrelDiff(lpobjval, stalllpobjval);
2674 SCIPsetDebugMsg(
set,
" -> LP bound moved from %g to %g (reldiff: %g)\n",
2675 stalllpobjval, lpobjval, objreldiff);
2678 objreldiff <= 1e-04 &&
2679 nfracs >= (0.9 - 0.1 * nsepastallrounds) * stallnfracs);
2681 stalllpobjval = lpobjval;
2682 stallnfracs = nfracs;
2691 nsepastallrounds = 0;
2701 if( nsepastallrounds >= maxnsepastallrounds-2 )
2703 SCIPsetDebugMsg(
set,
" -> nsepastallrounds=%d/%d\n", nsepastallrounds, maxnsepastallrounds);
2710 SCIPsetDebugMsg(
set,
"separation round %d/%d finished (%d/%d stall rounds): mustprice=%u, mustsepa=%u, delayedsepa=%u, propagateagain=%u\n",
2711 stat->
nseparounds, maxseparounds, nsepastallrounds, maxnsepastallrounds, mustprice, mustsepa, delayedsepa, *propagateagain);
2717 if( lp->
nrows > oldnlprows )
2719 else if( lp->
nrows < oldnlprows )
2724 if( root && nsepastallrounds >= maxnsepastallrounds )
2727 "Truncate separation round because of stalling (%d stall rounds).\n", maxnsepastallrounds);
2741 else if( !(*lperror) )
2769 lp, branchcand, eventqueue, cliquetable, NULL) );
2782 SCIPsetDebugMsg(
set,
" -> final lower bound: %g (LP status: %d, LP obj: %g)\n",
2810 assert(transprob != NULL);
2811 assert(origprob != NULL);
2812 assert(primal != NULL);
2813 assert(cutoff != NULL);
2826 SCIPsetDebugMsg(
set,
" -> lower bound: %g [%g] (pseudoobj: %g [%g]), cutoff bound: %g [%g]\n",
2835 SCIPsetDebugMsg(
set,
"node is cut off by bounding (lower=%g, upper=%g)\n",
2843 SCIP_CALL(
SCIPconflictAnalyzePseudo(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable, NULL) );
2860 assert(
set != NULL);
2861 assert(relaxation != NULL);
2865 for( r = 0; r <
set->nrelaxs; ++r )
2909 assert(stat != NULL);
2910 assert(tree != NULL);
2912 assert(cutoff != NULL);
2913 assert(unbounded != NULL);
2914 assert(lperror != NULL);
2915 assert(*cutoff ==
FALSE);
2916 assert(*unbounded ==
FALSE);
2917 assert(*lperror ==
FALSE);
2922 if( !initiallpsolved )
2925 SCIP_CALL(
solveNodeInitialLP(blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
2926 pricestore, sepastore, cutpool, branchcand, eventfilter, eventqueue, cliquetable, newinitconss, cutoff, lperror) );
2929 SCIPsetDebugMsg(
set,
"price-and-cut-loop: initial LP status: %d, LP obj: %g\n",
2953 checklprows =
FALSE;
2959 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
2966 SCIP_CALL(
SCIPsolCheck(sol,
set, messagehdlr, blkmem, stat, transprob,
FALSE,
FALSE,
TRUE,
TRUE,
2967 checklprows, &feasible) );
2973 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
2986 if( set->reopt_enable )
2988 assert(reopt != NULL);
3002 origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,
FALSE,
FALSE,
3008 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
3014 SCIPsetDebugMsg(
set,
"solution cuts off root node, stop solution process\n");
3023 if( !(*cutoff) && !(*lperror) )
3029 int oldncutsapplied;
3031 oldnpricedvars = transprob->
ncolvars;
3038 SCIP_CALL(
priceAndCutLoop(blkmem,
set, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,
3039 pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,
3040 eventqueue, cliquetable, fullseparation, propagateagain, cutoff, unbounded, lperror, pricingaborted) );
3047 *solverelaxagain =
TRUE;
3072 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, lperror) );
3077 SCIPsetDebugMsg(
set,
"re-optimized LP without cutoff bound: LP status: %d, LP obj: %g\n",
3135 assert(
set != NULL);
3136 assert(relaxation != NULL);
3137 assert(cutoff != NULL);
3138 assert(solvelpagain != NULL);
3139 assert(propagateagain != NULL);
3140 assert(solverelaxagain != NULL);
3141 assert(relaxcalled != NULL);
3147 for( r = 0; r <
set->nrelaxs && !(*cutoff); ++r )
3152 *relaxcalled =
TRUE;
3167 *solvelpagain =
TRUE;
3168 *propagateagain =
TRUE;
3172 *solvelpagain =
TRUE;
3173 *propagateagain =
TRUE;
3177 *solvelpagain =
TRUE;
3181 *solverelaxagain =
TRUE;
3198 assert(focusnode != NULL);
3203 SCIPsetDebugMsg(
set,
" -> new lower bound given by relaxator %s: %g\n",
3242 assert(
set != NULL);
3243 assert(stat != NULL);
3244 assert(tree != NULL);
3246 assert(branched != NULL);
3247 assert(cutoff != NULL);
3248 assert(infeasible != NULL);
3249 assert(propagateagain != NULL);
3250 assert(solvelpagain != NULL);
3251 assert(solverelaxagain != NULL);
3253 assert(!(*propagateagain));
3254 assert(!(*solvelpagain));
3255 assert(!(*solverelaxagain));
3266 for( h = 0; h <
set->nconshdlrs && enforcerelaxsol; ++h )
3268 if( set->conshdlrs_enfo[h]->consenforelax == NULL && ((! set->conshdlrs_enfo[h]->needscons) ||
3269 (set->conshdlrs_enfo[h]->nconss > 0)) )
3273 enforcerelaxsol =
FALSE;
3286 SCIPmessagePrintVerbInfo(messagehdlr, set->disp_verblevel, verblevel,
"Disable enforcement of relaxation solutions" 3287 " since constraint handler %s does not implement enforelax-callback\n",
3296 if( enforcerelaxsol )
3298 SCIPsetDebugMsg(
set,
"enforcing constraints on relaxation solution\n");
3308 objinfeasible =
FALSE;
3328 if( enforcerelaxsol )
3333 for( h = 0; h <
set->nconshdlrs && !resolved; ++h )
3338 if( enforcerelaxsol )
3343 relaxsol, *infeasible, &result) );
3359 objinfeasible, forced, &result) );
3362 SCIPerrorMessage(
"pseudo enforcing method of constraint handler <%s> separated cuts\n",
3376 SCIPsetDebugMsg(
set,
" -> constraint handler <%s> detected cutoff in enforcement\n",
3383 *propagateagain =
TRUE;
3384 *solvelpagain =
TRUE;
3385 *solverelaxagain =
TRUE;
3393 *propagateagain =
TRUE;
3394 *solvelpagain =
TRUE;
3395 *solverelaxagain =
TRUE;
3404 *solvelpagain =
TRUE;
3405 *solverelaxagain =
TRUE;
3428 *solvelpagain =
TRUE;
3450 assert(objinfeasible);
3455 SCIPerrorMessage(
"invalid result code <%d> from enforcing method of constraint handler <%s>\n",
3474 *propagateagain =
FALSE;
3475 *solvelpagain =
FALSE;
3478 assert(!(*branched) || (resolved && !(*cutoff) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3479 assert(!(*cutoff) || (resolved && !(*branched) && *infeasible && !(*propagateagain) && !(*solvelpagain)));
3480 assert(*infeasible || (!resolved && !(*branched) && !(*cutoff) && !(*propagateagain) && !(*solvelpagain)));
3481 assert(!(*propagateagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));
3482 assert(!(*solvelpagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));
3484 assert(!objinfeasible || *infeasible);
3485 assert(resolved == (*branched || *cutoff || *propagateagain || *solvelpagain));
3489 if( enforcerelaxsol )
3497 SCIPsetDebugMsg(
set,
" -> enforcing result: branched=%u, cutoff=%u, infeasible=%u, propagateagain=%u, solvelpagain=%u, resolved=%u\n",
3498 *branched, *cutoff, *infeasible, *propagateagain, *solvelpagain, resolved);
3528 assert(stat != NULL);
3529 assert(cutoff != NULL);
3530 assert(propagateagain != NULL);
3531 assert(solvelpagain != NULL);
3541 int oldncutsapplied;
3545 SCIP_CALL(
SCIPsepastoreApplyCuts(sepastore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
3546 eventqueue, eventfilter, cliquetable, root, efficiacychoice, cutoff) );
3547 *propagateagain = *propagateagain || (stat->
domchgcount != olddomchgcount);
3548 *solvelpagain =
TRUE;
3551 *solverelaxagain =
TRUE;
3574 assert(
set != NULL);
3575 assert(stat != NULL);
3576 assert(cutoff != NULL);
3577 assert(propagateagain != NULL);
3578 assert(solverelaxagain != NULL);
3581 *cutoff = *cutoff || (tree->
cutoffdepth <= depth);
3591 for( r = 0; r <
set->nrelaxs && !(*solverelaxagain); ++r )
3592 *solverelaxagain = *solverelaxagain || ( !
SCIPrelaxIsSolved(set->relaxs[r], stat) );
3597 *propagateagain =
FALSE;
3598 *solverelaxagain =
FALSE;
3655 assert(
set != NULL);
3656 assert(stat != NULL);
3657 assert(origprob != NULL);
3658 assert(transprob != NULL);
3659 assert(tree != NULL);
3661 assert(primal != NULL);
3662 assert(pricestore != NULL);
3663 assert(sepastore != NULL);
3665 assert(branchcand != NULL);
3666 assert(cutpool != NULL);
3667 assert(delayedcutpool != NULL);
3668 assert(conflict != NULL);
3670 assert(eventfilter != NULL);
3671 assert(eventqueue != NULL);
3672 assert(focusnode != NULL);
3673 assert(heurtiming != NULL);
3674 assert(nlperrors != NULL);
3675 assert(fullpropagation != NULL);
3676 assert(propagateagain != NULL);
3677 assert(afterlpproplps != NULL);
3678 assert(lpsolved != NULL);
3679 assert(solvelpagain != NULL);
3680 assert(solverelaxagain != NULL);
3681 assert(cutoff != NULL);
3682 assert(postpone != NULL);
3683 assert(unbounded != NULL);
3684 assert(lperror != NULL);
3685 assert(pricingaborted != NULL);
3686 assert(forcedenforcement != NULL);
3688 newinitconss =
FALSE;
3690 if( !(*cutoff) && !(*postpone) )
3701 if( ((*afterlpproplps) < stat->
nnodelps && (*lpsolved)) || (*relaxcalled) )
3708 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3710 propagate = propagate || (stat->
nboundchgs > oldnboundchgs);
3714 if( propagate && !(*cutoff) )
3722 *fullpropagation =
FALSE;
3725 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3730 solvelp = solvelp || (lpwasflushed && (!lp->
flushed || newinitconss));
3731 solverelax = solverelax || newinitconss;
3743 SCIPsetDebugMsg(
set,
" -> new lower bound: %g (LP status: %d, LP obj: %g)\n",
3761 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
3762 conflict, cliquetable, cutoff) );
3776 FALSE, propagateagain, unbounded) );
3805 if( *propagateagain )
3807 *solvelpagain = solvelp;
3808 *solverelaxagain = solverelax;
3815 *relaxcalled =
FALSE;
3816 if( solverelax && !(*cutoff) )
3823 cutoff, propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
3827 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3830 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3832 solvelpagain, solverelaxagain) );
3835 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
3846 SCIP_CALL(
solveNodeLP(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,
3847 sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,
3848 initiallpsolved, fullseparation, newinitconss, propagateagain, solverelaxagain, cutoff, unbounded, lperror, pricingaborted) );
3851 *solvelpagain =
FALSE;
3852 SCIPsetDebugMsg(
set,
" -> LP status: %d, LP obj: %g, iter: %" SCIP_LONGINT_FORMAT
", count: %" SCIP_LONGINT_FORMAT
"\n",
3858 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3865 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
3872 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
3879 *forcedenforcement =
TRUE;
3882 "(node %" SCIP_LONGINT_FORMAT
") LP solver hit %s limit in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead\n",
3889 "(node %" SCIP_LONGINT_FORMAT
") LP relaxation is unbounded (LP %" SCIP_LONGINT_FORMAT
")\n", stat->
nnodes, stat->
nlps);
3900 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",
3902 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") -> have to call PerPlex() (feature not yet implemented)\n", stat->
nnodes);
3909 *forcedenforcement =
TRUE;
3912 "(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",
3918 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
3919 cliquetable, cutoff) );
3927 *solverelaxagain = *solverelaxagain && *relaxcalled;
3930 if( solverelax && !(*cutoff) )
3933 propagateagain, solvelpagain, solverelaxagain, relaxcalled) );
3937 *cutoff = *cutoff || (tree->
cutoffdepth <= actdepth);
3940 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
3942 solvelpagain, solverelaxagain) );
3945 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,
3946 cliquetable, cutoff) );
3961 assert(
set != NULL);
3962 assert(stat != NULL);
3964 return (set->nactivepricers == 0 && !set->reopt_enable
3965 && (set->presol_maxrestarts == -1 || stat->
nruns <= set->presol_maxrestarts)
3966 && (set->limit_restarts == -1 || stat->
nruns <= set->limit_restarts));
3969 #define restartAllowed(set,stat) ((set)->nactivepricers == 0 && !set->reopt_enable && ((set)->presol_maxrestarts == -1 || (stat)->nruns <= (set)->presol_maxrestarts) \ 3970 && (set->limit_restarts == -1 || stat->nruns <= set->limit_restarts)) 4030 assert(
set != NULL);
4031 assert(stat != NULL);
4032 assert(origprob != NULL);
4033 assert(transprob != NULL);
4034 assert(tree != NULL);
4035 assert(primal != NULL);
4038 assert(cutoff != NULL);
4039 assert(postpone != NULL);
4040 assert(unbounded != NULL);
4041 assert(infeasible != NULL);
4042 assert(restart != NULL);
4043 assert(afternodeheur != NULL);
4048 *infeasible =
FALSE;
4050 *afternodeheur =
FALSE;
4052 pricingaborted =
FALSE;
4055 assert(focusnode != NULL);
4065 SCIPsetDebugMsg(
set,
"Processing node %" SCIP_LONGINT_FORMAT
" in depth %d, %d siblings\n",
4076 focusnodehaslp = (
set->lp_solvedepth == -1 || actdepth <=
set->lp_solvedepth);
4077 focusnodehaslp = focusnodehaslp && (
set->lp_solvefreq >= 1 && actdepth %
set->lp_solvefreq == 0);
4078 focusnodehaslp = focusnodehaslp || (actdepth == 0 &&
set->lp_solvefreq == 0);
4080 focusnodehaslp =
set->reopt_enable ? focusnodehaslp &&
SCIPreoptGetSolveLP(reopt,
set, focusnode) : focusnodehaslp;
4094 initiallpsolved =
FALSE;
4095 fullseparation =
TRUE;
4101 solverelaxagain =
TRUE;
4102 solvelpagain =
TRUE;
4103 propagateagain =
TRUE;
4104 fullpropagation =
TRUE;
4105 forcedlpsolve =
FALSE;
4108 while( !(*cutoff) && !(*postpone) && (solverelaxagain || solvelpagain || propagateagain) && nlperrors <
MAXNLPERRORS && !(*restart) )
4120 *infeasible =
FALSE;
4126 relaxcalled =
FALSE;
4127 forcedenforcement =
FALSE;
4128 afterlpproplps = -1L;
4130 while( !lperror && !(*cutoff) && (propagateagain || solvelpagain || solverelaxagain
4131 || (afterlpproplps < stat->nnodelps && lpsolved) || relaxcalled) )
4133 solverelax = solverelaxagain;
4134 solverelaxagain =
FALSE;
4135 solvelp = solvelpagain;
4136 solvelpagain =
FALSE;
4137 propagate = propagateagain;
4138 propagateagain =
FALSE;
4141 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4142 conflict, cliquetable, cutoff) );
4145 SCIPsetDebugMsg(
set,
" -> node solving loop: call propagators that are applicable before%s LP is solved\n",
4146 lpsolved ?
" and after" :
"");
4147 SCIP_CALL(
propAndSolve(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,
4148 relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,
4149 eventqueue, cliquetable, focusnode, actdepth, propagate, solvelp, solverelax, forcedlpsolve, initiallpsolved,
4150 fullseparation, &afterlpproplps, &heurtiming, &nlperrors, &fullpropagation, &propagateagain, &lpsolved, &relaxcalled,
4151 &solvelpagain, &solverelaxagain, cutoff, postpone, unbounded, stopped, &lperror, &pricingaborted, &forcedenforcement) );
4152 initiallpsolved |= lpsolved;
4159 fullseparation =
FALSE;
4162 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4171 if( actdepth == 0 && !(*afternodeheur) )
4175 *afternodeheur =
TRUE;
4180 *cutoff, &foundsol, unbounded) );
4185 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4193 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
4201 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
4217 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" cannot be dealt with\n",
4223 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- using pseudo solution instead (loop %d)\n",
4231 propagateagain =
TRUE;
4232 solvelpagain =
TRUE;
4233 solverelaxagain =
TRUE;
4239 if( !(*postpone) && !(*cutoff) && !solverelaxagain && !solvelpagain && !propagateagain )
4250 *infeasible =
FALSE;
4254 SCIP_CALL(
enforceConstraints(blkmem,
set, messagehdlr, stat, transprob, primal, tree, lp, relaxation, sepastore,
4255 branchcand, &branched, cutoff, infeasible, &propagateagain, &solvelpagain, &solverelaxagain,
4256 forcedenforcement) );
4257 assert(branched == (tree->
nchildren > 0));
4258 assert(!branched || (!(*cutoff) && *infeasible && !propagateagain && !solvelpagain));
4259 assert(!(*cutoff) || (!branched && *infeasible && !propagateagain && !solvelpagain));
4260 assert(*infeasible || (!branched && !(*cutoff) && !propagateagain && !solvelpagain));
4261 assert(!propagateagain || (!branched && !(*cutoff) && *infeasible));
4262 assert(!solvelpagain || (!branched && !(*cutoff) && *infeasible));
4267 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4269 &solvelpagain, &solverelaxagain) );
4272 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4275 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4284 if( pricingaborted && !(*infeasible) && !(*cutoff) && !(*postpone) )
4298 SCIP_CALL(
SCIPprimalTrySol(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4318 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4346 wasforcedlpsolve = forcedlpsolve;
4347 forcedlpsolve =
FALSE;
4348 if( (*infeasible) && !(*cutoff) && !(*postpone)
4350 && !solverelaxagain && !solvelpagain && !propagateagain && !branched )
4369 assert( nlpcands > 0 );
4372 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on LP solution with %d fractionals\n",
4374 SCIP_CALL(
SCIPbranchExecLP(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4385 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on %d external branching candidates.\n",
4387 SCIP_CALL(
SCIPbranchExecExtern(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,
4396 SCIPsetDebugMsg(
set,
"infeasibility in depth %d was not resolved: branch on pseudo solution with %d unfixed integers\n",
4398 SCIP_CALL(
SCIPbranchExecPseudo(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
4412 "Starting spatial branch-and-bound on unbounded variable <%s> ([%g,%g]) - cannot guarantee finite termination.\n",
4429 SCIPerrorMessage(
"LP branching rule added constraint, which was not allowed this time\n");
4432 propagateagain =
TRUE;
4433 solvelpagain =
TRUE;
4434 solverelaxagain =
TRUE;
4439 propagateagain =
TRUE;
4440 solvelpagain =
TRUE;
4441 solverelaxagain =
TRUE;
4447 solvelpagain =
TRUE;
4448 solverelaxagain =
TRUE;
4472 if( transprob->
ncontvars == 0 && set->nactivepricers == 0 )
4475 SCIPsetDebugMsg(
set,
" -> cutoff because all variables are fixed in current node\n");
4501 if( pricingaborted )
4503 SCIPerrorMessage(
"pricing was aborted, but no branching could be created!\n");
4507 if( wasforcedlpsolve )
4510 SCIPerrorMessage(
"LP was solved, all integers fixed, some constraint still infeasible, but no branching could be created!\n");
4527 "(node %" SCIP_LONGINT_FORMAT
") forcing the solution of an LP (last LP %" SCIP_LONGINT_FORMAT
")...\n", stat->
nnodes, stat->
nlps);
4531 solvelpagain =
TRUE;
4532 forcedlpsolve =
TRUE;
4537 SCIPerrorMessage(
"invalid result code <%d> from SCIPbranchLP(), SCIPbranchExt() or SCIPbranchPseudo()\n", result);
4540 assert(*cutoff || solvelpagain || propagateagain || branched);
4541 assert(!(*cutoff) || (!solvelpagain && !propagateagain && !branched));
4542 assert(!solvelpagain || (!(*cutoff) && !branched));
4543 assert(!propagateagain || (!(*cutoff) && !branched));
4544 assert(!branched || (!solvelpagain && !propagateagain));
4545 assert(branched == (tree->
nchildren > 0));
4548 SCIP_CALL(
applyCuts(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,
4550 &solvelpagain, &solverelaxagain) );
4553 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );
4556 updateLoopStatus(
set, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);
4564 SCIPsetDebugMsg(
set,
"node solving iteration %d finished: cutoff=%u, postpone=%u, propagateagain=%u, solverelaxagain=%u, solvelpagain=%u, nlperrors=%d, restart=%u\n",
4565 nloops, *cutoff, *postpone, propagateagain, solverelaxagain, solvelpagain, nlperrors, *restart);
4571 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
4576 SCIPerrorMessage(
"(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles in LP %" SCIP_LONGINT_FORMAT
" -- aborting\n", stat->
nnodes, stat->
nlps);
4581 restartfac =
set->presol_subrestartfac;
4583 restartfac = MIN(restartfac, set->presol_restartfac);
4589 if( actdepth == 0 && !(*cutoff) && !(*unbounded) && !(*postpone) )
4660 if( checksol || set->misc_exactsolve )
4663 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4668 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4669 eventqueue, eventfilter, &sol, &foundsol) );
4699 if( checksol || set->misc_exactsolve )
4702 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4707 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4708 eventqueue, eventfilter, &sol, &foundsol) );
4735 if( checksol || set->misc_exactsolve )
4738 SCIP_CALL(
SCIPprimalTrySolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4743 SCIP_CALL(
SCIPprimalAddSolFree(primal, blkmem,
set, messagehdlr, stat, origprob, transprob, tree, reopt, lp,
4744 eventqueue, eventfilter, &sol, &foundsol) );
4806 assert(
set != NULL);
4807 assert(blkmem != NULL);
4808 assert(stat != NULL);
4809 assert(transprob != NULL);
4810 assert(tree != NULL);
4812 assert(pricestore != NULL);
4813 assert(sepastore != NULL);
4814 assert(branchcand != NULL);
4815 assert(cutpool != NULL);
4816 assert(delayedcutpool != NULL);
4817 assert(primal != NULL);
4818 assert(eventfilter != NULL);
4819 assert(eventqueue != NULL);
4820 assert(restart != NULL);
4823 restartfac =
set->presol_subrestartfac;
4825 restartfac = MIN(restartfac, set->presol_restartfac);
4831 if( set->conf_restartnum > 0 )
4835 restartconfnum = (
SCIP_Real)set->conf_restartnum;
4836 for( i = 0; i < stat->nconfrestarts; ++i )
4837 restartconfnum *=
set->conf_restartfac;
4841 assert(restartconfnum >= 0.0);
4879 if( nextnode == NULL )
4884 focusnode = nextnode;
4892 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt,
4893 lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
4908 if( focusnode == NULL )
4931 SCIP_CALL(
solveNode(blkmem,
set, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,
4932 pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,
4933 cliquetable, &cutoff, &postpone, &unbounded, &infeasible, restart, &afternodeheur, &stopped) );
4934 assert(!cutoff || infeasible);
4945 if( !(*restart) && !postpone )
4988 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,
4989 lp, eventqueue, eventfilter,
FALSE) );
4992 SCIP_CALL(
applyBounding(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &cutoff) );
5003 if( set->reopt_enable )
5005 assert(reopt != NULL);
5012 else if( !unbounded )
5033 if( set->reopt_enable )
5035 assert(reopt != NULL);
5055 if( set->reopt_enable )
5057 assert(reopt != NULL);
5082 assert(set->misc_exactsolve);
5092 SCIPerrorMessage(
"cannot branch on all-fixed LP -- have to call PerPlex instead\n");
5115 if( !afternodeheur && (!cutoff || nnodes > 0) && !stopped )
5118 cutoff, &foundsol, &unbounded) );
5132 else if( !infeasible && !postpone )
5138 SCIP_CALL(
addCurrentSolution(blkmem,
set, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,
5139 eventqueue, eventfilter,
TRUE) );
5141 if( set->reopt_enable )
5143 assert(reopt != NULL);
5155 SCIP_CALL(
SCIPnodeFocus(&newfocusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5156 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
TRUE,
FALSE) );
5164 if( nsuccessconflicts >= restartconfnum &&
restartAllowed(
set, stat) )
5167 "(run %d, node %" SCIP_LONGINT_FORMAT
") restarting after %" SCIP_LONGINT_FORMAT
" successful conflict analysis calls\n",
5181 "(run %d, node %" SCIP_LONGINT_FORMAT
") restarting: triggering parameter controlled restart)\n",
5197 SCIPsetDebugMsg(
set,
"Processing of node %" SCIP_LONGINT_FORMAT
" in depth %d finished. %d siblings, %d children, %d leaves left\n",
5199 SCIPsetDebugMsg(
set,
"**********************************************************************\n");
5225 if( set->reopt_enable )
5227 assert(reopt != NULL);
5234 SCIP_CALL(
SCIPnodeFocus(&focusnode, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,
5235 branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
5247 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_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_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
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
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 void markRelaxsUnsolved(SCIP_SET *set, SCIP_RELAXATION *relaxation)
int SCIPheurGetPriority(SCIP_HEUR *heur)
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)
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)
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
SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)
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
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 SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
int SCIPbranchcandGetNPrioExternCands(SCIP_BRANCHCAND *branchcand)
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)
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)
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)
void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)
SCIP_Longint nnodesaboverefbound
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)
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)
int SCIPbranchcandGetExternMaxPrio(SCIP_BRANCHCAND *branchcand)
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)
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
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
#define SCIP_EVENTTYPE_NODEFEASIBLE
SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
#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)
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)
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)
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)
int SCIPbranchcandGetNPrioLPCands(SCIP_BRANCHCAND *branchcand)
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
int SCIPbranchcandGetLPMaxPrio(SCIP_BRANCHCAND *branchcand)
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_Real SCIPlpiInfinity(SCIP_LPI *lpi)
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_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
#define SCIP_PROPTIMING_BEFORELP
internal methods for storing cuts in a cut pool
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)
#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_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 allowlocal, 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)
union SCIP_Node::@10 data
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)
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)
int SCIPsepaGetPriority(SCIP_SEPA *sepa)
SCIP_Bool SCIPrelaxationIsLpIncludedForSol(SCIP_RELAXATION *relaxation)
#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