Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://scip.zib.de/doc/html/solve_8c_source.php below:

SCIP Doxygen Documentation: solve.c Source File

assert(stat !=

);

(

->limitchanged )

(

->misc_catchctrlc )

(

->istimelimitfinite )

( (

* (

->limit_time - currtime) / (avgisstoppedfreq + 1e-6)) < nclockskips )

( currtime >=

->limit_time )

( checknodelimits &&

->limit_nodes >= 0 && stat->

>=

->limit_nodes )

( checknodelimits &&

->limit_totalnodes >= 0 && stat->

>=

->limit_totalnodes )

( checknodelimits &&

->limit_stallnodes >= 0 && stat->

>= stat->

+

->limit_stallnodes )

( !checknodelimits )

lpstateforkdepth;

assert(primal !=

);

assert(foundsol !=

);

heurtiming &= ~SCIP_HEURTIMING_AFTERNODE;

assert(nextnode ==

lpstateforkdepth = -1;

assert(tree !=

);

(

,

, depth, heurtiming);

( lp !=

)

(

= 0;

<

->nheurs; ++

)

&ndelayedheurs, &result) );

assert(0 <= ndelayedheurs && ndelayedheurs <= set->nheurs);

assert(delayed !=

);

assert(propagain !=

);

assert(cutoff !=

);

assert(postpone !=

);

( i = 0; i <

->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )

( i = 0; i <

->nconshdlrs && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )

tree->

, timingmask, &result) );

