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

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

SCIP Doxygen Documentation: tree.c Source File

assert(tree !=

);

assert(num <= tree->childrensize);

assert(tree !=

);

assert(num <= tree->pathsize);

assert(tree !=

);

assert(num <= tree->pendingbdchgssize);

assert(elem1 !=

);

assert(elem2 !=

);

assert(fork !=

);

assert(fork !=

);

assert(blkmem !=

);

assert(subroot !=

);

(

,

assert(subroot !=

);

assert(blkmem !=

);

assert(node !=

);

(

);

assert(node !=

);

(

);

assert(probingnode !=

);

(*probingnode)->lpistate =

;

(*probingnode)->lpinorms =

;

(*probingnode)->ncols = (*probingnode)->ninitialcols;

(*probingnode)->nrows = (*probingnode)->ninitialrows;

(*probingnode)->origobjvars =

;

(*probingnode)->origobjvals =

;

(*probingnode)->nchgdobjs = 0;

(

, (*probingnode)->ncols, (*probingnode)->nrows);

assert(probingnode !=

);

assert(probingnode !=

);

assert(*probingnode !=

);

( (*probingnode)->lpistate !=

)

( (*probingnode)->lpinorms !=

)

( (*probingnode)->nchgdobjs > 0 )

assert((*probingnode)->origobjvars !=

);

assert((*probingnode)->origobjvals !=

);

assert(junction !=

);

assert(tree !=

);

assert(pseudofork !=

);

assert(blkmem !=

);

assert(tree !=

);

(*pseudofork)->addedcols =

;

(*pseudofork)->addedrows =

;

(*pseudofork)->nchildren = tree->

;

(

,

(*pseudofork)->nchildren, (*pseudofork)->naddedcols, (*pseudofork)->naddedrows);

( (*pseudofork)->naddedcols > 0 )

( (*pseudofork)->naddedrows > 0 )

( i = 0; i < (*pseudofork)->naddedrows; ++i )

assert(pseudofork !=

);

assert(*pseudofork !=

);

assert((*pseudofork)->nchildren == 0);

assert(blkmem !=

);

( i = 0; i < (*pseudofork)->naddedrows; ++i )

assert(fork !=

);

assert(blkmem !=

);

assert(tree !=

);

(*fork)->nlpistateref = 0;

(*fork)->addedcols =

;

(*fork)->addedrows =

;

(*fork)->nchildren = (

int) tree->

;

(

,

, (*fork)->nchildren, (*fork)->naddedcols, (*fork)->naddedrows);

( (*fork)->naddedcols > 0 )

( (*fork)->naddedrows > 0 )

( i = 0; i < (*fork)->naddedrows; ++i )

assert(fork !=

);

assert(*fork !=

);

assert((*fork)->nchildren == 0);

assert((*fork)->nlpistateref == 0);

assert((*fork)->lpistate ==

);

assert(blkmem !=

);

( i = (*fork)->naddedrows - 1; i >= 0; --i )

assert(subroot !=

);

assert(blkmem !=

);

assert(tree !=

);

(*subroot)->nlpistateref = 0;

(*subroot)->nchildren = (

int) tree->

;

( (*subroot)->ncols != 0 )

(*subroot)->cols =

;

( (*subroot)->nrows != 0 )

(*subroot)->rows =

;

( i = 0; i < (*subroot)->nrows; ++i )

assert(subroot !=

);

assert(*subroot !=

);

assert((*subroot)->nchildren == 0);

assert((*subroot)->nlpistateref == 0);

assert((*subroot)->lpistate ==

);

assert(blkmem !=

);

( i = 0; i < (*subroot)->nrows; ++i )

assert(tree !=

);

assert(sibling !=

);

assert(tree !=

);

assert(child !=

);

assert(tree !=

);

assert(child !=

);

assert(node !=

);

assert(blkmem !=

);

assert(tree !=

);

( parent !=

)

assert(node !=

);

assert(blkmem !=

);

assert(tree !=

);

( parent !=

)

( freeParent && !parent->

)

( !

->reopt_enable && freeParent == !parent->

)

singleChild =

;

assert(node !=

);

(*node)->parent =

;

(*node)->conssetchg =

;

(*node)->domchg =

;

(*node)->number = 0;

(*node)->reoptid = 0;

(*node)->active =

;

(*node)->cutoff =

;

(*node)->reprop =

;

(*node)->repropsubtreemark = 0;

assert(node !=

);

assert(blkmem !=

);

assert(stat !=

);

assert(tree !=

);

(*node)->data.child.arraypos = -1;

assert(node !=

);

assert(*node !=

);

assert(!(*node)->active);

assert(blkmem !=

);

assert(tree !=

);

(

);

assert((*node)->data.sibling.arraypos >= 0);

assert((*node)->data.sibling.arraypos < tree->

);

assert(tree->

[(*node)->data.sibling.arraypos] == *node);

assert((*node)->data.child.arraypos >= 0);

assert((*node)->data.child.arraypos < tree->

);

assert(tree->

[(*node)->data.child.arraypos] == *node);

( (*node)->data.leaf.lpstatefork !=

)

assert(stat !=

);

assert(tree !=

);

(

->reopt_enable )

( node->

== 0 )

(

->misc_calcintegral )

assert(node !=

);

assert(stat !=

);

assert(tree !=

);

assert(node !=

);

assert(tree !=

);

assert(tree !=

);

assert(node !=

);

assert(stat !=

);

assert(tree !=

);

assert(cutoff !=

);

initialreprop = node->

;

( clockisrunning )

assert(!node->

|| *cutoff);

( initialreprop && !(*cutoff) && stat->

> oldnboundchgs )

( clockisrunning )

assert(node !=

);

assert(stat !=

);

assert(tree !=

);

assert(cutoff !=

);

node->

=

->conf_enable &&

->conf_useprop;

(

(node, blkmem,

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

eventfilter, eventqueue, cliquetable, &propcutoff) );

*cutoff = *cutoff || propcutoff;

assert(node !=

);

assert(tree !=

);

assert(node !=

);

assert(cons !=

);

assert(tree !=

);

( cons->

!=

->scip )

assert(node !=

);

assert(tree !=

);

assert(cons !=

);

assert(node !=

);

( addedconsssize < *naddedconss )

( cons = 0; cons < *naddedconss; cons++ )

assert(node !=

);

assert(tree !=

);

( node->

== 0 )

assert(node !=

);

|| node->

== 0);

assert(tree !=

);

assert(var !=

);

assert(node->

|| (infercons ==

&& inferprop ==

));

inferboundtype = boundtype;

newbound =

