64#define MAXREPROPMARK 511
91 assert(num <= tree->childrensize);
117 assert(num <= tree->pathsize);
141 assert(num <= tree->pendingbdchgssize);
218 SCIPdebugMessage(
"captured LPI state of subroot %p %d times -> new nlpistateref=%d\n",
267 SCIPerrorMessage(
"node for capturing the LPI state is neither fork nor subroot\n");
293 SCIPerrorMessage(
"node for releasing the LPI state is neither fork nor subroot\n");
310 (*probingnode)->lpistate =
NULL;
311 (*probingnode)->lpinorms =
NULL;
314 (*probingnode)->ncols = (*probingnode)->ninitialcols;
315 (*probingnode)->nrows = (*probingnode)->ninitialrows;
316 (*probingnode)->origobjvars =
NULL;
317 (*probingnode)->origobjvals =
NULL;
318 (*probingnode)->nchgdobjs = 0;
320 SCIPdebugMessage(
"created probingnode information (%d cols, %d rows)\n", (*probingnode)->ncols, (*probingnode)->nrows);
334 SCIP_Bool storenorms =
FALSE;
392 if( (*probingnode)->lpistate !=
NULL )
397 if( (*probingnode)->lpinorms !=
NULL )
403 if( (*probingnode)->nchgdobjs > 0 )
459 (*pseudofork)->addedcols =
NULL;
460 (*pseudofork)->addedrows =
NULL;
463 (*pseudofork)->nchildren = tree->
nchildren;
465 SCIPdebugMessage(
"creating pseudofork information with %d children (%d new cols, %d new rows)\n",
466 (*pseudofork)->nchildren, (*pseudofork)->naddedcols, (*pseudofork)->naddedrows);
468 if( (*pseudofork)->naddedcols > 0 )
473 if( (*pseudofork)->naddedrows > 0 )
481 for(
i = 0;
i < (*pseudofork)->naddedrows; ++
i )
507 assert((*pseudofork)->nchildren == 0);
512 for(
i = 0;
i < (*pseudofork)->naddedrows; ++
i )
555 (*fork)->nlpistateref = 0;
556 (*fork)->addedcols =
NULL;
557 (*fork)->addedrows =
NULL;
560 (*fork)->nchildren = (
unsigned int) tree->
nchildren;
562 SCIPsetDebugMsg(
set,
"creating fork information with %u children (%d new cols, %d new rows)\n", (*fork)->nchildren, (*fork)->naddedcols, (*fork)->naddedrows);
564 if( (*fork)->naddedcols > 0 )
569 if( (*fork)->naddedrows > 0 )
577 for(
i = 0;
i < (*fork)->naddedrows; ++
i )
600 assert((*fork)->nchildren == 0);
601 assert((*fork)->nlpistateref == 0);
608 for(
i = (*fork)->naddedrows - 1;
i >= 0; --
i )
647 (*subroot)->nlpistateref = 0;
650 (*subroot)->nchildren = (
unsigned int) tree->
nchildren;
657 if( (*subroot)->ncols != 0 )
662 (*subroot)->cols =
NULL;
663 if( (*subroot)->nrows != 0 )
668 (*subroot)->rows =
NULL;
671 for(
i = 0;
i < (*subroot)->nrows; ++
i )
694 assert((*subroot)->nchildren == 0);
695 assert((*subroot)->nlpistateref == 0);
702 for(
i = 0;
i < (*subroot)->nrows; ++
i )
746 SCIP_Real nodeselprio
799 SCIP_Real nodeselprio
872 SCIP_Bool freeParent =
FALSE;
937 if( freeParent && !parent->
active )
942 else if( !
set->reopt_enable && freeParent == !parent->
active )
944 SCIP_Bool singleChild =
FALSE;
1021 (*node)->parent =
NULL;
1022 (*node)->conssetchg =
NULL;
1023 (*node)->domchg =
NULL;
1024 (*node)->number = 0;
1027 (*node)->reoptid = 0;
1030 (*node)->active =
FALSE;
1031 (*node)->cutoff =
FALSE;
1032 (*node)->reprop =
FALSE;
1033 (*node)->repropsubtreemark = 0;
1045 SCIP_Real nodeselprio,
1069 (*node)->data.child.arraypos = -1;
1116 assert(!(*node)->active);
1147 SCIPerrorMessage(
"cannot free focus node - has to be converted into a dead end first\n");
1156 assert((*node)->data.sibling.arraypos >= 0);
1168 assert((*node)->data.child.arraypos >= 0);
1179 if( (*node)->data.leaf.lpstatefork !=
NULL )
1253 if(
set->reopt_enable )
1269 if( node->
depth == 0 )
1272 if(
set->misc_calcintegral )
1277 SCIP_Real lowerbound;
1386 SCIP_Longint oldfocuslpstateforklpcount;
1389 SCIP_Bool oldfocusnodehaslp;
1390 SCIP_Longint oldnboundchgs;
1391 SCIP_Bool initialreprop;
1392 SCIP_Bool clockisrunning;
1408 initialreprop = node->
reprop;
1417 if( clockisrunning )
1496 if( clockisrunning )
1570 SCIP_Bool propcutoff;
1572 SCIP_CALL(
nodeRepropagate(node, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict,
1573 eventfilter, eventqueue, cliquetable, &propcutoff) );
1708 if( addedconsssize < *naddedconss )
1712 for( cons = 0; cons < *naddedconss; cons++ )
1745 SCIP_Bool probingchange
1768 if( node->
depth == 0 )
1771 SCIP_Real
bound = newbound;
1841 SCIP_Bool probingchange
1849 SCIP_Bool useglobal;
1868 || node->
depth == 0);
1888 inferboundtype = boundtype;
1919 newbound =
MIN(newbound, oldub);
1936 newbound =
MAX(newbound, oldlb);
1953 SCIPsetDebugMsg(
set,
" -> transformed to active variable <%s>: old bounds=[%g,%g], new %s bound: %g, obj: %g\n",
1965 int conflictingdepth;
1969 if( conflictingdepth >= 0 )
1972 assert(conflictingdepth > 0);
1973 assert(conflictingdepth < tree->pathlen);
1975 SCIPsetDebugMsg(
set,
" -> bound change <%s> %s %g violates current local bounds [%g,%g] since depth %d: remember for later application\n",
2003 SCIPsetDebugMsg(
set,
" -> bound change in root node: perform global bound change\n");
2010 SCIPsetDebugMsg(
set,
"marked root node to be repropagated due to global bound change <%s>:[%g,%g] -> [%g,%g] found in depth %u\n",
2026 SCIP_Real newpseudoobjval;
2049 if(
set->misc_exactsolve )
2063 0.0, infervar, infercons, inferprop, inferinfo, inferboundtype) );
2113 SCIP_Bool probingchange
2116 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2117 cliquetable,
var, newbound, boundtype,
NULL,
NULL, 0, probingchange) );
2139 SCIP_Bool probingchange,
2152 || node->
depth == 0);
2167 SCIP_Real adjustedleft;
2168 SCIP_Real adjustedright;
2170 adjustedleft = left;
2171 adjustedright = right;
2185 SCIPsetDebugMsg(
set,
"adding hole (%g,%g) at node at depth %u to variable <%s>: bounds=[%g,%g], (infer%s=<%s>, inferinfo=%d)\n",
2225 SCIPsetDebugMsg(
set,
"marked root node to be repropagated due to global added hole <%s>: (%g,%g) found in depth %u\n",
2235 SCIPerrorMessage(
"WARNING: currently domain holes can only be handled globally!\n");
2257 SCIP_Bool probingchange,
2271 NULL,
NULL, 0, probingchange, added) );
2302 for(
i = 0;
i < npendingbdchgs; ++
i )
2314 if( conflictdepth == 0 )
2324 assert(conflictdepth == -1);
2396 if( node->
depth == 0 )
2399 if(
set->misc_calcintegral )
2405 SCIP_Real lowerbound;
2408 assert(newbound >= lowerbound);
2439 if(
set->misc_exactsolve )
2474 SCIP_Real newestimate
2520 for(
i = 0;
i < nboundchgs && !(*cutoff); ++
i )
2534 SCIP_Bool varfixing;
2538 SCIP_Real* implbounds;
2550 for( j = 0; j < nimpls; ++j )
2595 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
2596 eventqueue, cliquetable, implvars[j], implbounds[j], impltypes[j],
NULL,
NULL, 0,
FALSE) );
2602 for( j = 0; j < ncliques; ++j )
2612 for( k = 0; k <
nvars; ++k )
2623 if(
vars[k] ==
var && values[k] == varfixing )
2629 if( values[k] ==
FALSE )
2654 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
2686 assert(startdepth <= tree->pathlen);
2688 if( startdepth == 0 )
2699 for(
i = startdepth;
i < tree->
pathlen; ++
i )
2701 node = tree->
path[
i];
2821 *newlpstatefork =
NULL;
2857 if( lpfork ==
NULL )
2865 *newlpfork = lpfork;
2867 lpstatefork = lpfork;
2870 lpstatefork = lpstatefork->
parent;
2871 if( lpstatefork ==
NULL )
2873 if( lpstatefork->
cutoff )
2879 *newlpstatefork = lpstatefork;
2881 subroot = lpstatefork;
2884 subroot = subroot->
parent;
2885 if( subroot ==
NULL )
2893 *newsubroot = subroot;
2929 if( lpstatefork ==
NULL
2936 assert(lpstatefork ==
NULL || !lpstatefork->
active || lpstatefork == fork);
2960 if( lpfork ==
NULL )
2966 while( lpfork !=
NULL
2992 if( lpstatefork ==
NULL )
2998 lpstatefork = lpfork;
3001 while( lpstatefork !=
NULL
3006 lpstatefork = lpstatefork->
parent;
3026 if( subroot ==
NULL )
3032 subroot = lpstatefork;
3040 subroot = subroot->
parent;
3064 *newlpfork = lpfork;
3065 *newlpstatefork = lpstatefork;
3066 *newsubroot = subroot;
3069 while( fork !=
NULL )
3102 int newappliedeffectiverootdepth;
3122 focusnodedepth = (focusnode !=
NULL ? (int)focusnode->
depth : -1);
3123 forkdepth = (fork !=
NULL ? (int)fork->
depth : -1);
3124 assert(forkdepth <= focusnodedepth);
3125 assert(forkdepth < tree->pathlen);
3131 for(
i = tree->
pathlen-1;
i > forkdepth; --
i )
3138 SCIP_CALL(
treeApplyPendingBdchgs(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue, cliquetable) );
3143 while( focusnode != fork )
3149 tree->
path[focusnode->
depth] = focusnode;
3150 focusnode = focusnode->
parent;
3154 if( oldfocusnode !=
NULL )
3206 "shift effective root from depth %d to %d: applying constraint set and bound changes to global problem\n",
3239 SCIP_CALL(
nodeRepropagate(fork, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict,
3240 eventfilter, eventqueue, cliquetable,
cutoff) );
3255 for(
i = forkdepth+1;
i < focusnodedepth && !(*cutoff); ++
i )
3262 SCIP_CALL(
nodeActivate(tree->
path[
i], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
3263 conflict, eventfilter, eventqueue, cliquetable,
cutoff) );
3270 if( !(*
cutoff) && (
i == focusnodedepth) )
3277 SCIP_CALL(
nodeActivate(tree->
path[focusnodedepth], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
3278 conflict, eventfilter, eventqueue, cliquetable,
cutoff) );
3330 for(
c = 0;
c < ncols; ++
c )
3334 for(
r = 0;
r < nrows; ++
r )
3375 for(
c = 0;
c < ncols; ++
c )
3379 for(
r = 0;
r < nrows; ++
r )
3420 for(
c = 0;
c < ncols; ++
c )
3424 for(
r = 0;
r < nrows; ++
r )
3449 for( d = 0; d < tree->
pathlen; ++d )
3451 node = tree->
path[d];
3463 if( d < tree->pathlen-1 )
3494 SCIPerrorMessage(
"node at depth %d on active path has to be of type JUNCTION, PSEUDOFORK, FORK, SUBROOT, FOCUSNODE, REFOCUSNODE, or PROBINGNODE, but is %d\n",
3503#define treeCheckPath(tree)
3549 if( lpfork ==
NULL )
3563 lpforkdepth = (int) lpfork->
depth;
3565 assert(lpforkdepth < tree->pathlen-1);
3589 assert(lpforkdepth < tree->pathlen);
3596 pathnode = tree->
path[d];
3646 SCIP_Bool updatefeas;
3647 SCIP_Bool checkbdchgs;
3648 int lpstateforkdepth;
3672 if( lpstatefork ==
NULL )
3679 lpstateforkdepth = (int) lpstatefork->
depth;
3680 assert(lpstateforkdepth < tree->pathlen-1);
3681 assert(lpstateforkdepth <= tree->correctlpdepth);
3711 checkbdchgs =
FALSE;
3731 assert(d < tree->pathlen);
3766 SCIP_Real cutoffbound
3784 (*node)->data.leaf.lpstatefork = lpstatefork;
3791 pathnode = (*node)->
parent;
3792 while( pathnode !=
NULL && pathnode != lpstatefork )
3796 pathnode = pathnode->
parent;
3798 assert(pathnode == lpstatefork);
3816 if(
set->reopt_enable )
3885 for(
i = 0;
i < transprob->
nvars;
i++ )
3963 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
TRUE) );
3988 SCIP_Real cutoffbound
4001 SCIP_CALL(
nodeToLeaf(&tree->
focusnode, blkmem,
set, stat, eventfilter, eventqueue, tree, reopt, lp, lpstatefork, cutoffbound));
4074 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
FALSE) );
4140 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
TRUE, &
lperror) );
4177 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
FALSE) );
4248#ifdef SCIP_DISABLED_CODE
4261 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
TRUE, &
lperror) );
4298 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, lp, branchcand, cliquetable,
FALSE) );
4304 SCIP_CALL( subrootCreate(&subroot, blkmem,
set, transprob, tree, lp) );
4339 SCIP_Real cutoffbound
4352 SCIP_CALL(
nodeToLeaf(&nodes[
i], blkmem,
set, stat, eventfilter, eventqueue, tree, reopt, lp, lpstatefork, cutoffbound) );
4367 SCIP_Real* tmpprios;
4419 SCIP_Bool postponed,
4460 SCIPsetDebugMsg(
set,
"focus node: focusnodedepth=%ld, forkdepth=%ld, lpforkdepth=%ld, lpstateforkdepth=%ld, subrootdepth=%ld, cutoff=%u\n",
4461 *node !=
NULL ? (
long)((*node)->depth) : -1, fork !=
NULL ? (
long)(fork->
depth) : -1,
4462 lpfork !=
NULL ? (
long)(lpfork->
depth) : -1, lpstatefork !=
NULL ? (
long)(lpstatefork->
depth) : -1,
4476 if(
set->reopt_enable )
4522 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren,
NULL, -
SCIPsetInfinity(
set)) );
4540 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren,
NULL, -
SCIPsetInfinity(
set)) );
4551 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4581 SCIP_CALL(
focusnodeToDeadend(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand,
4592 SCIP_Bool selectedchild;
4596 assert(oldcutoffdepth == INT_MAX);
4609 SCIP_CALL( focusnodeToSubroot(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, transprob, origprob, tree, lp, branchcand) );
4619 reopt, lp, branchcand, cliquetable) );
4648 branchcand, cliquetable) );
4682 SCIP_CALL(
focusnodeToDeadend(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable) );
4701 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4705 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4721 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4739 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4753 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4772 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4805 SCIP_CALL(
treeSwitchPath(tree, reopt, blkmem,
set, stat, transprob, origprob, primal, lp, branchcand, conflict,
4806 eventfilter, eventqueue, cliquetable, fork, *node,
cutoff) );
4838 (*tree)->root =
NULL;
4843 for( p = 0; p <= 1; ++p )
4848 (*tree)->ndivebdchanges[p] = 0;
4849 (*tree)->divebdchgsize[p] = 1;
4852 (*tree)->path =
NULL;
4853 (*tree)->focusnode =
NULL;
4854 (*tree)->focuslpfork =
NULL;
4855 (*tree)->focuslpstatefork =
NULL;
4856 (*tree)->focussubroot =
NULL;
4857 (*tree)->children =
NULL;
4858 (*tree)->siblings =
NULL;
4859 (*tree)->probingroot =
NULL;
4860 (*tree)->childrenprio =
NULL;
4861 (*tree)->siblingsprio =
NULL;
4862 (*tree)->pathnlpcols =
NULL;
4863 (*tree)->pathnlprows =
NULL;
4864 (*tree)->probinglpistate =
NULL;
4865 (*tree)->probinglpinorms =
NULL;
4866 (*tree)->pendingbdchgs =
NULL;
4867 (*tree)->probdiverelaxsol =
NULL;
4868 (*tree)->nprobdiverelaxsol = 0;
4869 (*tree)->pendingbdchgssize = 0;
4870 (*tree)->npendingbdchgs = 0;
4871 (*tree)->focuslpstateforklpcount = -1;
4872 (*tree)->childrensize = 0;
4873 (*tree)->nchildren = 0;
4874 (*tree)->siblingssize = 0;
4875 (*tree)->nsiblings = 0;
4876 (*tree)->pathlen = 0;
4877 (*tree)->pathsize = 0;
4878 (*tree)->effectiverootdepth = 0;
4879 (*tree)->appliedeffectiverootdepth = 0;
4880 (*tree)->lastbranchparentid = -1L;
4881 (*tree)->correctlpdepth = -1;
4882 (*tree)->cutoffdepth = INT_MAX;
4883 (*tree)->repropdepth = INT_MAX;
4884 (*tree)->repropsubtreecount = 0;
4885 (*tree)->focusnodehaslp =
FALSE;
4886 (*tree)->probingnodehaslp =
FALSE;
4887 (*tree)->focuslpconstructed =
FALSE;
4888 (*tree)->cutoffdelayed =
FALSE;
4889 (*tree)->probinglpwasflushed =
FALSE;
4890 (*tree)->probinglpwassolved =
FALSE;
4891 (*tree)->probingloadlpistate =
FALSE;
4892 (*tree)->probinglpwasrelax =
FALSE;
4893 (*tree)->probingsolvedlp =
FALSE;
4894 (*tree)->forcinglpmessage =
FALSE;
4895 (*tree)->sbprobing =
FALSE;
4896 (*tree)->probinglpwasprimfeas =
TRUE;
4897 (*tree)->probinglpwasdualfeas =
TRUE;
4898 (*tree)->probdiverelaxstored =
FALSE;
4899 (*tree)->probdiverelaxincludeslp =
FALSE;
4919 assert((*tree)->nchildren == 0);
4920 assert((*tree)->nsiblings == 0);
4930 for( p = 0; p <= 1; ++p )
5054 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventfilter, eventqueue, lp, tree->
children, &tree->
nchildren,
NULL,
5094 SCIP_CALL(
SCIPnodeFocus(&tree->
root, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5095 conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5131 SCIP_CALL(
SCIPnodeFocus(&node, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5132 conflict, conflictstore, eventfilter, eventqueue, cliquetable, &
cutoff,
FALSE,
FALSE) );
5192 SCIP_Real cutoffbound
5226 if(
set->reopt_enable )
5249 if(
set->reopt_enable )
5277 SCIP_Real targetvalue
5282 SCIP_Real varrootsol;
5310 switch(
set->nodesel_childsel )
5325 prio = targetvalue - varsol;
5328 prio = varrootsol - varsol;
5332 if( !isroot && haslp )
5333 prio *= (varrootsol - varsol + 1.0);
5342 SCIPerrorMessage(
"invalid preferred branching direction <%d> of variable <%s>\n",
5359 switch(
set->nodesel_childsel )
5374 prio = varsol - targetvalue;
5377 prio = varsol - varrootsol;
5381 if( !isroot && haslp )
5382 prio *= (varsol - varrootsol + 1.0);
5396 SCIPerrorMessage(
"invalid preferred branching direction <%d> of variable <%s>\n",
5424 SCIP_Real targetvalue
5427 SCIP_Real estimateinc;
5455 if( estimateinc > 0.0 )
5456 estimate += estimateinc;
5513 if( downchild !=
NULL )
5515 if( eqchild !=
NULL )
5517 if( upchild !=
NULL )
5542 val = (val - constant) / scalar;
5611 SCIPsetDebugMsg(
set,
"fixing continuous variable <%s> with value %g and bounds [%.15g, %.15g], priority %d (current lower bound: %g)\n",
5643 SCIPsetDebugMsg(
set,
"continuous branch on variable <%s> with bounds [%.15g, %.15g], priority %d (current lower bound: %g), node %p\n",
5669 SCIPsetDebugMsg(
set,
"continuous branch on variable <%s> with value %g, priority %d (current lower bound: %g)\n",
5694 center = (ub + lb) / 2.0;
5698 uplb = downub + 1.0;
5703 downub = uplb - 1.0;
5715 downub = fixval - 1.0;
5719 uplb = fixval + 1.0;
5721 SCIPsetDebugMsg(
set,
"integral branch on variable <%s> with value %g, priority %d (current lower bound: %g)\n",
5728 uplb = downub + 1.0;
5730 SCIPsetDebugMsg(
set,
"fractional branch on variable <%s> with value %g, root value %g, priority %d (current lower bound: %g)\n",
5748 SCIPsetDebugMsg(
set,
" -> creating child: <%s> <= %g (priority: %g, estimate: %g)\n",
5751 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5756 if( downchild !=
NULL )
5765 SCIPsetDebugMsg(
set,
" -> creating child: <%s> == %g (priority: %g, estimate: %g)\n",
5770 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5775 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5781 if( eqchild !=
NULL )
5793 SCIPsetDebugMsg(
set,
" -> creating child: <%s> >= %g (priority: %g, estimate: %g)\n",
5796 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5801 if( upchild !=
NULL )
5842 if( downchild !=
NULL )
5844 if( upchild !=
NULL )
5899 SCIPsetDebugMsg(
set,
" -> creating child: <%s> <= %g (priority: %g, estimate: %g)\n",
5903 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
NULL,
5908 if( downchild !=
NULL )
5919 SCIPsetDebugMsg(
set,
" -> creating child: <%s> >= %g (priority: %g, estimate: %g)\n",
5923 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5928 if( upchild !=
NULL )
5967 SCIP_Real widthfactor,
5997 SCIP_CALL(
SCIPtreeBranchVar(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue,
var, val,
5998 &downchild, &fixchild, &upchild) );
6000 if( nchildren !=
NULL )
6001 *nchildren = (downchild !=
NULL ? 1 : 0) + (fixchild !=
NULL ? 1 : 0) + (upchild !=
NULL ? 1 : 0);
6028 val = (val - constant) / scalar;
6102 else if( widthfactor == 1.0 )
6120 assert(widthfactor > 1.0);
6122 width *= (widthfactor - 1.0) / (pow(widthfactor, (SCIP_Real)(n/2)) - 1.0);
6124 width /= 0.5 + widthfactor * (pow(widthfactor, (SCIP_Real)(n/2)) - 1.0) / (widthfactor - 1.0);
6127 minwidth =
MAX(1.0, minwidth);
6128 if( width < minwidth )
6132 SCIPsetDebugMsg(
set,
"%d-ary branching on variable <%s> [%g, %g] around %g, initial width = %g\n",
6135 if( nchildren !=
NULL )
6142 left = val - width/2.0;
6143 right = val + width/2.0;
6160 SCIPsetDebugMsg(
set,
" -> creating middle child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6164 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
6166 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6171 if( nchildren !=
NULL )
6183 width *= widthfactor;
6191 if( right - left < 0.5 )
6208 for(
i = 0;
i < n; ++
i )
6239 SCIPsetDebugMsg(
set,
" -> creating left child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6245 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6248 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6253 if( nchildren !=
NULL )
6273 bnd = right + width;
6290 SCIPsetDebugMsg(
set,
" -> creating right child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6294 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6298 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6304 if( nchildren !=
NULL )
6312 width *= widthfactor;
6321#define ARRAYGROWTH 5
6331 int idx = preferred ? 0 : 1;
6334 assert(pos < tree->divebdchgsize[idx]);
6363 int idx = preferred ? 0 : 1;
6383 for( p = 0; p < 2; ++p )
6457 SCIPsetDebugMsg(
set,
"updated probingnode information of parent (%d cols, %d rows)\n",
6490 SCIP_Bool strongbranching
6499 SCIPsetDebugMsg(
set,
"probing started in depth %d (LP flushed: %u, LP solved: %u, solstat: %d), probing root in depth %d\n",
6579 SCIP_Bool primalfeas,
6645 SCIP_Bool lpwasprimfeas =
FALSE;
6646 SCIP_Bool lpwasprimchecked =
FALSE;
6647 SCIP_Bool lpwasdualfeas =
FALSE;
6648 SCIP_Bool lpwasdualchecked =
FALSE;
6678 if( lpistate ==
NULL )
6689 if( lpistate !=
NULL )
6692 lpwasprimfeas, lpwasprimchecked, lpwasdualfeas, lpwasdualchecked) );
6696 if( lpinorms !=
NULL )
6778 if( newpathlen < tree->pathlen )
6790 while( tree->
pathlen > newpathlen )
6863 SCIP_CALL(
treeApplyPendingBdchgs(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue, cliquetable) );
6906 SCIP_CALL(
treeBacktrackProbing(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, primal, branchcand,
6907 eventqueue, eventfilter, cliquetable, probingdepth) );
6950 SCIP_CALL(
treeBacktrackProbing(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, primal, branchcand,
6951 eventqueue, eventfilter, cliquetable, -1) );
6997 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, &
lperror) );
7012 "LP was not resolved to a sufficient status after probing\n");
7047 SCIPsetDebugMsg(
set,
"clearing lp state at end of probing mode because LP was initially unsolved\n");
7113 for( v = 0; v <
nvars; ++v )
7144 for( v = 0; v <
nvars; ++v )
7294 bestnode = bestchild;
7296 bestnode = bestsibling;
7298 bestnode = bestleaf;
7311 SCIP_Real lowerbound;
7350 SCIP_Real lowerbound;
7392 return lowerboundnode;
7398 SCIP_Real cutoffbound
7401 SCIP_Real lowerboundsum;
7450#undef SCIPnodeGetType
7451#undef SCIPnodeGetNumber
7452#undef SCIPnodeGetDepth
7453#undef SCIPnodeGetLowerbound
7454#undef SCIPnodeGetEstimate
7455#undef SCIPnodeGetDomchg
7456#undef SCIPnodeGetParent
7457#undef SCIPnodeGetConssetchg
7458#undef SCIPnodeIsActive
7459#undef SCIPnodeIsPropagatedAgain
7460#undef SCIPtreeGetNLeaves
7461#undef SCIPtreeGetNChildren
7462#undef SCIPtreeGetNSiblings
7463#undef SCIPtreeGetNNodes
7464#undef SCIPtreeIsPathComplete
7465#undef SCIPtreeProbing
7466#undef SCIPtreeGetProbingRoot
7467#undef SCIPtreeGetProbingDepth
7468#undef SCIPtreeGetFocusNode
7469#undef SCIPtreeGetFocusDepth
7470#undef SCIPtreeHasFocusNodeLP
7471#undef SCIPtreeSetFocusNodeLP
7472#undef SCIPtreeIsFocusNodeLPConstructed
7473#undef SCIPtreeInRepropagation
7474#undef SCIPtreeGetCurrentNode
7475#undef SCIPtreeGetCurrentDepth
7476#undef SCIPtreeHasCurrentNodeLP
7477#undef SCIPtreeGetEffectiveRootDepth
7478#undef SCIPtreeGetRootNode
7479#undef SCIPtreeProbingObjChanged
7480#undef SCIPtreeMarkProbingObjChanged
7509 return (
int) node->
depth;
7558 node->
reopttype = (
unsigned int) reopttype;
7605 SCIP_Bool count_branchings;
7606 SCIP_Bool count_consprop;
7607 SCIP_Bool count_prop;
7612 count_branchings = (nbranchings !=
NULL);
7613 count_consprop = (nconsprop !=
NULL);
7614 count_prop = (nprop !=
NULL);
7617 if( count_branchings )
7619 if( count_consprop )
7657 int npseudobranchvars;
7667 npseudobranchvars = 0;
7675 for(
i = nboundchgs-1;
i >= 0;
i--)
7686 npseudobranchvars++;
7691 return npseudobranchvars;
7731 for(
i = nboundchgs-1;
i >= 0;
i--)
7747 if( varssize >= *
nvars )
7751 for(
i =
i+1;
i < nboundchgs;
i++)
7786 SCIP_Real* branchbounds,
7803 assert(branchvarssize >= 0);
7819 for(
i = 0;
i < nboundchgs;
i++)
7829 for( ;
i < nboundchgs;
i++)
7834 if( branchvarssize >= *nbranchvars )
7836 for(
i = 0;
i < *nbranchvars;
i++)
7839 branchvars[
i] = boundchgs[
i].
var;
7850 SCIP_Real* branchbounds,
7863 assert(branchvarssize >= 0);
7869 int nodenbranchvars;
7873 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
7874 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
7877 *nbranchvars += nodenbranchvars;
7888 SCIP_Real* branchbounds,
7902 assert(branchvarssize >= 0);
7906 while( node != parent )
7908 int nodenbranchvars;
7912 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
7913 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
7916 *nbranchvars += nodenbranchvars;
7928 SCIP_Real* varbounds,
7933 int conspropvarssize
7947 assert(conspropvarssize >= 0);
7949 (*nconspropvars) = 0;
7963 while(
i < nboundchgs
7971 for(
i = nskip;
i < first_dual;
i++ )
7986 if( conspropvarssize >= *nconspropvars )
7990 for(
i = nskip, pos = 0;
i < first_dual;
i++ )
8015 SCIP_Real* varbounds,
8034 assert(branchvarssize >= 0);
8049 while(
i < nboundchgs
8057 for( ;
i < nboundchgs;
i++)
8070 if( branchvarssize >= *nbranchvars )
8073 for(
i = first_dual, p = start;
i < nboundchgs;
i++)
8113 for(
i = 0;
i < nboundchgs;
i++)
8123 if( nbranchings > 0 )
8146 SCIP_Real* branchbounds,
8164 assert(branchvarssize >= 0);
8172 int nodenbranchvars;
8177 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
8178 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
8179 if( *
nnodes < nodeswitchsize )
8180 nodeswitches[*
nnodes] = start;
8184 *nbranchvars += nodenbranchvars;
8212 return (node1 == node2);
8235 while( node1 != node2 )
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_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,...)
assert(minobj< SCIPgetCutoffbound(scip))
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_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)
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
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)
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]
SCIP_Bool probdiverelaxincludeslp
int appliedeffectiverootdepth
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 branching rules and branching candidate storage
datastructures for managing events
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)
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)
void SCIPnodeGetBdChgsAfterDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int start, int *nbranchvars, int branchvarssize)
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)
void SCIPnodeGetConsProps(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *nconspropvars, int conspropvarssize)
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)
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
#define SCIP_DECL_SORTPTRCOMP(x)
@ 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)