(

,

,

( i = 0; i <

->nprops && !(*postpone) && (!(*cutoff) || !abortoncutoff); ++i )

assert(tree !=

);

assert(cutoff !=

);

( maxproprounds == 0 )

maxproprounds = (depth == 0 ?

->prop_maxroundsroot :

->prop_maxrounds);

( maxproprounds == -1 )

maxproprounds = INT_MAX;

(

,

,

(

(blkmem,

, stat, tree, depth, fullpropagation,

, &delayed, &propagain, timingmask, cutoff, postpone) );

( delayed && (!propagain || propround >= maxproprounds) && !(*cutoff) )

(

(blkmem,

, stat, tree, depth, fullpropagation,

, &delayed, &propagain, timingmask, cutoff, postpone) );

fullpropagation =

;

(

,

, (

*)node);

(

(conflict, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );

assert(var !=

);

assert(tree !=

);

assert(tree->

[actdepth] == focusnode);

node = tree->

[d];

( i = 0; i < nboundchgs; ++i )

var = boundchgs[i].

;

assert(var !=

);

updates[nupdates] = &boundchgs[i];

weight = (nvalidupdates > 0 ? 1.0 / (

)nvalidupdates : 1.0);

lpgain =

(lpgain, 0.0);

( i = 0; i < nupdates; ++i )

var = updates[i]->

;

assert(var !=

);

(

,

,

assert(

->branch_lpgainnorm ==

||

->branch_lpgainnorm ==

);

(

->branch_lpgainnorm ==

)

assert(!updates[i]->redundant);

( j = nbdchginfos-1; j >= 0; --j )

assert(updates[i]->redundant);

assert(j >= 0 || updates[i]->redundant);

delta = updates[i]->

- oldbound;

( j = nbdchginfos-1; j >= 0; --j )

assert(updates[i]->redundant);

assert(j >= 0 || updates[i]->redundant);

delta = updates[i]->

- oldbound;

(

,

,

delta, lpgain, weight);

assert(focusnode !=

);

( i = 0; i < nlpcands; ++i )

estimate +=

(pscdown, pscup);

assert(lp !=

);

assert(cutoff !=

);

(

= 0;

<

->nconshdlrs && !(*cutoff); ++

)

(

->reopt_enable &&

->reopt_usecuts && firstsubtreeinit && !(*cutoff) )

eventfilter, lp, root) );

(

(sepastore, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

assert(transprob !=

);

assert(lp !=

);

assert(cutoff !=

);

oldnvars = transprob->

;

( v = 0; v < transprob->

; ++v )

var = transprob->

[v];

(

(blkmem,

, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

eventfilter, cliquetable, root,

, cutoff) );

( root && transprob->

> oldnvars )

( v = 0; v < transprob->

; ++v )

var = transprob->

[v];

assert(tree !=

);

assert(cutoff !=

);

(

(sepastore, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool, branchcand,

eventqueue, eventfilter, cliquetable, initroot, cutoff) );

( newinitconss )

origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,

,

,

assert(blkmem !=

);

assert(stat !=

);

assert(prob !=

);

assert(primal !=

);

assert(tree !=

);

assert(lp !=

);

vars = prob->

;

nvars = prob->

;

( i = 0; i < nvars; i++ )

assert(stat !=

);

assert(tree !=

);

assert(lp !=

);

assert(cutoff !=

);

assert(lperror !=

);

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, pricestore, sepastore, cutpool,

branchcand, eventqueue, eventfilter, cliquetable, newinitconss, cutoff) );

( focusnode->

== 0 )

assert(lp->

|| *lperror);

(

->misc_exactsolve )

assert(lp !=

);

assert(lperror !=

);

assert(mustsepa !=

);

assert(mustprice !=

);

(

(lp,

, messagehdlr, blkmem, stat, eventqueue, eventfilter, prob,

->lp_iterlim,

,

,

,

, lperror) );

assert(lp->

|| *lperror);

assert(lp !=

);

assert(

->conshdlrs_sepa !=

);

assert(delayed !=

);

assert(enoughcuts !=

);

assert(cutoff !=

);

assert(lperror !=

);

root = (actdepth == 0);

*enoughcuts =

;

*enoughcuts =

;

(

,

, actdepth, onlydelayed);

( i = 0; i <

->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->

&& lp->

*enoughcuts =

;

(

(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );

( i = 0; i <

->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->

&& lp->

(

,

,

*enoughcuts =

;

(

(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );

( i = 0; i <

->nsepas && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->

&& lp->

*enoughcuts =

;

(

(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );

assert(!onlydelayed);

( i = 0; i <

->nconshdlrs && !(*cutoff) && !(*lperror) && !(*enoughcuts) && lp->

&& lp->

(

,

,

*enoughcuts =

;

(

(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, lperror, mustsepa, mustprice) );

(

,

,

*delayed, *enoughcuts, lp->

, *cutoff);

assert(

->conshdlrs_sepa !=

);

assert(delayed !=

);

assert(enoughcuts !=

);

assert(cutoff !=

);

*enoughcuts =

;

root = (actdepth == 0);

(

,

, actdepth, onlydelayed);

*enoughcuts =

;

*enoughcuts =

;

(

,

,

*enoughcuts =

;

assert(!onlydelayed);

*enoughcuts =

;

(

,

,

(

,

,

*delayed, *enoughcuts, *cutoff);

assert(delayed !=

);

assert(cutoff !=

);

enoughcuts =

;

(

(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, prob, primal, tree, lp, sepastore, \

actdepth, 0.0, allowlocal, onlydelayed, delayed, &enoughcuts, cutoff, \

&lperror, &mustsepa, &mustprice) );

(

(blkmem,

, stat, sepastore, sol, actdepth, allowlocal, onlydelayed, delayed, &enoughcuts, cutoff) );

* npricedcolvars,

assert(transprob !=

);

assert(lp !=

);

assert(npricedcolvars !=

);

assert(mustsepa !=

);

assert(lperror !=

);

assert(aborted !=

);

*npricedcolvars = transprob->

;

( maxpricerounds == -1 )

maxpricerounds = INT_MAX;

( !(*lperror) && mustprice && npricerounds < maxpricerounds )

, &foundsol, &unbounded) );

*npricedcolvars = transprob->

;

stoppricing =

;

( p = 0; p <

->nactivepricers && !enoughvars; ++p )

( p == 0 && stopearly )

stoppricing =

;

( stoppricing && !stopearly )

stoppricing =

;

mustprice = !lp->

|| (transprob->

!= *npricedcolvars);

*mustsepa = *mustsepa || !lp->

;

(

(lp,

, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,

,

,

,

, lperror) );

assert(lp->

|| *lperror);

(

(blkmem,

, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

eventfilter, cliquetable,

,

, &cutoff) );

assert(cutoff ==

);

mustprice = mustprice || !lp->

|| (transprob->

!= *npricedcolvars);

*mustsepa = *mustsepa || !lp->

;

(

,

);

(

(lp,

, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,

,

,

,

, lperror) );

assert(lp->

|| *lperror);

( displayinfo && mustprice )

mustprice = mustprice &&

assert(lp->

|| *lperror);

( (

->sepa_poolfreq == 0 && actdepth == 0)

|| (

->sepa_poolfreq > 0 && actdepth %

->sepa_poolfreq == 0) )

(

(cutpool, blkmem,

, stat, eventqueue, eventfilter, lp, sepastore,

, cutpoolisdelayed, root, &result) );

*enoughcuts =

;

maxsepapartialrounds;

nsepastallrounds;

maxsepastallrounds;

assert(blkmem !=

);

assert(stat !=

);

assert(transprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(pricestore !=

);

assert(sepastore !=

);

assert(cutpool !=

);

assert(delayedcutpool !=

);

assert(primal !=

);

assert(cutoff !=

);

assert(unbounded !=

);

assert(lperror !=

);

assert(focusnode !=

);

root = (actdepth == 0);

bounddist = (loclowerbound - glblowerbound)/(primal->

- glblowerbound);

separate = (

->sepa_maxruns == -1 || stat->

<

->sepa_maxruns);

maxseparounds = (root ?

->sepa_maxroundsroot :

->sepa_maxrounds);

( maxseparounds == -1 )

maxseparounds = INT_MAX;

( stat->

> 1 && root &&

->sepa_maxroundsrootsubrun >= 0 )

maxseparounds =

(maxseparounds,

->sepa_maxroundsrootsubrun);

maxsepapartialrounds = INT_MAX;

( !fullseparation &&

->sepa_maxaddrounds >= 0 )

maxsepapartialrounds = stat->

+

->sepa_maxaddrounds;

maxsepastallrounds = root ?

->sepa_maxstallroundsroot :

->sepa_maxstallrounds;

( maxsepastallrounds == -1 )

maxsepastallrounds = INT_MAX;

assert(lp->

|| *lperror);

npricedcolvars = transprob->

;

mustsepa = separate;

delayedsepa =

;

nsepastallrounds = 0;

stallnfracs = INT_MAX;

( !(*cutoff) && !(*unbounded) && !(*lperror) && ( mustprice || mustsepa ) )

( mustprice && !(*lperror) )

(

(blkmem,

, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,

pricestore, sepastore, cutpool, branchcand, eventqueue, eventfilter, cliquetable, root, root, -1, &npricedcolvars,

&mustsepa, lperror, pricingaborted) );

assert(lp->

|| *lperror);

( !(*lperror) && !(*pricingaborted) &&

(lp) )

(

,

);

(

(blkmem,

, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,

branchcand, eventqueue, eventfilter, cliquetable,

,

, cutoff) );

( !(*cutoff) && !(*unbounded) )

assert(lp->

|| *lperror);

*propagateagain =

;

( stat->

> oldnboundchgs )

*propagateagain =

;

, &foundsol, unbounded) );

assert(lp->

|| *cutoff || *unbounded);

assert(lp->

|| *lperror || *cutoff || *unbounded);

mustsepa = mustsepa && separate && !(*cutoff) && !(*unbounded)

&& ( delayedsepa || stat->

< maxsepapartialrounds )

&& nsepastallrounds < maxsepastallrounds

assert(!(*lperror));

delayedsepa = delayedsepa && stat->

>= maxsepapartialrounds;

( !enoughcuts && !delayedsepa )

(

(cutpool, blkmem,

, stat, eventqueue, eventfilter, lp, sepastore,

, root,

actdepth, &enoughcuts, cutoff) );

assert(!(*lperror));

( !(*cutoff) && !enoughcuts )

lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,

&delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );

( !(*cutoff) && !(*lperror) && lp->

&& !enoughcuts && delayedsepa

&& ( stat->

+ 1 >= maxseparounds || nsepastallrounds + 1 >= maxsepastallrounds )

tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,

&delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );

(

(cutpool, blkmem,

, stat, eventqueue, eventfilter, lp, sepastore,

, root,

actdepth, &enoughcuts, cutoff) );

root, actdepth, &enoughcuts, cutoff) );

tree, lp, sepastore, actdepth, bounddist, allowlocal, delayedsepa,

&delayedsepa, &enoughcuts, cutoff, lperror, &mustsepa, &mustprice) );

assert( !(*lperror) );

root, actdepth, &enoughcuts, cutoff) );

( *cutoff || *lperror

mustprice = mustprice || !lp->

|| (transprob->

!= npricedcolvars);

mustsepa = mustsepa || !lp->

;

*propagateagain =

;

(

(blkmem,

, sepastore, cutpool, stat, transprob, origprob, tree, reopt, lp,

branchcand, eventqueue, eventfilter, cliquetable,

,

, cutoff) );

assert(lp->

|| *lperror);

( stat->

!= olddomchgcount && (!mustprice || mustsepa) && !(*cutoff)

objreldiff =

(lpobjval, stalllpobjval);

stalllpobjval, lpobjval, objreldiff);

objreldiff <= 1e-04 &&

nfracs >= (0.9 - 0.1 * nsepastallrounds) * stallnfracs);

stalllpobjval = lpobjval;

stallnfracs = nfracs;

nsepastallrounds = 0;

( nsepastallrounds + 1 >= maxsepastallrounds )

(

,

, nsepastallrounds, maxsepastallrounds);

assert(*cutoff || *lperror || (lp->

&& lp->

));

(

,

,

stat->

, maxseparounds, nsepastallrounds, maxsepastallrounds, mustprice, mustsepa, delayedsepa, *propagateagain);

( root && nsepastallrounds >= maxsepastallrounds )

, maxsepastallrounds);

( !(*cutoff) && !(*lperror) )

lp, branchcand, eventqueue, cliquetable,

) );