(newbound, oldub);

newbound =

(newbound, oldlb);

(

,

,

conflictingdepth;

( conflictingdepth >= 0 )

assert(conflictingdepth > 0);

assert(conflictingdepth < tree->pathlen);

(

,

,

assert(!probingchange);

(

,

);

(

,

,

(

->misc_exactsolve )

0.0, infervar, infercons, inferprop, inferinfo, inferboundtype) );

(

(node, blkmem,

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

cliquetable, var, newbound, boundtype,

,

, 0, probingchange) );

assert(node !=

);

|| node->

== 0);

assert(blkmem !=

);

assert(tree !=

);

assert(var !=

);

assert(node->

|| (infercons ==

&& inferprop ==

));

adjustedleft = left;

adjustedright = right;

(

,

,

assert(!probingchange);

(

,

);

(

,

,

(

);

assert(node !=

);

assert(blkmem !=

);

(

,

,

,

, 0, probingchange, added) );

assert(tree !=

);

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

( conflictdepth == 0 )

assert(conflictdepth == -1);

assert(var !=

);

assert(stat !=

);

( node->

== 0 )

assert(lowerbound <= newbound);

assert(lp !=

);

(

->misc_exactsolve )

assert(node !=

);

assert(node !=

);

assert(cutoff !=

);

( i = 0; i < nboundchgs && !(*cutoff); ++i )

( j = 0; j < nimpls; ++j )

(

(node, blkmem,

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

eventqueue, cliquetable, implvars[j], implbounds[j], impltypes[j],

,

, 0,

) );

( j = 0; j < ncliques; ++j )

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

( vars[k] == var && values[k] == varfixing )

( values[k] ==

)

(

(node, blkmem,

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

assert(tree !=

);

assert(startdepth >= 0);

assert(startdepth <= tree->pathlen);

( startdepth == 0 )

( i = startdepth; i < tree->

; ++i )

node = tree->

[i];

assert(node !=

);

assert((

)(node->

) == i);

( i < tree->pathlen-1 )

assert(tree !=

);

assert(commonfork !=

);

assert(newlpfork !=

);

assert(newlpstatefork !=

);

assert(newsubroot !=

);

assert(cutoff !=

);

*commonfork =

;

*newlpstatefork =

;

*newsubroot =

;

lpfork = lpfork->

;

( lpfork ==

)

*newlpfork = lpfork;

lpstatefork = lpfork;

lpstatefork = lpstatefork->

;

( lpstatefork ==

)

( lpstatefork->

)

*newlpstatefork = lpstatefork;

subroot = lpstatefork;

subroot = subroot->

;

( subroot ==

)

*newsubroot = subroot;

lpstatefork =

;

assert(fork !=

);

assert(fork !=

);

( lpstatefork ==

assert(lpfork ==

|| !lpfork->

|| lpfork == fork);

assert(lpstatefork ==

|| !lpstatefork->

|| lpstatefork == fork);

assert(subroot ==

|| !subroot->

|| subroot == fork);

assert(fork !=

);

( lpfork ==

)

( lpfork !=

assert(lpfork->

);

lpfork = lpfork->

;

assert(lpfork ==

( lpstatefork ==

)

lpstatefork = lpfork;

( lpstatefork !=

assert(lpstatefork->

);

lpstatefork = lpstatefork->

;

assert(lpstatefork ==

|| lpstatefork->

<= fork->

);

assert(lpstatefork ==

|| lpstatefork->

);

assert(lpstatefork ==

assert(lpstatefork ==

|| (lpfork !=

&& lpstatefork->

<= lpfork->

));

(

, lpstatefork ==

? -1 : (

)(lpstatefork->

));

( subroot ==

)

subroot = lpstatefork;

assert(subroot->

);

subroot = subroot->

;

assert(subroot ==

|| subroot->

);

assert(subroot ==

|| (lpstatefork !=

&& subroot->

<= lpstatefork->

));

*newlpfork = lpfork;

*newlpstatefork = lpstatefork;

*newsubroot = subroot;

( fork !=

)

neweffectiverootdepth;

assert(tree !=

);

assert(fork ==

|| focusnode !=

);

assert(focusnode ==

|| (!focusnode->

&& !focusnode->

));

assert(cutoff !=

);

focusnodedepth = (focusnode !=

? (int)focusnode->

: -1);

forklen = (fork !=

? (int)fork->

+ 1 : 0);

assert(forklen <= focusnodedepth + 1);

( tree->

> forklen )

assert(tree->

== forklen);

(

(tree, reopt, blkmem,

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

( focusnode != fork )

assert(focusnode !=

);

assert(!focusnode->

);

assert(!focusnode->

);

tree->

[focusnode->

] = focusnode;

focusnode = focusnode->

;

( oldfocusnode !=

)

,

( i = tree->

+ 1; i <= neweffectiverootdepth && !(*cutoff); ++i )

( fork !=

&& fork->

&& !(*cutoff) )

(

(fork, blkmem,

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

conflict, eventfilter, eventqueue, cliquetable, cutoff) );

assert(fork !=

|| !(*cutoff));

( tree->

< focusnodedepth && !(*cutoff) )

lp, branchcand, conflict, eventfilter, eventqueue, cliquetable, cutoff) );

( tree->

== focusnodedepth && !(*cutoff) )

lp, branchcand, conflict, eventfilter, eventqueue, cliquetable, cutoff) );

assert(subroot !=

);

assert(blkmem !=

);

assert(lp !=

);

assert(ncols == 0 || cols !=

);

assert(nrows == 0 || rows !=

);

( c = 0; c < ncols; ++c )

(

= 0;

< nrows; ++

)

assert(fork !=

);

assert(blkmem !=

);

assert(lp !=

);

assert(ncols == 0 || cols !=

);

assert(nrows == 0 || rows !=

);

( c = 0; c < ncols; ++c )

(

= 0;

< nrows; ++

)

assert(pseudofork !=

);

assert(blkmem !=

);

assert(lp !=

);

assert(ncols == 0 || cols !=

);

assert(nrows == 0 || rows !=

);

( c = 0; c < ncols; ++c )

(

= 0;

< nrows; ++

)

assert(tree !=

);

( d = 0; d < tree->

; ++d )

node = tree->

[d];

assert(node !=

);

assert((

)(node->

) == d);

( d < tree->pathlen-1 )

(

,

assert(tree !=

);

assert(blkmem !=

);

assert(lp !=

);

assert(initroot !=

);

( lpfork ==

)

assert(lpfork->

);

assert(tree->

[lpfork->

] == lpfork);

lpforkdepth = (int) lpfork->

;

assert(lpforkdepth < tree->pathlen-1);

assert(lpforkdepth < tree->pathlen);

pathnode = tree->

[d];

assert(pathnode !=

);

assert((

)(pathnode->

) == d);

lpstateforkdepth;

assert(tree !=

);

assert(blkmem !=

);

assert(lp !=

);

( lpstatefork ==

)

assert(lpstatefork->

);

assert(tree->

[lpstatefork->

] == lpstatefork);

lpstateforkdepth = (int) lpstatefork->

;

assert(lpstateforkdepth < tree->pathlen-1);

assert(lpstateforkdepth <= tree->correctlpdepth);

checkbdchgs =

;

checkbdchgs =

;

assert(d < tree->pathlen);

assert(stat !=

);

assert(lpstatefork ==

|| lpstatefork->

< (*node)->depth);

assert(lpstatefork ==

pathnode = (*node)->

;

( pathnode !=

&& pathnode != lpstatefork )

pathnode = pathnode->

;

assert(pathnode == lpstatefork);

(*node)->data.leaf.lpstatefork = lpstatefork;

assert(*node ==

);

assert(blkmem !=

);

assert(stat !=

);

assert(tree !=

);

assert(lp !=

);

needdel = (tree->

== tree->

?

->price_delvarsroot :

->price_delvars);

assert(var !=

);

assert(blkmem !=

);

assert(tree !=

);

(

(blkmem,

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

) );

assert(tree !=

);

(

(&tree->

, blkmem,

, stat, eventfilter, eventqueue, tree, reopt, lp, lpstatefork, cutoffbound));

assert(tree !=

);

assert(blkmem !=

);

assert(tree !=

);

assert(lp !=

);

(

(blkmem,

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

) );

assert(blkmem !=

);

assert(tree !=

);

assert(lp !=

);

(

(lp,

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

,

,

,

, &lperror) );

(

(blkmem,

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

) );

assert(blkmem !=

);

assert(tree !=

);

assert(lp !=

);

(

(lp,

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

,

,

,

, &lperror) );

assert(lp->

|| lperror);

(

(blkmem,

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

) );

( subrootCreate(&subroot, blkmem,

, transprob, tree, lp) );

assert(tree !=

);

(

(&nodes[*

-1], blkmem,

, stat, eventfilter, eventqueue, tree, reopt, lp, lpstatefork, cutoffbound) );

assert(tree !=

);

( i = 0; i < tree->

; ++i )

assert(node !=

);

assert(*node ==

assert(*node ==

|| !(*node)->active);

assert(stat !=

);

assert(tree !=

);

assert(lp !=

);

assert(conflictstore !=

);

assert(cutoff !=

);

(

,

,

*node !=

? (

)((*node)->depth) : -1, fork !=

? (

)(fork->

) : -1,

lpfork !=

? (

)(lpfork->

) : -1, lpstatefork !=

? (

)(lpstatefork->

) : -1,

subroot !=

? (

)(subroot->

) : -1, *cutoff);

assert(*node !=

);

assert(!(*node)->active);

(

,

,

(

->reopt_enable )

(*node)->cutoff =

;

( (*node)->depth == 0 )

(

->misc_calcintegral )

assert(lpstatefork ==

|| lpfork !=

);

assert(subroot ==

|| lpstatefork !=

);

assert(subroot ==

|| subroot->

);

( exitsolve && tree->

> 0 )

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

,

, -

(

)) );

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

,

, -

(

)) );

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, tree->

,

assert(!postponed || *node ==

);

assert(*node ==

);

(

(blkmem,

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

assert(oldcutoffdepth == INT_MAX);

( focusnodeToSubroot(blkmem,

, messagehdlr, stat, eventqueue, eventfilter, transprob, origprob, tree, lp, branchcand) );

reopt, lp, branchcand, cliquetable) );

childrenlpstatefork = tree->

;

( selectedchild )

branchcand, cliquetable) );

( selectedchild )

(

(blkmem,

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

assert(lpstatefork ==

assert(childrenlpstatefork ==

assert(lpfork ==

( *node ==

)

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, tree->

,

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, childrenlpstatefork,

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, childrenlpstatefork,

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, tree->

,

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, tree->

,

( c = 0; c < tree->

; ++c )

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

, childrenlpstatefork,

assert(subroot ==

|| (lpstatefork !=

&& subroot->

<= lpstatefork->

));

assert(lpstatefork ==

|| (lpfork !=

&& lpstatefork->

<= lpfork->

));

assert(lpfork ==

|| (*node !=

&& lpfork->

< (*node)->depth));

(

(tree, reopt, blkmem,

, stat, transprob, origprob, primal, lp, branchcand, conflict,

eventfilter, eventqueue, cliquetable, fork, *node, cutoff) );

assert(*node ==

|| tree->

-1 <= (

)(*node)->depth);

assert(tree !=

);

assert(blkmem !=

);

(*tree)->root =

;

( p = 0; p <= 1; ++p )

(*tree)->ndivebdchanges[p] = 0;

(*tree)->divebdchgsize[p] = 1;

(*tree)->path =

;

(*tree)->focusnode =

;

(*tree)->focuslpfork =

;

(*tree)->focuslpstatefork =

;

(*tree)->focussubroot =

;

(*tree)->children =

;

(*tree)->siblings =

;

(*tree)->probingroot =

;

(*tree)->childrenprio =

;

(*tree)->siblingsprio =

;

(*tree)->pathnlpcols =

;

(*tree)->pathnlprows =

;

(*tree)->probinglpistate =

;

(*tree)->probinglpinorms =

;

(*tree)->pendingbdchgs =

;

(*tree)->probdiverelaxsol =

;

(*tree)->nprobdiverelaxsol = 0;

(*tree)->pendingbdchgssize = 0;

(*tree)->npendingbdchgs = 0;

(*tree)->focuslpstateforklpcount = -1;

(*tree)->childrensize = 0;

(*tree)->nchildren = 0;

(*tree)->siblingssize = 0;

(*tree)->nsiblings = 0;

(*tree)->pathlen = 0;

(*tree)->pathsize = 0;

(*tree)->effectiverootdepth = 0;

(*tree)->updatedeffectiverootdepth = 0;

(*tree)->lastbranchparentid = -1L;

(*tree)->correctlpdepth = -1;

(*tree)->cutoffdepth = INT_MAX;

(*tree)->repropdepth = INT_MAX;

(*tree)->repropsubtreecount = 0;

(*tree)->focusnodehaslp =

;

(*tree)->probingnodehaslp =

;

(*tree)->focuslpconstructed =

;

(*tree)->cutoffdelayed =

;

(*tree)->probinglpwasflushed =

;

(*tree)->probinglpwassolved =

;

(*tree)->probingloadlpistate =

;

(*tree)->probinglpwasrelax =

;

(*tree)->probingsolvedlp =

;

(*tree)->forcinglpmessage =

;

(*tree)->sbprobing =

;

(*tree)->probinglpwasprimfeas =

;

(*tree)->probinglpwasdualfeas =

;

(*tree)->probdiverelaxstored =

;

(*tree)->probdiverelaxincludeslp =

;

assert(tree !=

);

assert(*tree !=

);

assert((*tree)->nchildren == 0);

assert((*tree)->nsiblings == 0);

assert((*tree)->focusnode ==

);

( p = 0; p <= 1; ++p )

assert(tree !=

);

assert(var !=

);

assert(tree !=

);

(

(tree, reopt, blkmem,

, stat, eventfilter, eventqueue, lp, tree->

, &tree->

,

,

assert(tree !=

);

(

(&tree->

, blkmem,

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

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

,

) );

assert(tree !=

);

(

(&node, blkmem,

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

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

,

) );

assert(tree !=

);

assert(tree !=

);

assert(stat !=

);

assert(tree !=

);

assert(stat !=

);

assert(lp !=

);

( i = tree->

-1; i >= 0; --i )

( i = tree->

-1; i >= 0; --i )

( branchdir )

(

->nodesel_childsel )

prio = targetvalue - varsol;

prio = varrootsol - varsol;

( !isroot && haslp )

prio *= (varrootsol - varsol + 1.0);

(

,

(

->nodesel_childsel )

prio = varsol - targetvalue;

prio = varsol - varrootsol;

( !isroot && haslp )

prio *= (varsol - varrootsol + 1.0);

(

,

assert(tree !=

);

assert(var !=

);

( estimateinc > 0.0 )

estimate += estimateinc;

assert(tree !=

);

assert(var !=

);

( downchild !=

)

( eqchild !=

)

( upchild !=

)

( scalar == 0.0 )

val = (val - constant) / scalar;

(

,

,

(

,

,

(

,

,

center = (ub + lb) / 2.0;

( val <= center )

uplb = downub + 1.0;

downub = uplb - 1.0;

downub = fixval - 1.0;

uplb = fixval + 1.0;

(

,

,

uplb = downub + 1.0;

(

,

,

(

,

,

(

(node, blkmem,

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

( downchild !=

)

(

,

,

(

(node, blkmem,

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

(

(node, blkmem,

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

( eqchild !=

)

(

,

,

(

(node, blkmem,

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

( upchild !=

)

assert(tree !=

);

assert(var !=

);

( downchild !=

)

( upchild !=

)

(

,

,

(

(node, blkmem,

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

,

( downchild !=

)

(

,

,

(

(node, blkmem,

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

( upchild !=

)

assert(tree !=

);

assert(var !=

);

assert(minwidth >= 0.0);

(

(tree, reopt, blkmem,

, stat, transprob, origprob, lp, branchcand, eventqueue, var, val,

&downchild, &fixchild, &upchild) );

( nchildren !=

)

*nchildren = (downchild !=

? 1 : 0) + (fixchild !=

? 1 : 0) + (upchild !=

? 1 : 0);

( scalar == 0.0 )

val = (val - constant) / scalar;

( widthfactor == 1.0 )

assert(widthfactor > 1.0);

width *= (widthfactor - 1.0) / (pow(widthfactor, (

)(n/2)) - 1.0);

width /= 0.5 + widthfactor * (pow(widthfactor, (

)(n/2)) - 1.0) / (widthfactor - 1.0);

minwidth =

(1.0, minwidth);

( width < minwidth )

(

,

,

( nchildren !=

)

left = val - width/2.0;

right = val + width/2.0;

( left <= right )

(

,

,

left,

(var), right, priority, estimate, right - left);

(

(node, blkmem,

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

(

(node, blkmem,

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

( nchildren !=

)

width *= widthfactor;

( right - left < 0.5 )

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

(

,

,

bnd,

(var), left, priority, estimate, left - bnd);

(

(node, blkmem,

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

(

(node, blkmem,

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

( nchildren !=

)

bnd = right + width;

(

,

,

right,

(var), bnd, priority, estimate, bnd - right);

(

(node, blkmem,

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

(

(node, blkmem,

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

( nchildren !=

)

width *= widthfactor;

idx = preferred ? 0 : 1;

assert(pos < tree->divebdchgsize[idx]);

idx = preferred ? 0 : 1;

assert(variables !=

);

assert(directions !=

);

assert(values !=

);

assert(ndivebdchgs !=

);

( p = 0; p < 2; ++p )

assert(tree !=

);

assert(blkmem !=

);

assert(currentnode !=

);

assert(node !=

);

(

,

,

assert(tree !=

);

assert(lp !=

);

(

,

,

assert(tree !=

);

assert(lpistate !=

);

assert(lpinorms !=

);

assert(tree !=

);

assert(node !=

);

assert(node !=

);

( lpistate ==

)

( lpistate !=

)

lpwasprimfeas, lpwasprimchecked, lpwasdualfeas, lpwasdualchecked) );

( lpinorms !=

)

assert(tree !=

);

assert(node !=

);

assert(tree !=

);

assert(newpathlen >= 1);

( newpathlen < tree->pathlen )

( tree->

> newpathlen )

assert(tree->

== newpathlen);

(

(tree, reopt, blkmem,

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

assert(tree !=

);

(

(tree, reopt, blkmem,

, stat, transprob, origprob, lp, primal, branchcand,

eventqueue, eventfilter, cliquetable, probingdepth) );

assert(tree !=

);

(

(tree, reopt, blkmem,

, stat, transprob, origprob, lp, primal, branchcand,

eventqueue, eventfilter, cliquetable, -1) );

(

(lp,

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

,

,

,

, &lperror) );

);

(

,

);

assert(tree !=

);

assert(relaxation !=

);

assert(transprob !=

);

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

assert(tree !=

);

assert( nvars <= tree->nprobdiverelaxsol );

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

assert(tree !=

);

( i = 0; i < tree->

; ++i )

assert(tree !=

);

( i = 0; i < tree->

; ++i )

assert(tree !=

);

assert(nodesel !=

);

( i = 0; i < tree->

; ++i )

assert(tree !=

);

assert(nodesel !=

);

( i = 0; i < tree->

; ++i )

assert(tree !=

);

assert(tree !=

);

assert(nodesel !=

);

bestnode = bestchild;

bestnode = bestsibling;

bestnode = bestleaf;

assert(tree !=

);

( i = 0; i < tree->

; ++i )

( i = 0; i < tree->

; ++i )

assert(tree !=

);

( i = 0; i < tree->

; ++i )

lowerboundnode = tree->

[i];

( i = 0; i < tree->

; ++i )

lowerboundnode = tree->

[i];

lowerboundnode;

assert(tree !=

);

( i = 0; i < tree->

; ++i )

( i = 0; i < tree->

; ++i )

assert(node !=

);

assert(node !=

);

assert(node !=

);

(

) node->

;

assert(node !=

);

assert(node !=

);

assert(node !=

);

assert(node !=

);

node->

= (

int) reopttype;

assert(node !=

);

assert(node !=

);

assert(

<= 536870911);

assert(node !=

);

assert(node !=

);

count_branchings = (nbranchings !=

);

count_consprop = (nconsprop !=

);

count_prop = (nprop !=

);

( count_branchings )

( count_consprop )

( count_branchings )

( !count_consprop && !count_prop )

( count_consprop )

npseudobranchvars;

assert(node !=

);

npseudobranchvars = 0;

assert(boundchgs !=

);

assert(nboundchgs >= 0);

( i = nboundchgs-1; i >= 0; i--)

npseudobranchvars++;

npseudobranchvars;

assert(node !=

);

assert(vars !=

);

assert(bounds !=

);

assert(boundtypes !=

);

assert(nvars !=

);

assert(varssize >= 0);

assert(boundchgs !=

);

assert(nboundchgs >= 0);

( i = nboundchgs-1; i >= 0; i--)

( varssize >= *nvars )

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

vars[j] = boundchgs[i].

;

bounds[j] = boundchgs[i].

;

assert(node !=

);

assert(node !=

);

assert(branchvars !=

);

assert(branchbounds !=

);

assert(boundtypes !=

);

assert(nbranchvars !=

);

assert(branchvarssize >= 0);

assert(boundchgs !=

);

assert(nboundchgs >= 0);

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

( ; i < nboundchgs; i++)

( branchvarssize >= *nbranchvars )

( i = 0; i < *nbranchvars; i++)

branchvars[i] = boundchgs[i].

;

branchbounds[i] = boundchgs[i].

;

assert(node !=

);

assert(branchvars !=

);

assert(branchbounds !=

);

assert(boundtypes !=

);

assert(nbranchvars !=

);

assert(branchvarssize >= 0);

nodenbranchvars;

start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;

size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);

*nbranchvars += nodenbranchvars;

assert(node !=

);

assert(parent !=

);

assert(branchvars !=

);

assert(branchbounds !=

);

assert(boundtypes !=

);

assert(nbranchvars !=

);

assert(branchvarssize >= 0);

( node != parent )

nodenbranchvars;

start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;

size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);

*nbranchvars += nodenbranchvars;

assert(node !=

);

assert(vars !=

);

assert(varbounds !=

);

assert(varboundtypes !=

);

assert(npropvars !=

);

assert(propvarssize >= 0);

assert(boundchgs !=

);

assert(nboundchgs >= 0);

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

( propvarssize < *npropvars )

( i = nbranchings, pos = 0; pos < *npropvars; ++i )

assert(i < nboundchgs);

vars[pos] = boundchgs[i].

;

varbounds[pos] = boundchgs[i].

;

assert(node !=

);

assert(vars !=

);

assert(varbounds !=

);

assert(varboundtypes !=

);

assert(nvars !=

);

assert(varssize >= 0);

assert(boundchgs !=

);

assert(nboundchgs >= 0);

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

( ; i < nboundchgs; ++i )

( varssize < *nvars )

( i = first_dual, pos = 0; pos < *nvars; ++i )

assert(i < nboundchgs);

vars[pos] = boundchgs[i].

;

varbounds[pos] = boundchgs[i].

;

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

( nbranchings > 0 )

assert(node !=

);

assert(branchvars !=

);

assert(branchbounds !=

);

assert(boundtypes !=

);

assert(nbranchvars !=

);

assert(branchvarssize >= 0);

nodenbranchvars;

start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;

size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);

( *

< nodeswitchsize )

nodeswitches[*

] = start;

*nbranchvars += nodenbranchvars;

assert(node1 !=

);

assert(node2 !=

);

(node1 == node2);

assert(node1 !=

);

assert(node2 !=

);

( node1 != node2 )

assert(node !=

);

assert(node !=

);

assert(node !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

assert(tree !=

);

tree->

;

assert(tree !=

);

assert(tree !=

);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Bool SCIPclockIsRunning(SCIP_CLOCK *clck)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

internal methods for clocks and timing issues

internal methods for storing conflicts

SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)

SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconssetchgAddAddedCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons, int depth, SCIP_Bool focusnode, SCIP_Bool active)

SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)

SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)

SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)

SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)

internal methods for constraints and constraint handlers

#define SCIPdebugCheckLbGlobal(scip, var, lb)

#define SCIPdebugCheckUbGlobal(scip, var, ub)

#define SCIPdebugCheckGlobalLowerbound(blkmem, set)

#define SCIPdebugCheckLocalLowerbound(blkmem, set, node)

#define SCIPdebugRemoveNode(blkmem, set, node)

#define SCIPdebugCheckInference(blkmem, set, node, var, newbound, boundtype)

common defines and data types used in all packages of SCIP

#define SCIP_MAXTREEDEPTH

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPeventChgNode(SCIP_EVENT *event, SCIP_NODE *node)

SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPeventqueueProcess(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)

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)

SCIP_RETCODE SCIPeventqueueDelay(SCIP_EVENTQUEUE *eventqueue)

internal methods for managing events

void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteClosing(FILE *file)

void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)

void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

void SCIPnodeGetAncestorBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)

void SCIPnodeSetReopttype(SCIP_NODE *node, SCIP_REOPTTYPE reopttype)

void SCIPnodeSetReoptID(SCIP_NODE *node, unsigned int id)

void SCIPnodeGetAncestorBranchingsPart(SCIP_NODE *node, SCIP_NODE *parent, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)

void SCIPnodeGetParentBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)

SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

void SCIPnodeGetAncestorBranchingPath(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize, int *nodeswitches, int *nnodes, int nodeswitchsize)

void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)

SCIP_NODE * SCIPnodesGetCommonAncestor(SCIP_NODE *node1, SCIP_NODE *node2)

SCIP_Bool SCIPnodeIsActive(SCIP_NODE *node)

SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)

SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)

SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)

SCIP_Bool SCIPnodesSharePath(SCIP_NODE *node1, SCIP_NODE *node2)

int SCIPnodeGetNAddedConss(SCIP_NODE *node)

SCIP_Real SCIPnodeGetEstimate(SCIP_NODE *node)

void SCIPnodeGetAddedConss(SCIP_NODE *node, SCIP_CONS **addedconss, int *naddedconss, int addedconsssize)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_REOPTTYPE SCIPnodeGetReopttype(SCIP_NODE *node)

unsigned int SCIPnodeGetReoptID(SCIP_NODE *node)

SCIP_Bool SCIPnodeIsPropagatedAgain(SCIP_NODE *node)

SCIP_RETCODE SCIPnodePrintAncestorBranchings(SCIP_NODE *node, FILE *file)

SCIP_DECL_SORTPTRCOMP(SCIPnodeCompLowerbound)

SCIP_CONSSETCHG * SCIPnodeGetConssetchg(SCIP_NODE *node)

const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)

const char * SCIPpropGetName(SCIP_PROP *prop)

SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)

SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)

SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)

SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)

int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)

int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)

SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)

SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)

SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)

int SCIPvarGetBranchPriority(SCIP_VAR *var)

SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

void SCIPvarMarkNotDeletable(SCIP_VAR *var)

SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)

int SCIPsnprintf(char *t, int len, const char *s,...)

SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)

int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)

SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)

methods for implications, variable bounds, and cliques

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

SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)

void SCIProwCapture(SCIP_ROW *row)

SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)

SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)

void SCIPlpMarkSize(SCIP_LP *lp)

SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)

int SCIPlpGetNNewcols(SCIP_LP *lp)

SCIP_RETCODE SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)

SCIP_RETCODE SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)

SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)

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

SCIP_Real SCIPlpGetModifiedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)

SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)

SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)

SCIP_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)

void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)

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 SCIPlpCleanupAll(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)

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

SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)

SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)

SCIP_Bool SCIPlpDiving(SCIP_LP *lp)

void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)

SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)

SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)

SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)

SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)

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

SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)

SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)

SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)

int SCIPlpGetNCols(SCIP_LP *lp)

SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)

int SCIPlpGetNNewrows(SCIP_LP *lp)

int SCIPlpGetNRows(SCIP_LP *lp)

void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)

SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

internal methods for LP management

interface methods for specific LP solvers

#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSallocMemoryArray(ptr, num)

#define BMSfreeMemoryArray(ptr)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

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

SCIP_Real SCIPnodepqGetLowerbound(SCIP_NODEPQ *nodepq, SCIP_SET *set)

int SCIPnodepqLen(const SCIP_NODEPQ *nodepq)

SCIP_RETCODE SCIPnodepqRemove(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node)

int SCIPnodeselCompare(SCIP_NODESEL *nodesel, SCIP_SET *set, SCIP_NODE *node1, SCIP_NODE *node2)

SCIP_RETCODE SCIPnodepqFree(SCIP_NODEPQ **nodepq, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)

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

SCIP_RETCODE SCIPnodepqSetNodesel(SCIP_NODEPQ **nodepq, SCIP_SET *set, SCIP_NODESEL *nodesel)

SCIP_RETCODE SCIPnodepqClear(SCIP_NODEPQ *nodepq, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)

SCIP_NODESEL * SCIPnodepqGetNodesel(SCIP_NODEPQ *nodepq)