assert(transprob !=

);

assert(origprob !=

);

assert(primal !=

);

assert(cutoff !=

);

(

,

,

(

(conflict, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable,

) );

assert(relaxation !=

);

(

= 0;

<

->nrelaxs; ++

)

assert(stat !=

);

assert(tree !=

);

assert(cutoff !=

);

assert(unbounded !=

);

assert(lperror !=

);

assert(*cutoff ==

);

assert(*unbounded ==

);

assert(*lperror ==

);

nlps = stat->

;

( !initiallpsolved )

(

(blkmem,

, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,

pricestore, sepastore, cutpool, branchcand, eventfilter, eventqueue, cliquetable, newinitconss,

forcedlpsolve, cutoff, lperror) );

assert(*cutoff || *lperror || (lp->

&& lp->

));

checklprows =

;

checklprows =

;

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

(

(sol,

, messagehdlr, blkmem, stat, transprob,

,

,

,

,

checklprows, &feasible) );

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

eventqueue, eventfilter, &sol,

,

,

,

, checklprows, &stored) );

(

->reopt_enable )

assert(reopt !=

);

origprob, tree, reopt, lp, branchcand, eventqueue, eventfilter, cliquetable,

,

,

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );

( !(*cutoff) && !(*lperror) )

oldncutsapplied;

oldnpricedvars = transprob->

;

(

(blkmem,

, messagehdlr, stat, mem, transprob, origprob, primal, tree, reopt, lp,

pricestore, sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter,

eventqueue, cliquetable, fullseparation, forcedlpsolve, propagateagain, cutoff, unbounded, lperror, pricingaborted) );

*solverelaxagain =

;

assert(*cutoff || *lperror || (lp->

&& lp->

));

(

(lp,

, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,

,

,

, forcedlpsolve, lperror) );

(

,

,

assert(*cutoff || *lperror || (lp->

&& lp->

));

assert(relaxation !=

);

assert(cutoff !=

);

assert(solvelpagain !=

);

assert(propagateagain !=

);

assert(solverelaxagain !=

);

assert(relaxcalled !=

);

(

= 0;

<

->nrelaxs && !(*cutoff); ++

)

*relaxcalled =

;

*solvelpagain =

;

*propagateagain =

;

*solvelpagain =

;

*propagateagain =

;

*solvelpagain =

;

*solverelaxagain =

;

assert(focusnode !=

);

assert(stat !=

);

assert(tree !=

);

assert(branched !=

);

assert(cutoff !=

);

assert(infeasible !=

);

assert(propagateagain !=

);

assert(solvelpagain !=

);

assert(solverelaxagain !=

);

assert(!(*propagateagain));

assert(!(*solvelpagain));

assert(!(*solverelaxagain));

(

= 0;

<

->nconshdlrs && enforcerelaxsol; ++

)

(

->conshdlrs_enfo[

]->consenforelax ==

&& ((!

->conshdlrs_enfo[

]->needscons) ||

(

->conshdlrs_enfo[

]->nconss > 0)) )

enforcerelaxsol =

;

,

( enforcerelaxsol )

objinfeasible =

;

( enforcerelaxsol )

(

= 0;

<

->nconshdlrs && !resolved; ++

)

( enforcerelaxsol )

relaxsol, *infeasible, &result) );

objinfeasible, forced, &result) );

(

,

*infeasible =

;

(

,

,

*infeasible =

;

*propagateagain =

;

*solvelpagain =

;

*solverelaxagain =

;

*infeasible =

;

*propagateagain =

;

*solvelpagain =

;

*solverelaxagain =

;

*infeasible =

;

*solvelpagain =

;

*solverelaxagain =

;

*infeasible =

;

*infeasible =

;

*solvelpagain =

;

*infeasible =

;

assert(objinfeasible);

*infeasible =

;

(

,

*infeasible =

;

*propagateagain =

;

*solvelpagain =

;

assert(!(*branched) || (resolved && !(*cutoff) && *infeasible && !(*propagateagain) && !(*solvelpagain)));

assert(!(*cutoff) || (resolved && !(*branched) && *infeasible && !(*propagateagain) && !(*solvelpagain)));

assert(*infeasible || (!resolved && !(*branched) && !(*cutoff) && !(*propagateagain) && !(*solvelpagain)));

assert(!(*propagateagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));

assert(!(*solvelpagain) || (resolved && !(*branched) && !(*cutoff) && *infeasible));

assert(!objinfeasible || *infeasible);

assert(resolved == (*branched || *cutoff || *propagateagain || *solvelpagain));

( enforcerelaxsol )

(

,

,

*branched, *cutoff, *infeasible, *propagateagain, *solvelpagain, resolved);

assert(stat !=

);

assert(cutoff !=

);

assert(propagateagain !=

);

assert(solvelpagain !=

);

oldncutsapplied;

(

(sepastore, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

eventqueue, eventfilter, cliquetable, root, efficiacychoice, cutoff) );

*propagateagain = *propagateagain || (stat->

!= olddomchgcount);

*solvelpagain =

;

*solverelaxagain =

;

assert(stat !=

);

assert(cutoff !=

);

assert(propagateagain !=

);

assert(solverelaxagain !=

);

*cutoff = *cutoff || (tree->

<= depth);

(

= 0;

<

->nrelaxs && !(*solverelaxagain); ++

)

*propagateagain =

;

*solverelaxagain =

;

assert(stat !=

);

assert(origprob !=

);

assert(transprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(primal !=

);

assert(pricestore !=

);

assert(sepastore !=

);

assert(branchcand !=

);

assert(cutpool !=

);

assert(delayedcutpool !=

);

assert(conflict !=

);

assert(eventfilter !=

);

assert(eventqueue !=

);

assert(focusnode !=

);

assert(heurtiming !=

);

assert(nlperrors !=

);

assert(fullpropagation !=

);

assert(propagateagain !=

);

assert(afterlpproplps !=

);

assert(lpsolved !=

);

assert(solvelpagain !=

);

assert(solverelaxagain !=

);

assert(cutoff !=

);

assert(postpone !=

);

assert(unbounded !=

);

assert(lperror !=

);

assert(pricingaborted !=

);

assert(forcedenforcement !=

);

newinitconss =

;

( !(*cutoff) && !(*postpone) )

( ((*afterlpproplps) < stat->

&& (*lpsolved)) || (*relaxcalled) )

*cutoff = *cutoff || (tree->

<= actdepth);

*afterlpproplps = stat->

;

propagate = propagate || (stat->

> oldnboundchgs);

( propagate && !(*cutoff) )

*fullpropagation =

;

*cutoff = *cutoff || (tree->

<= actdepth);

solvelp = solvelp || (lpwasflushed && (!lp->

|| newinitconss));

solverelax = solverelax || newinitconss;

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,

conflict, cliquetable, cutoff) );

, propagateagain, unbounded) );

( *propagateagain )

*solvelpagain = solvelp;

*solverelaxagain = solverelax;

*relaxcalled =

;

( solverelax && !(*cutoff) )

cutoff, propagateagain, solvelpagain, solverelaxagain, relaxcalled) );

*cutoff = *cutoff || (tree->

<= actdepth);

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,

solvelpagain, solverelaxagain) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );

*unbounded =

;

(

(blkmem,

, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation, pricestore,

sepastore, cutpool, delayedcutpool, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable,

initiallpsolved, fullseparation, newinitconss, forcedlpsolve, propagateagain, solverelaxagain, cutoff, unbounded, lperror, pricingaborted) );

*solvelpagain =

;

*cutoff = *cutoff || (tree->

<= actdepth);

( forcedlpsolve )

*forcedenforcement =

;

*forcedenforcement =

;

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,

cliquetable, cutoff) );

*solverelaxagain = *solverelaxagain && *relaxcalled;

( solverelax && !(*cutoff) )

propagateagain, solvelpagain, solverelaxagain, relaxcalled) );

*cutoff = *cutoff || (tree->

<= actdepth);

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,

solvelpagain, solverelaxagain) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict,

cliquetable, cutoff) );

assert(stat !=

);

->nactivepricers == 0 && !

->reopt_enable

&& (

->presol_maxrestarts == -1 || stat->

<=

->presol_maxrestarts );

assert(stat !=

);

assert(origprob !=

);

assert(transprob !=

);

assert(tree !=

);

assert(primal !=

);

assert(cutoff !=

);

assert(postpone !=

);

assert(unbounded !=

);

assert(infeasible !=

);

assert(restart !=

);

assert(afternodeheur !=

);

*unbounded =

;

*infeasible =

;

*afternodeheur =

;

pricingaborted =

;

assert(focusnode !=

);

focusnodehaslp = (

->lp_solvedepth == -1 || actdepth <=

->lp_solvedepth);

focusnodehaslp = focusnodehaslp && (

->lp_solvefreq >= 1 && actdepth %

->lp_solvefreq == 0);

focusnodehaslp = focusnodehaslp || (actdepth == 0 &&

->lp_solvefreq == 0);

lastlpcount = stat->

;

initiallpsolved =

;

fullseparation =

;

solverelaxagain =

;

solvelpagain =

;

propagateagain =

;

fullpropagation =

;

forcedlpsolve =

;

( !(*cutoff) && !(*postpone) && (solverelaxagain || solvelpagain || propagateagain) && nlperrors <

&& !(*restart) )

*unbounded =

;

*infeasible =

;

relaxcalled =

;

forcedenforcement =

;

afterlpproplps = -1L;

( !lperror && !(*cutoff) && (propagateagain || solvelpagain || solverelaxagain

|| (afterlpproplps < stat->nnodelps && lpsolved) || relaxcalled) )

solverelax = solverelaxagain;

solverelaxagain =

;

solvelp = solvelpagain;

solvelpagain =

;

propagate = propagateagain;

propagateagain =

;

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,

conflict, cliquetable, cutoff) );

(

,

,

lpsolved ?

:

);

(

(blkmem,

, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp,

relaxation, pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter,

eventqueue, cliquetable, focusnode, actdepth, propagate, solvelp, solverelax, forcedlpsolve, initiallpsolved,

fullseparation, &afterlpproplps, &heurtiming, &nlperrors, &fullpropagation, &propagateagain, &lpsolved, &relaxcalled,

&solvelpagain, &solverelaxagain, cutoff, postpone, unbounded, stopped, &lperror, &pricingaborted, &forcedenforcement) );

initiallpsolved |= lpsolved;

fullseparation =

;

(

, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);

( actdepth == 0 && !(*afternodeheur) )

*afternodeheur =

;

*cutoff, &foundsol, unbounded) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );

( forcedlpsolve )

( forcedlpsolve )

( foundsol && !(*cutoff) )

propagateagain =

;

solvelpagain =

;

solverelaxagain =

;

( !(*postpone) && !(*restart) && !(*cutoff) && !solverelaxagain && !solvelpagain && !propagateagain )

lastlpcount = stat->

;

*infeasible =

;

(

(blkmem,

, messagehdlr, stat, transprob, primal, tree, lp, relaxation, sepastore,

branchcand, &branched, cutoff, infeasible, &propagateagain, &solvelpagain, &solverelaxagain,

forcedenforcement) );

assert(branched == (tree->

> 0));

assert(!branched || (!(*cutoff) && *infeasible && !propagateagain && !solvelpagain));

assert(!(*cutoff) || (!branched && *infeasible && !propagateagain && !solvelpagain));

assert(*infeasible || (!branched && !(*cutoff) && !propagateagain && !solvelpagain));

assert(!propagateagain || (!branched && !(*cutoff) && *infeasible));

assert(!solvelpagain || (!branched && !(*cutoff) && *infeasible));

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,

&solvelpagain, &solverelaxagain) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );

(

, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);

( pricingaborted && !(*infeasible) && !(*cutoff) && !(*postpone) && !(*restart) )

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

*infeasible =

;

wasforcedlpsolve = forcedlpsolve;

forcedlpsolve =

;

( (*infeasible) && !(*cutoff) && !(*postpone) && !(*restart)

&& !solverelaxagain && !solvelpagain && !propagateagain && !branched )

assert( nlpcands > 0 );

(

,

,

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,

(

,

,

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, sepastore, branchcand,

(

,

,

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

,

(

);

propagateagain =

;

solvelpagain =

;

solverelaxagain =

;

propagateagain =

;

solvelpagain =

;

solverelaxagain =

;

solvelpagain =

;

solverelaxagain =

;

( transprob->

== 0 &&

->nactivepricers == 0 )

(

,

);

( pricingaborted )

(

);

( wasforcedlpsolve )

(

);

solvelpagain =

;

forcedlpsolve =

;

(

, result);

assert(*cutoff || solvelpagain || propagateagain || branched);

assert(!(*cutoff) || (!solvelpagain && !propagateagain && !branched));

assert(!solvelpagain || (!(*cutoff) && !branched));

assert(!propagateagain || (!(*cutoff) && !branched));

assert(!branched || (!solvelpagain && !propagateagain));

assert(branched == (tree->

> 0));

(

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, relaxation, sepastore, branchcand,

&solvelpagain, &solverelaxagain) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, cutoff) );

(

, stat, tree, actdepth, cutoff, &propagateagain, &solverelaxagain);

(

,

,

nloops, *cutoff, *postpone, propagateagain, solverelaxagain, solvelpagain, nlperrors, *restart);

(

(conflict, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );

restartfac =

->presol_subrestartfac;

( actdepth == 0 )

restartfac =

(restartfac,

->presol_restartfac);

( actdepth == 0 && !(*cutoff) && !(*unbounded) && !(*postpone) )

*unbounded =

;

*infeasible =

;

( checksol ||

->misc_exactsolve )

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

eventqueue, eventfilter, &sol, &foundsol) );