SCIP_RETCODE SCIPnodepqInsert(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node)

SCIP_NODE * SCIPnodepqFirst(const SCIP_NODEPQ *nodepq)

int SCIPnodepqCompare(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node1, SCIP_NODE *node2)

SCIP_RETCODE SCIPnodepqCreate(SCIP_NODEPQ **nodepq, SCIP_SET *set, SCIP_NODESEL *nodesel)

SCIP_Real SCIPnodepqGetLowerboundSum(SCIP_NODEPQ *nodepq)

SCIP_NODE * SCIPnodepqGetLowerboundNode(SCIP_NODEPQ *nodepq, SCIP_SET *set)

internal methods for node selectors and node priority queues

internal methods for collecting primal CIP solutions and primal informations

SCIP_RETCODE SCIPprobPerformVarDeletions(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)

SCIP_RETCODE SCIPprobDelVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Bool *deleted)

int SCIPprobGetNVars(SCIP_PROB *prob)

SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)

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

internal methods for storing and manipulating the main problem

internal methods for propagators

public methods for message output

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

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)

data structures and methods for collecting reoptimization information

SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)

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

SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)

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

SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)

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

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

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

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

SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)

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

SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)

SCIP_Real SCIPsetEpsilon(SCIP_SET *set)

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

SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)

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

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

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

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

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