( checksol ||

->misc_exactsolve )

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

eventqueue, eventfilter, &sol, &foundsol) );

( checksol ||

->misc_exactsolve )

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

(

(primal, blkmem,

, messagehdlr, stat, origprob, transprob, tree, reopt, lp,

eventqueue, eventfilter, &sol, &foundsol) );

assert(blkmem !=

);

assert(stat !=

);

assert(transprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(pricestore !=

);

assert(sepastore !=

);

assert(branchcand !=

);

assert(cutpool !=

);

assert(delayedcutpool !=

);

assert(primal !=

);

assert(eventfilter !=

);

assert(eventqueue !=

);

assert(restart !=

);

restartfac =

->presol_subrestartfac;

restartfac =

(restartfac,

->presol_restartfac);

(

->conf_restartnum > 0 )

( i = 0; i < stat->nconfrestarts; ++i )

restartconfnum *=

->conf_restartfac;

assert(restartconfnum >= 0.0);

infeasible =

;

( nextnode ==

)

focusnode = nextnode;

(

(&focusnode, blkmem,

, messagehdlr, stat, transprob, origprob, primal, tree, reopt,

lp, branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,

,

) );

( focusnode ==

)

(

(blkmem,

, messagehdlr, stat, mem, origprob, transprob, primal, tree, reopt, lp, relaxation,

pricestore, sepastore, branchcand, cutpool, delayedcutpool, conflict, conflictstore, eventfilter, eventqueue,

cliquetable, &cutoff, &postpone, &unbounded, &infeasible, restart, &afternodeheur, &stopped) );

assert(!cutoff || infeasible);

( !(*restart) && !postpone )

(

(blkmem,

, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt,

lp, eventqueue, eventfilter,

) );

(

(blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue, conflict, cliquetable, &cutoff) );

(

->reopt_enable )

assert(reopt !=

);

( !unbounded || branched )

(

->reopt_enable )

assert(reopt !=

);

(

->reopt_enable )

assert(reopt !=

);

assert(

->misc_exactsolve);

(

);

( !afternodeheur && (!cutoff ||

> 0) && !stopped )

cutoff, &foundsol, &unbounded) );

( !infeasible && !postpone )

(

(blkmem,

, messagehdlr, stat, origprob, transprob, primal, relaxation, tree, reopt, lp,

eventqueue, eventfilter,

) );

(

->reopt_enable )

assert(reopt !=

);

( postpone )

(

(&newfocusnode, blkmem,

, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,

branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,

,

) );

stat->

, stat->

, nsuccessconflicts);

,

(

,

);

(

->reopt_enable )

assert(reopt !=

);

(

(&focusnode, blkmem,

, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp,

branchcand, conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,

,

) );

( primal->

> 0 )

SCIP_RETCODE SCIPbranchcandGetLPCands(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)

int SCIPbranchcandGetNExternCands(SCIP_BRANCHCAND *branchcand)

SCIP_RETCODE SCIPbranchExecPseudo(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)

int SCIPbranchcandGetNPrioExternCands(SCIP_BRANCHCAND *branchcand)

void SCIPbranchcandClearExternCands(SCIP_BRANCHCAND *branchcand)

int SCIPbranchcandGetExternMaxPrio(SCIP_BRANCHCAND *branchcand)

int SCIPbranchcandGetNPseudoCands(SCIP_BRANCHCAND *branchcand)

int SCIPbranchcandGetNPrioLPCands(SCIP_BRANCHCAND *branchcand)

SCIP_RETCODE SCIPbranchExecExtern(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)

SCIP_RETCODE SCIPbranchExecLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real cutoffbound, SCIP_Bool allowaddcons, SCIP_RESULT *result)

int SCIPbranchcandGetLPMaxPrio(SCIP_BRANCHCAND *branchcand)

internal methods for branching rules and branching candidate storage

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetLastTime(SCIP_CLOCK *clck)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

internal methods for clocks and timing issues

SCIP_Longint SCIPgetConcurrentMemTotal(SCIP *scip)

int SCIPgetNConcurrentSolvers(SCIP *scip)

helper functions for concurrent scip solvers

internal methods for conflict analysis

int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)

SCIP_RETCODE SCIPconflictAnalyzePseudo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)

SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)

SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)

SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)

SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)

SCIP_RETCODE SCIPconshdlrSeparateLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrEnforceRelaxSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_SOL *relaxsol, SCIP_Bool solinfeasible, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrSeparateSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool execdelayed, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrEnforceLPSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_SEPASTORE *sepastore, SCIP_Bool solinfeasible, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrInitLP(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Bool initkeptconss, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPconshdlrPropagate(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool fullpropagation, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)

SCIP_RETCODE SCIPconshdlrEnforcePseudoSol(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_BRANCHCAND *branchcand, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_Bool forced, SCIP_RESULT *result)

internal methods for constraints and constraint handlers

SCIP_RETCODE SCIPcutpoolSeparate(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, SCIP_RESULT *result)

internal methods for storing cuts in a cut pool

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPdispPrintLine(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, FILE *file, SCIP_Bool forcedisplay, SCIP_Bool endline)

internal methods for displaying runtime statistics

SCIP_RETCODE SCIPeventChgNode(SCIP_EVENT *event, SCIP_NODE *node)

SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)

SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)

internal methods for managing events

SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)

SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)

SCIP_Real SCIPgetTransObjscale(SCIP *scip)

SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)

SCIP_PROPTIMING SCIPconshdlrGetPropTiming(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrWasSolSeparationDelayed(SCIP_CONSHDLR *conshdlr)

int SCIPconshdlrGetSepaPriority(SCIP_CONSHDLR *conshdlr)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrWasLPSeparationDelayed(SCIP_CONSHDLR *conshdlr)

SCIP_Bool SCIPconshdlrWasPropagationDelayed(SCIP_CONSHDLR *conshdlr)

int SCIPheurGetPriority(SCIP_HEUR *heur)

const char * SCIPheurGetName(SCIP_HEUR *heur)

BMS_BUFMEM * SCIPbuffer(SCIP *scip)

SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

SCIP_Bool SCIPnodeIsActive(SCIP_NODE *node)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_Bool SCIPnodeIsPropagatedAgain(SCIP_NODE *node)

SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)

const char * SCIPpricerGetName(SCIP_PRICER *pricer)

SCIP_Bool SCIPpropWasDelayed(SCIP_PROP *prop)

const char * SCIPpropGetName(SCIP_PROP *prop)

int SCIPpropGetPriority(SCIP_PROP *prop)

SCIP_PROPTIMING SCIPpropGetTimingmask(SCIP_PROP *prop)

void SCIPrelaxMarkUnsolved(SCIP_RELAX *relax)

const char * SCIPrelaxGetName(SCIP_RELAX *relax)

int SCIPrelaxGetPriority(SCIP_RELAX *relax)

SCIP_Bool SCIPsepaWasSolDelayed(SCIP_SEPA *sepa)

int SCIPsepaGetPriority(SCIP_SEPA *sepa)

const char * SCIPsepaGetName(SCIP_SEPA *sepa)

SCIP_Bool SCIPsepaWasLPDelayed(SCIP_SEPA *sepa)

SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)

SCIP_RETCODE SCIPprintRay(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)

SCIP_Real SCIPgetPrimalbound(SCIP *scip)

SCIP_Real SCIPgetUpperbound(SCIP *scip)

SCIP_Real SCIPgetGap(SCIP *scip)

SCIP_Real SCIPgetDualbound(SCIP *scip)

SCIP_Real SCIPgetLowerbound(SCIP *scip)

SCIP_Longint SCIPgetNLimSolsFound(SCIP *scip)

void SCIPstoreSolutionGap(SCIP *scip)

SCIP_Longint SCIPgetNBestSolsFound(SCIP *scip)

SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)

int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)

SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)

int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)

void SCIPregressionAddObservation(SCIP_REGRESSION *regression, SCIP_Real x, SCIP_Real y)

SCIP_RETCODE SCIPheurExec(SCIP_HEUR *heur, SCIP_SET *set, SCIP_PRIMAL *primal, int depth, int lpstateforkdepth, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, int *ndelayedheurs, SCIP_RESULT *result)

SCIP_Bool SCIPheurShouldBeExecuted(SCIP_HEUR *heur, int depth, int lpstateforkdepth, SCIP_HEURTIMING heurtiming, SCIP_Bool *delayed)

internal methods for primal heuristics

void SCIPresetInterrupted(void)

SCIP_Bool SCIPterminated(void)

SCIP_Bool SCIPinterrupted(void)

methods for catching the user CTRL-C interrupt

SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)

SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)

void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)

SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)

SCIP_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 forcedlpsolve, SCIP_Bool *lperror)

SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)

SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)

SCIP_RETCODE SCIPlpRemoveRedundantRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)

SCIP_Bool SCIPlpDiving(SCIP_LP *lp)

SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)

SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

int SCIPlpGetNCols(SCIP_LP *lp)

void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)

SCIP_RETCODE SCIPlpGetPrimalRay(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *ray)

int SCIPlpGetNRows(SCIP_LP *lp)

SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

internal methods for LP management

interface methods for specific LP solvers

size_t BMSgetNUsedBufferMemory(BMS_BUFMEM *buffer)

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)

void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)

SCIP_RETCODE SCIPnodeselSelect(SCIP_NODESEL *nodesel, SCIP_SET *set, SCIP_NODE **selnode)

internal methods for node selectors and node priority queues

SCIP_RETCODE SCIPpricerExec(SCIP_PRICER *pricer, SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_Real *lowerbound, SCIP_Bool *stopearly, SCIP_RESULT *result)

internal methods for variable pricers

void SCIPpricestoreStartInitialLP(SCIP_PRICESTORE *pricestore)

SCIP_RETCODE SCIPpricestoreApplyVars(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)

int SCIPpricestoreGetNVars(SCIP_PRICESTORE *pricestore)

SCIP_RETCODE SCIPpricestoreAddProbVars(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPpricestoreAddVar(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_VAR *var, SCIP_Real score, SCIP_Bool root)

int SCIPpricestoreGetNBoundResets(SCIP_PRICESTORE *pricestore)

void SCIPpricestoreEndInitialLP(SCIP_PRICESTORE *pricestore)

SCIP_RETCODE SCIPpricestoreResetBounds(SCIP_PRICESTORE *pricestore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)

internal methods for storing priced variables

SCIP_RETCODE SCIPprimalTrySolFree(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)

SCIP_RETCODE SCIPprimalTrySol(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)

SCIP_RETCODE SCIPprimalAddSolFree(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL **sol, SCIP_Bool *stored)

internal methods for collecting primal CIP solutions and primal informations

SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)

SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

void SCIPprobStoreRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool roothaslp)

SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)

void SCIPprobUpdateBestRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)

SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)

internal methods for storing and manipulating the main problem

SCIP_RETCODE SCIPpropExec(SCIP_PROP *prop, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool execdelayed, SCIP_Bool instrongbranching, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)

internal methods for propagators

public methods for managing constraints

public methods for primal heuristics

public methods for message output

public data structures and miscellaneous methods

public methods for variable pricers

public methods for propagators

public methods for relaxation handlers

public methods for separators

public methods for branch and bound tree

public methods for problem variables

void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)

SCIP_Real SCIPrelaxationGetSolObj(SCIP_RELAXATION *relaxation)

SCIP_Bool SCIPrelaxIsSolved(SCIP_RELAX *relax, SCIP_STAT *stat)

SCIP_RETCODE SCIPrelaxExec(SCIP_RELAX *relax, SCIP_SET *set, SCIP_TREE *tree, SCIP_STAT *stat, int depth, SCIP_Real *lowerbound, SCIP_RESULT *result)

SCIP_Bool SCIPrelaxationIsLpIncludedForSol(SCIP_RELAXATION *relaxation)

SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)

internal methods for relaxators

SCIP_RETCODE SCIPreoptCheckCutoff(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_EVENTTYPE eventtype, SCIP_LP *lp, SCIP_LPSOLSTAT lpsolstat, SCIP_Bool isrootnode, SCIP_Bool isfocusnode, SCIP_Real lowerbound, int effectiverootdepth)

SCIP_RETCODE SCIPreoptApplyCuts(SCIP_REOPT *reopt, SCIP_NODE *node, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool root)

SCIP_Bool SCIPreoptGetSolveLP(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node)

data structures and methods for collecting reoptimization information

public methods for concurrent solving mode

public methods for memory management

public methods for global and local (sub)problems

public methods for solutions

public methods for querying solving statistics

SCIP_RETCODE SCIPsepaExecLP(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, int depth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)

SCIP_RETCODE SCIPsepaExecSol(SCIP_SEPA *sepa, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int depth, SCIP_Bool allowlocal, SCIP_Bool execdelayed, SCIP_RESULT *result)