int SCIPsetCalcPathGrowSize(SCIP_SET *set, int num)

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

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

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

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

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

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)

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)

internal methods for problem statistics

#define SCIPstatIncrement(stat, set, field)

union SCIP_BoundChg::@21 data

SCIP_INFERENCEDATA inferencedata

unsigned int boundchgtype

SCIP_CONS ** disabledconss

unsigned int updatedisable

SCIP_BOUNDCHG * boundchgs

SCIP_BOUNDCHG * boundchgs

unsigned int lpwasprimfeas

unsigned int lpwasprimchecked

unsigned int lpwasdualfeas

unsigned int lpwasdualchecked

unsigned int repropsubtreemark

SCIP_PROBINGNODE * probingnode

SCIP_PSEUDOFORK * pseudofork

union SCIP_Node::@19 data

SCIP_CONSSETCHG * conssetchg

SCIP_Bool lpwasdualchecked

SCIP_Bool lpwasprimchecked

SCIP_Longint nearlybacktracks

SCIP_Longint nactiveconssadded

SCIP_Longint nrepropcutoffs

SCIP_Longint ncreatednodesrun

SCIP_CLOCK * nodeactivationtime

SCIP_Longint nprobholechgs

SCIP_Longint ndeactivatednodes

SCIP_Longint nrepropboundchgs

SCIP_Longint nactivatednodes

SCIP_Longint ncreatednodes

unsigned int lpwasdualchecked

unsigned int lpwasdualfeas

unsigned int lpwasprimchecked

unsigned int lpwasprimfeas

SCIP_Bool focuslpconstructed

SCIP_LPISTATE * probinglpistate

SCIP_PENDINGBDCHG * pendingbdchgs

SCIP_Bool probinglpwasdualchecked

SCIP_NODE * focuslpstatefork

SCIP_Bool probinglpwasprimfeas

SCIP_BRANCHDIR * divebdchgdirs[2]

SCIP_Bool probinglpwassolved

SCIP_Bool probinglpwasrelax

SCIP_Bool probingnodehaslp

SCIP_Bool probingobjchanged

SCIP_Real * divebdchgvals[2]

int updatedeffectiverootdepth

SCIP_Bool probdiverelaxincludeslp

SCIP_VAR ** divebdchgvars[2]

SCIP_Bool probingsolvedlp

SCIP_Bool probinglpwasprimchecked

SCIP_LPINORMS * probinglpinorms

SCIP_Bool probinglpwasflushed

SCIP_Longint lastbranchparentid

SCIP_Bool probdiverelaxstored

SCIP_Real * probdiverelaxsol

SCIP_Bool probingloadlpistate