internal methods for separators

void SCIPsepastoreEndInitialLP(SCIP_SEPASTORE *sepastore)

SCIP_RETCODE SCIPsepastoreClearCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)

int SCIPsepastoreGetNCuts(SCIP_SEPASTORE *sepastore)

SCIP_RETCODE SCIPsepastoreAddCut(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool root, SCIP_Bool *infeasible)

void SCIPsepastoreStartForceCuts(SCIP_SEPASTORE *sepastore)

void SCIPsepastoreEndForceCuts(SCIP_SEPASTORE *sepastore)

void SCIPsepastoreStartInitialLP(SCIP_SEPASTORE *sepastore)

SCIP_RETCODE SCIPsepastoreApplyCuts(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice, SCIP_Bool *cutoff)

int SCIPsepastoreGetNCutsApplied(SCIP_SEPASTORE *sepastore)

internal methods for storing separated cuts

SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)

int SCIPsetGetSepaMaxcuts(SCIP_SET *set, SCIP_Bool root)

SCIP_Bool SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsDualfeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

void SCIPsetSortRelaxs(SCIP_SET *set)

SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

void SCIPsetSortPricers(SCIP_SET *set)

void SCIPsetSortSepas(SCIP_SET *set)

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

void SCIPsetSortProps(SCIP_SET *set)

SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

void SCIPsetSortHeurs(SCIP_SET *set)

SCIP_Real SCIPsetGetSepaMaxcutsGenFactor(SCIP_SET *set, SCIP_Bool root)

SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

int SCIPsetGetPriceMaxvars(SCIP_SET *set, SCIP_Bool root)

SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)

SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetAllocBufferArray(set, ptr, num)

#define SCIPsetReallocBufferArray(set, ptr, num)

SCIP_RETCODE SCIPsolCreateRelaxSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolCheck(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)

SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)

SCIP_RETCODE SCIPsolCreateCurrentSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolSetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPsolCreatePseudoSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsolCreateLPSol(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_HEUR *heur)

SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)

SCIP_RETCODE SCIPsolCreate(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_HEUR *heur)

internal methods for storing primal CIP solutions

static SCIP_RETCODE cutpoolSeparate(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_Bool cutpoolisdelayed, SCIP_Bool root, int actdepth, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff)

static SCIP_RETCODE enforceConstraints(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_Bool *branched, SCIP_Bool *cutoff, SCIP_Bool *infeasible, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool forced)

static SCIP_RETCODE updateEstimate(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)

enum PseudocostFlag PSEUDOCOSTFLAG

static SCIP_RETCODE applyBounding(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)

static SCIP_RETCODE solveNodeInitialLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool forcedlpsolve, SCIP_Bool *cutoff, SCIP_Bool *lperror)

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 forcedlpsolve, SCIP_Bool *propagateagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted)

static SCIP_RETCODE updatePseudocost(SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous)

SCIP_RETCODE SCIPsolveCIP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *restart)

static SCIP_RETCODE separationRoundSol(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff)

static void updateLoopStatus(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain)

static SCIP_RETCODE propAndSolve(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_NODE *focusnode, int actdepth, SCIP_Bool propagate, SCIP_Bool solvelp, SCIP_Bool solverelax, SCIP_Bool forcedlpsolve, SCIP_Bool initiallpsolved, SCIP_Bool fullseparation, SCIP_Longint *afterlpproplps, SCIP_HEURTIMING *heurtiming, int *nlperrors, SCIP_Bool *fullpropagation, SCIP_Bool *propagateagain, SCIP_Bool *lpsolved, SCIP_Bool *relaxcalled, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *stopped, SCIP_Bool *lperror, SCIP_Bool *pricingaborted, SCIP_Bool *forcedenforcement)

SCIP_RETCODE SCIPpropagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, int depth, int maxproprounds, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff)

static SCIP_RETCODE separationRoundLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, int actdepth, SCIP_Real bounddist, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *enoughcuts, SCIP_Bool *cutoff, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice)

SCIP_RETCODE SCIPinitConssLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool firstsubtreeinit, SCIP_Bool *cutoff)

static SCIP_RETCODE solveNodeRelax(SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_PROB *origprob, int depth, SCIP_Bool beforelp, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain, SCIP_Bool *relaxcalled)

static SCIP_RETCODE 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 forcedlpsolve, SCIP_Bool *propagateagain, SCIP_Bool *solverelaxagain, SCIP_Bool *cutoff, SCIP_Bool *unbounded, SCIP_Bool *lperror, SCIP_Bool *pricingaborted)

static SCIP_RETCODE applyCuts(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_EFFICIACYCHOICE efficiacychoice, SCIP_Bool *cutoff, SCIP_Bool *propagateagain, SCIP_Bool *solvelpagain, SCIP_Bool *solverelaxagain)

static SCIP_RETCODE propagationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, SCIP_Bool fullpropagation, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *propagain, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone)

static SCIP_RETCODE propagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int depth, int maxproprounds, SCIP_Bool fullpropagation, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff, SCIP_Bool *postpone)

SCIP_RETCODE SCIPpriceLoop(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, int *npricedcolvars, SCIP_Bool *mustsepa, SCIP_Bool *lperror, SCIP_Bool *aborted)

SCIP_RETCODE SCIPconstructCurrentLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff)

static SCIP_RETCODE addCurrentSolution(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_RELAXATION *relaxation, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool checksol)

SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)

static SCIP_RETCODE solveNode(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_BRANCHCAND *branchcand, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool *postpone, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *restart, SCIP_Bool *afternodeheur, SCIP_Bool *stopped)

static SCIP_RETCODE updatePrimalRay(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool lperror)

static void markRelaxsUnsolved(SCIP_SET *set, SCIP_RELAXATION *relaxation)

SCIP_RETCODE SCIPseparationRound(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_SEPASTORE *sepastore, SCIP_SOL *sol, int actdepth, SCIP_Bool allowlocal, SCIP_Bool onlydelayed, SCIP_Bool *delayed, SCIP_Bool *cutoff)

static SCIP_Bool restartAllowed(SCIP_SET *set, SCIP_STAT *stat)

static SCIP_RETCODE initLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool root, SCIP_Bool *cutoff)

static SCIP_RETCODE separationRoundResolveLP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_Bool *lperror, SCIP_Bool *mustsepa, SCIP_Bool *mustprice)

static SCIP_Bool isPseudocostUpdateValid(SCIP_VAR *var, SCIP_SET *set, SCIP_Real oldlpsolval, SCIP_Bool updateintegers, SCIP_Bool updatecontinuous)

SCIP_RETCODE SCIPprimalHeuristics(SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_NODE *nextnode, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_Bool *foundsol, SCIP_Bool *unbounded)

internal methods for main solving loop and node processing