SCIP_Longint focuslpstateforklpcount

SCIP_Bool probinglpwasdualfeas

datastructures for managing events

datastructures for block memory pools and memory buffers

SCIP main data structure.

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

SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetProbingRoot(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeReleaseLPIState(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_LP *lp)

SCIP_RETCODE SCIPnodeAddHoleinfer(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool probingchange, SCIP_Bool *added)

static SCIP_RETCODE forkCreate(SCIP_FORK **fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)

static void treeCheckPath(SCIP_TREE *tree)

static void subrootCaptureLPIState(SCIP_SUBROOT *subroot, int nuses)

void SCIPnodeGetDualBoundchgs(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int *nvars, int varssize)

SCIP_NODE * SCIPtreeGetBestSibling(SCIP_TREE *tree, SCIP_SET *set)

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)

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

static SCIP_RETCODE focusnodeToFork(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable)

static SCIP_RETCODE treeUpdatePathLPSize(SCIP_TREE *tree, int startdepth)

SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)

SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)

int SCIPtreeGetFocusDepth(SCIP_TREE *tree)

SCIP_Real SCIPtreeGetAvgLowerbound(SCIP_TREE *tree, SCIP_Real cutoffbound)

static SCIP_RETCODE pseudoforkFree(SCIP_PSEUDOFORK **pseudofork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

SCIP_Bool SCIPtreeIsPathComplete(SCIP_TREE *tree)

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

static SCIP_RETCODE junctionInit(SCIP_JUNCTION *junction, SCIP_TREE *tree)

SCIP_Bool SCIPtreeProbingObjChanged(SCIP_TREE *tree)

int SCIPtreeGetProbingDepth(SCIP_TREE *tree)

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

static SCIP_RETCODE nodeDeactivate(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPnodeDelCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)

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

SCIP_RETCODE SCIPtreeBranchVarHole(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_NODE **downchild, SCIP_NODE **upchild)

SCIP_RETCODE SCIPtreeBranchVarNary(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Real val, int n, SCIP_Real minwidth, SCIP_Real widthfactor, int *nchildren)

void SCIPnodePropagateAgain(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeCaptureLPIState(SCIP_NODE *node, int nuses)

static SCIP_RETCODE forkAddLP(SCIP_NODE *fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)

static SCIP_RETCODE treeCreateProbingNode(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

static void treeNextRepropsubtreecount(SCIP_TREE *tree)

void SCIPnodeGetPropsAfterDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *nvars, int varssize)

SCIP_RETCODE SCIPtreeStartProbing(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_Bool strongbranching)

static SCIP_RETCODE treeEnsureChildrenMem(SCIP_TREE *tree, SCIP_SET *set, int num)

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

SCIP_RETCODE SCIPtreeBranchVar(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)

int SCIPtreeGetNChildren(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeSetProbingLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_LP *lp, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)

SCIP_RETCODE SCIPnodeFree(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)

SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)

void SCIPnodeMarkPropagated(SCIP_NODE *node, SCIP_TREE *tree)

int SCIPtreeGetNLeaves(SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeStoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)

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 void treeRemoveChild(SCIP_TREE *tree, SCIP_NODE *child)

void SCIPtreeMarkProbingObjChanged(SCIP_TREE *tree)

static void treeChildrenToSiblings(SCIP_TREE *tree)

static SCIP_RETCODE nodeToLeaf(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_NODE *lpstatefork, SCIP_Real cutoffbound)

SCIP_RETCODE SCIPtreeAddDiveBoundChange(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)

SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)

SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)

SCIP_RETCODE SCIPnodeAddBoundinfer(SCIP_NODE *node, 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_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool probingchange)

SCIP_RETCODE SCIPtreeRestoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)

static SCIP_RETCODE probingnodeCreate(SCIP_PROBINGNODE **probingnode, BMS_BLKMEM *blkmem, SCIP_LP *lp)

SCIP_RETCODE SCIPnodeAddHolechg(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Real left, SCIP_Real right, SCIP_Bool probingchange, SCIP_Bool *added)

static void treeFindSwitchForks(SCIP_TREE *tree, SCIP_NODE *node, SCIP_NODE **commonfork, SCIP_NODE **newlpfork, SCIP_NODE **newlpstatefork, SCIP_NODE **newsubroot, SCIP_Bool *cutoff)

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

SCIP_RETCODE SCIPnodePropagateImplics(SCIP_NODE *node, 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 *cutoff)

static SCIP_RETCODE focusnodeCleanupVars(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool inlp)

SCIP_NODE * SCIPtreeGetBestChild(SCIP_TREE *tree, SCIP_SET *set)

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

static SCIP_RETCODE treeAddPendingBdchg(SCIP_TREE *tree, SCIP_SET *set, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool probingchange)

int SCIPtreeGetEffectiveRootDepth(SCIP_TREE *tree)

static void treeRemoveSibling(SCIP_TREE *tree, SCIP_NODE *sibling)

static SCIP_RETCODE subrootReleaseLPIState(SCIP_SUBROOT *subroot, BMS_BLKMEM *blkmem, SCIP_LP *lp)

SCIP_NODE * SCIPtreeGetPrioSibling(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeAddBoundchg(SCIP_NODE *node, 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_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_Bool probingchange)

void SCIPtreeSetFocusNodeLP(SCIP_TREE *tree, SCIP_Bool solvelp)

int SCIPnodeGetNDualBndchgs(SCIP_NODE *node)

SCIP_RETCODE SCIPnodeAddCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)

int SCIPtreeGetNNodes(SCIP_TREE *tree)

static SCIP_RETCODE subrootConstructLP(SCIP_NODE *subroot, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)

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

static SCIP_RETCODE treeAddChild(SCIP_TREE *tree, SCIP_SET *set, SCIP_NODE *child, SCIP_Real nodeselprio)

static SCIP_RETCODE treeNodesToQueue(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_NODE **nodes, int *nnodes, SCIP_NODE *lpstatefork, SCIP_Real cutoffbound)

static SCIP_RETCODE pseudoforkCreate(SCIP_PSEUDOFORK **pseudofork, BMS_BLKMEM *blkmem, SCIP_TREE *tree, SCIP_LP *lp)

static SCIP_RETCODE probingnodeFree(SCIP_PROBINGNODE **probingnode, BMS_BLKMEM *blkmem, SCIP_LP *lp)

SCIP_Real SCIPtreeCalcNodeselPriority(SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)

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

static SCIP_RETCODE forkReleaseLPIState(SCIP_FORK *fork, BMS_BLKMEM *blkmem, SCIP_LP *lp)

static SCIP_RETCODE probingnodeUpdate(SCIP_PROBINGNODE *probingnode, BMS_BLKMEM *blkmem, SCIP_TREE *tree, SCIP_LP *lp)

int SCIPtreeGetNSiblings(SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetBestNode(SCIP_TREE *tree, SCIP_SET *set)

static SCIP_RETCODE treeEnsurePendingbdchgsMem(SCIP_TREE *tree, SCIP_SET *set, int num)

static SCIP_RETCODE nodeReleaseParent(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)

SCIP_NODE * SCIPtreeGetBestLeaf(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeEndProbing(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRIMAL *primal, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable)

SCIP_Bool SCIPtreeHasFocusNodeLP(SCIP_TREE *tree)

void SCIPtreeGetDiveBoundChangeData(SCIP_TREE *tree, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)

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 SCIPtreeCreate(SCIP_TREE **tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_NODESEL *nodesel)

void SCIPchildChgNodeselPrio(SCIP_TREE *tree, SCIP_NODE *child, SCIP_Real priority)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetPrioChild(SCIP_TREE *tree)

static SCIP_RETCODE treeEnsurePathMem(SCIP_TREE *tree, SCIP_SET *set, int num)

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

static SCIP_RETCODE subrootFree(SCIP_SUBROOT **subroot, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

SCIP_Bool SCIPtreeWasNodeLastBranchParent(SCIP_TREE *tree, SCIP_NODE *node)

SCIP_RETCODE SCIPtreeCreateProbingNode(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

static SCIP_RETCODE forkFree(SCIP_FORK **fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

SCIP_RETCODE SCIPtreeMarkProbingNodeHasLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_LP *lp)

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)

static SCIP_RETCODE treeBacktrackProbing(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_PRIMAL *primal, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, int probingdepth)

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_Bool SCIPtreeInRepropagation(SCIP_TREE *tree)

static SCIP_RETCODE nodeAssignParent(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_TREE *tree, SCIP_NODE *parent, SCIP_Real nodeselprio)

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

static void forkCaptureLPIState(SCIP_FORK *fork, int nuses)

SCIP_NODESEL * SCIPtreeGetNodesel(SCIP_TREE *tree)

SCIP_Real SCIPtreeCalcChildEstimate(SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real targetvalue)

SCIP_NODE * SCIPtreeGetLowerboundNode(SCIP_TREE *tree, SCIP_SET *set)

SCIP_RETCODE SCIPtreeBacktrackProbing(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp, SCIP_PRIMAL *primal, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, int probingdepth)

static SCIP_RETCODE focusnodeToJunction(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)

void SCIPnodeGetPropsBeforeDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *npropvars, int propvarssize)

static SCIP_RETCODE nodeActivate(SCIP_NODE *node, 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_CONFLICT *conflict, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)

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

static SCIP_RETCODE nodeCreate(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set)

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

void SCIPtreeClearDiveBoundChanges(SCIP_TREE *tree)

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

static SCIP_RETCODE nodeRepropagate(SCIP_NODE *node, 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_CONFLICT *conflict, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)

static SCIP_RETCODE pseudoforkAddLP(SCIP_NODE *pseudofork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)

internal methods for branch and bound tree

#define SCIP_EVENTTYPE_NODEINFEASIBLE

#define SCIP_EVENTTYPE_NODEDELETE

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BranchDir SCIP_BRANCHDIR

enum SCIP_BoundType SCIP_BOUNDTYPE

@ SCIP_LPSOLSTAT_NOTSOLVED

@ SCIP_LPSOLSTAT_TIMELIMIT

@ SCIP_LPSOLSTAT_UNBOUNDEDRAY

@ SCIP_LPSOLSTAT_INFEASIBLE

@ SCIP_LPSOLSTAT_OBJLIMIT

@ SCIP_LPSOLSTAT_ITERLIMIT

@ SCIP_REOPTTYPE_INFSUBTREE

@ SCIP_REOPTTYPE_LOGICORNODE

@ SCIP_REOPTTYPE_FEASIBLE

@ SCIP_REOPTTYPE_STRBRANCHED

enum SCIP_ReoptType SCIP_REOPTTYPE

enum SCIP_Retcode SCIP_RETCODE

#define SCIP_PROPTIMING_ALWAYS

enum SCIP_NodeType SCIP_NODETYPE

@ SCIP_NODETYPE_REFOCUSNODE

@ SCIP_NODETYPE_PROBINGNODE

@ SCIP_NODETYPE_PSEUDOFORK

@ SCIP_NODETYPE_FOCUSNODE

@ SCIP_DOMCHGTYPE_DYNAMIC

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_BOUNDCHGTYPE_PROPINFER

@ SCIP_BOUNDCHGTYPE_BRANCHING

@ SCIP_BOUNDCHGTYPE_CONSINFER

@ SCIP_VARSTATUS_MULTAGGR

SCIP_DOMCHGBOUND domchgbound

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

SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)

SCIP_RETCODE SCIPdomchgUndo(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)

SCIP_RETCODE SCIPboundchgApply(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, int pos, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

SCIP_RETCODE SCIPvarAddHoleGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)

SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)

void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)

SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

void SCIPvarCapture(SCIP_VAR *var)

SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)

int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)

SCIP_RETCODE SCIPdomchgApplyGlobal(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPdomchgApply(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, SCIP_Bool *cutoff)

SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)

SCIP_RETCODE SCIPvarChgBdGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)

SCIP_RETCODE SCIPdomchgAddBoundchg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDCHGTYPE boundchgtype, SCIP_Real lpsolval, SCIP_VAR *infervar, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_BOUNDTYPE inferboundtype)

SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)

void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)

SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)

internal methods for problem variables

SCIP_RETCODE SCIPvisualUpdateChild(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)

void SCIPvisualLowerbound(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real lowerbound)

void SCIPvisualMarkedRepropagateNode(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)

SCIP_RETCODE SCIPvisualNewChild(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)

void SCIPvisualRepropagatedNode(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)

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