void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)

void SCIPstatUpdateMemsaveMode(SCIP_STAT *stat, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_MEM *mem)

internal methods for problem statistics

#define SCIPstatIncrement(stat, set, field)

unsigned int boundchgtype

SCIP_BRANCHINGDATA branchingdata

SCIP_BOUNDCHG * boundchgs

union SCIP_Node::@19 data

SCIP_Longint nbestsolsfound

SCIP_Longint nlimsolsfound

SCIP_Longint nrelaxsolsfound

SCIP_Longint nprimalzeroitlps

SCIP_REGRESSION * regressioncandsobjval

SCIP_Bool disableenforelaxmsg

SCIP_Longint ninfeasleaves

SCIP_Longint ndelayedcutoffs

SCIP_CLOCK * nodeactivationtime

SCIP_Longint externmemestim

SCIP_Longint nrootfirstlpiterations

SCIP_Longint ninitconssadded

SCIP_Longint nlpiterations

SCIP_Longint nnodesaboverefbound

SCIP_Real firstlpdualbound

SCIP_Longint nrootlpiterations

SCIP_Longint ninternalnodes

SCIP_CLOCK * relaxsoltime

SCIP_Longint ntotalinternalnodes

SCIP_BRANCHDIR lastbranchdir

SCIP_CLOCK * pseudosoltime

SCIP_Longint nlpbestsolsfound

SCIP_Longint nrelaxbestsolsfound

SCIP_Longint npsbestsolsfound

SCIP_Longint nisstoppedcalls

SCIP_Longint ndualzeroitlps

SCIP_Longint nnodelpiterations

SCIP_Longint nnodezeroitlps

SCIP_Longint npssolsfound

SCIP_Longint nbarrierzeroitlps

SCIP_Bool branchedunbdvar

SCIP_Longint nlpsolsfound

SCIP_Real lastbranchvalue

SCIP_Longint ninitlpiterations

SCIP_NODE * focuslpstatefork

SCIP_Bool forcinglpmessage

unsigned int pseudocostflag

datastructures for constraints and constraint handlers

datastructures for managing events

data structures for LP management

datastructures for block memory pools and memory buffers

datastructures for collecting primal CIP solutions and primal informations

datastructures for storing and manipulating the main problem

datastructures for global SCIP settings

datastructures for problem statistics

data structures for branch and bound tree

datastructures for problem variables

SCIP_Bool SCIPsyncstoreSolveIsStopped(SCIP_SYNCSTORE *syncstore)

the function declarations for the synchronization store

void SCIPnodeUpdateLowerbound(SCIP_NODE *node, SCIP_STAT *stat, SCIP_SET *set, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real newbound)

SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeCutoff(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, BMS_BLKMEM *blkmem)

SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)

SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)

int SCIPtreeGetFocusDepth(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeSetNodesel(SCIP_TREE *tree, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_NODESEL *nodesel)

void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)

SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)

void SCIPnodeMarkPropagated(SCIP_NODE *node, SCIP_TREE *tree)

int SCIPtreeGetNLeaves(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeCreateChild(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real nodeselprio, SCIP_Real estimate)

SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)

SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)

void SCIPtreeSetFocusNodeLP(SCIP_TREE *tree, SCIP_Bool solvelp)

int SCIPtreeGetNNodes(SCIP_TREE *tree)

SCIP_Bool SCIPtreeHasFocusNodeLP(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeFocus(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool postponed, SCIP_Bool exitsolve)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeUpdateLowerboundLP(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp)

SCIP_RETCODE SCIPtreeCutoff(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real cutoffbound)

SCIP_RETCODE SCIPtreeLoadLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

SCIP_RETCODE SCIPtreeLoadLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool *initroot)

internal methods for branch and bound tree

#define SCIP_EVENTTYPE_FIRSTLPSOLVED

#define SCIP_EVENTTYPE_NODEFEASIBLE

#define SCIP_EVENTTYPE_NODEFOCUSED

#define SCIP_EVENTTYPE_NODEINFEASIBLE

#define SCIP_EVENTTYPE_NODEBRANCHED

#define SCIP_EVENTTYPE_LPSOLVED

enum SCIP_LPSolStat SCIP_LPSOLSTAT

enum SCIP_BoundType SCIP_BOUNDTYPE

@ SCIP_LPSOLSTAT_NOTSOLVED

@ SCIP_LPSOLSTAT_TIMELIMIT

@ SCIP_LPSOLSTAT_UNBOUNDEDRAY

@ SCIP_LPSOLSTAT_INFEASIBLE

@ SCIP_LPSOLSTAT_OBJLIMIT

@ SCIP_LPSOLSTAT_ITERLIMIT

enum SCIP_VerbLevel SCIP_VERBLEVEL

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_EFFICIACYCHOICE_LP

@ SCIP_EFFICIACYCHOICE_RELAX

enum SCIP_Efficiacychoice SCIP_EFFICIACYCHOICE

@ SCIP_STATUS_TOTALNODELIMIT

@ SCIP_STATUS_BESTSOLLIMIT

@ SCIP_STATUS_PRIMALLIMIT

@ SCIP_STATUS_USERINTERRUPT

@ SCIP_STATUS_STALLNODELIMIT

@ SCIP_STATUS_RESTARTLIMIT

#define SCIP_HEURTIMING_BEFOREPRESOL

#define SCIP_HEURTIMING_DURINGPRICINGLOOP

#define SCIP_HEURTIMING_AFTERPSEUDONODE

#define SCIP_HEURTIMING_AFTERPROPLOOP

unsigned int SCIP_PROPTIMING

unsigned int SCIP_HEURTIMING

#define SCIP_HEURTIMING_DURINGLPLOOP

#define SCIP_HEURTIMING_DURINGPRESOLLOOP

#define SCIP_HEURTIMING_AFTERNODE

#define SCIP_PROPTIMING_AFTERLPLOOP

#define SCIP_HEURTIMING_AFTERLPPLUNGE

#define SCIP_HEURTIMING_AFTERPSEUDOPLUNGE

#define SCIP_PROPTIMING_BEFORELP

#define SCIP_HEURTIMING_AFTERLPNODE

#define SCIP_HEURTIMING_AFTERLPLOOP

#define SCIP_HEURTIMING_BEFORENODE

#define SCIP_PROPTIMING_DURINGLPLOOP

@ SCIP_NODETYPE_REFOCUSNODE

@ SCIP_NODETYPE_PROBINGNODE

@ SCIP_NODETYPE_FOCUSNODE

enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_BOUNDCHGTYPE_BRANCHING

SCIP_DOMCHGBOUND domchgbound

SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)

SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)

SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)

internal methods for problem variables

void SCIPvisualSolvedNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)

void SCIPvisualCutoffNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node, SCIP_Bool infeasible)

methods for creating output for visualization tools (VBC, BAK)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4