52 #define MAXREPROPMARK 511 79 assert(num <= tree->childrensize);
105 assert(num <= tree->pathsize);
118 assert(tree != NULL);
129 assert(num <= tree->pendingbdchgssize);
144 assert(elem1 != NULL);
145 assert(elem2 != NULL);
162 assert(fork != NULL);
178 assert(fork != NULL);
180 assert(blkmem != NULL);
201 assert(subroot != NULL);
206 SCIPdebugMessage(
"captured LPI state of subroot %p %d times -> new nlpistateref=%d\n",
218 assert(subroot != NULL);
220 assert(blkmem != NULL);
240 assert(node != NULL);
242 SCIPdebugMessage(
"capture %d times LPI state of node #%" SCIP_LONGINT_FORMAT
" at depth %d (current: %d)\n",
255 SCIPerrorMessage(
"node for capturing the LPI state is neither fork nor subroot\n");
269 assert(node != NULL);
271 SCIPdebugMessage(
"release LPI state of node #%" SCIP_LONGINT_FORMAT
" at depth %d (current: %d)\n",
281 SCIPerrorMessage(
"node for releasing the LPI state is neither fork nor subroot\n");
294 assert(probingnode != NULL);
298 (*probingnode)->lpistate = NULL;
299 (*probingnode)->lpinorms = NULL;
302 (*probingnode)->ncols = (*probingnode)->ninitialcols;
303 (*probingnode)->nrows = (*probingnode)->ninitialrows;
304 (*probingnode)->origobjvars = NULL;
305 (*probingnode)->origobjvals = NULL;
306 (*probingnode)->nchgdobjs = 0;
308 SCIPdebugMessage(
"created probingnode information (%d cols, %d rows)\n", (*probingnode)->ncols, (*probingnode)->nrows);
324 assert(probingnode != NULL);
376 assert(probingnode != NULL);
377 assert(*probingnode != NULL);
380 if( (*probingnode)->lpistate != NULL )
385 if( (*probingnode)->lpinorms != NULL )
391 if( (*probingnode)->nchgdobjs > 0 )
393 assert((*probingnode)->origobjvars != NULL);
394 assert((*probingnode)->origobjvals != NULL);
412 assert(junction != NULL);
413 assert(tree != NULL);
438 assert(pseudofork != NULL);
439 assert(blkmem != NULL);
440 assert(tree != NULL);
447 (*pseudofork)->addedcols = NULL;
448 (*pseudofork)->addedrows = NULL;
451 (*pseudofork)->nchildren = tree->
nchildren;
453 SCIPdebugMessage(
"creating pseudofork information with %d children (%d new cols, %d new rows)\n",
454 (*pseudofork)->nchildren, (*pseudofork)->naddedcols, (*pseudofork)->naddedrows);
456 if( (*pseudofork)->naddedcols > 0 )
461 if( (*pseudofork)->naddedrows > 0 )
469 for( i = 0; i < (*pseudofork)->naddedrows; ++i )
493 assert(pseudofork != NULL);
494 assert(*pseudofork != NULL);
495 assert((*pseudofork)->nchildren == 0);
496 assert(blkmem != NULL);
500 for( i = 0; i < (*pseudofork)->naddedrows; ++i )
523 assert(fork != NULL);
524 assert(blkmem != NULL);
525 assert(tree != NULL);
543 (*fork)->nlpistateref = 0;
544 (*fork)->addedcols = NULL;
545 (*fork)->addedrows = NULL;
548 (*fork)->nchildren = (
unsigned int) tree->
nchildren;
550 SCIPsetDebugMsg(
set,
"creating fork information with %u children (%d new cols, %d new rows)\n", (*fork)->nchildren, (*fork)->naddedcols, (*fork)->naddedrows);
552 if( (*fork)->naddedcols > 0 )
557 if( (*fork)->naddedrows > 0 )
565 for( i = 0; i < (*fork)->naddedrows; ++i )
586 assert(fork != NULL);
587 assert(*fork != NULL);
588 assert((*fork)->nchildren == 0);
589 assert((*fork)->nlpistateref == 0);
590 assert((*fork)->lpistate == NULL);
591 assert(blkmem != NULL);
596 for( i = (*fork)->naddedrows - 1; i >= 0; --i )
622 assert(subroot != NULL);
623 assert(blkmem != NULL);
624 assert(tree != NULL);
635 (*subroot)->nlpistateref = 0;
638 (*subroot)->nchildren = (
unsigned int) tree->
nchildren;
645 if( (*subroot)->ncols != 0 )
650 (*subroot)->cols = NULL;
651 if( (*subroot)->nrows != 0 )
656 (*subroot)->rows = NULL;
659 for( i = 0; i < (*subroot)->nrows; ++i )
680 assert(subroot != NULL);
681 assert(*subroot != NULL);
682 assert((*subroot)->nchildren == 0);
683 assert((*subroot)->nlpistateref == 0);
684 assert((*subroot)->lpistate == NULL);
685 assert(blkmem != NULL);
690 for( i = 0; i < (*subroot)->nrows; ++i )
711 assert(tree != NULL);
712 assert(sibling != NULL);
737 assert(tree != NULL);
738 assert(child != NULL);
760 assert(tree != NULL);
761 assert(child != NULL);
790 assert(node != NULL);
791 assert(node->
parent == NULL);
794 assert(node->
domchg == NULL);
796 assert(blkmem != NULL);
798 assert(tree != NULL);
821 SCIPsetDebugMsg(
set,
"assigning parent #%" SCIP_LONGINT_FORMAT
" to node #%" SCIP_LONGINT_FORMAT
" at depth %d\n",
848 assert(node != NULL);
849 assert(blkmem != NULL);
850 assert(tree != NULL);
852 SCIPsetDebugMsg(
set,
"releasing parent-child relationship of node #%" SCIP_LONGINT_FORMAT
" at depth %d of type %d with parent #%" SCIP_LONGINT_FORMAT
" of type %d\n",
931 if( freeParent && !parent->
active )
943 SCIPsetDebugMsg(
set,
"unlinked node #%" SCIP_LONGINT_FORMAT
" in depth %d -> new effective root depth: %d\n",
959 assert(node != NULL);
962 (*node)->parent = NULL;
963 (*node)->conssetchg = NULL;
964 (*node)->domchg = NULL;
968 (*node)->reoptid = 0;
971 (*node)->active =
FALSE;
972 (*node)->cutoff =
FALSE;
973 (*node)->reprop =
FALSE;
974 (*node)->repropsubtreemark = 0;
990 assert(node != NULL);
991 assert(blkmem != NULL);
993 assert(stat != NULL);
994 assert(tree != NULL);
1010 (*node)->data.child.arraypos = -1;
1039 assert(node != NULL);
1040 assert(*node != NULL);
1041 assert(!(*node)->active);
1042 assert(blkmem != NULL);
1043 assert(tree != NULL);
1059 SCIPerrorMessage(
"cannot free focus node - has to be converted into a dead end first\n");
1068 assert((*node)->data.sibling.arraypos >= 0);
1069 assert((*node)->data.sibling.arraypos < tree->
nsiblings);
1070 assert(tree->
siblings[(*node)->data.sibling.arraypos] == *node);
1080 assert((*node)->data.child.arraypos >= 0);
1081 assert((*node)->data.child.arraypos < tree->
nchildren);
1082 assert(tree->
children[(*node)->data.child.arraypos] == *node);
1091 if( (*node)->data.leaf.lpstatefork != NULL )
1160 assert(node != NULL);
1161 assert(
set != NULL);
1162 assert(stat != NULL);
1163 assert(tree != NULL);
1165 if( set->reopt_enable )
1167 assert(reopt != NULL);
1181 if( node->
depth == 0 )
1184 if( set->misc_calcintegral )
1199 SCIPsetDebugMsg(
set,
"cutting off %s node #%" SCIP_LONGINT_FORMAT
" at depth %d (cutoffdepth: %d)\n",
1213 assert(node != NULL);
1214 assert(
set != NULL);
1215 assert(stat != NULL);
1216 assert(tree != NULL);
1226 SCIPsetDebugMsg(
set,
"marked %s node #%" SCIP_LONGINT_FORMAT
" at depth %d to be propagated again (repropdepth: %d)\n",
1237 assert(node != NULL);
1238 assert(tree != NULL);
1240 if( node->
parent != NULL )
1266 assert(tree != NULL);
1306 assert(node != NULL);
1314 assert(stat != NULL);
1315 assert(tree != NULL);
1317 assert(cutoff != NULL);
1320 initialreprop = node->
reprop;
1329 if( clockisrunning )
1354 SCIP_CALL(
SCIPpropagateDomains(blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
1356 assert(!node->
reprop || *cutoff);
1373 SCIPsetDebugMsg(
set,
"repropagation %" SCIP_LONGINT_FORMAT
" at depth %u changed %" SCIP_LONGINT_FORMAT
" bounds (total reprop bound changes: %" SCIP_LONGINT_FORMAT
"), cutoff: %u\n",
1381 if( initialreprop && !(*cutoff) && stat->
nboundchgs > oldnboundchgs )
1385 SCIPsetDebugMsg(
set,
"initial repropagation at depth %u changed %" SCIP_LONGINT_FORMAT
" bounds -> repropagating subtree (new mark: %d)\n",
1408 if( clockisrunning )
1444 assert(node != NULL);
1446 assert(stat != NULL);
1447 assert(tree != NULL);
1449 assert(cutoff != NULL);
1451 SCIPsetDebugMsg(
set,
"activate node #%" SCIP_LONGINT_FORMAT
" at depth %d of type %d (reprop subtree mark: %u)\n",
1470 node->
reprop =
set->conf_enable &&
set->conf_useprop;
1484 SCIP_CALL(
nodeRepropagate(node, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict,
1485 eventfilter, eventqueue, cliquetable, &propcutoff) );
1486 *cutoff = *cutoff || propcutoff;
1507 assert(node != NULL);
1509 assert(tree != NULL);
1512 SCIPsetDebugMsg(
set,
"deactivate node #%" SCIP_LONGINT_FORMAT
" at depth %d of type %d (reprop subtree mark: %u)\n",
1574 assert(node != NULL);
1575 assert(cons != NULL);
1577 assert(tree != NULL);
1579 assert(tree->
root != NULL);
1584 if( cons->
scip != set->scip )
1617 assert(node != NULL);
1618 assert(tree != NULL);
1619 assert(cons != NULL);
1647 assert(node != NULL );
1655 if( addedconsssize < *naddedconss )
1659 for( cons = 0; cons < *naddedconss; cons++ )
1672 assert(node != NULL);
1695 assert(tree != NULL);
1715 if( node->
depth == 0 )
1797 assert(node != NULL);
1802 || node->
depth == 0);
1803 assert(
set != NULL);
1804 assert(tree != NULL);
1806 assert(tree->
root != NULL);
1807 assert(var != NULL);
1808 assert(node->
active || (infercons == NULL && inferprop == NULL));
1811 SCIPsetDebugMsg(
set,
"adding boundchange at node %llu at depth %u to variable <%s>: old bounds=[%g,%g], new %s bound: %g (infer%s=<%s>, inferinfo=%d)\n",
1813 boundtype ==
SCIP_BOUNDTYPE_LOWER ?
"lower" :
"upper", newbound, infercons != NULL ?
"cons" :
"prop",
1818 inferboundtype = boundtype;
1849 newbound = MIN(newbound, oldub);
1867 newbound =
MAX(newbound, oldlb);
1877 SCIPsetDebugMsg(
set,
" -> transformed to active variable <%s>: old bounds=[%g,%g], new %s bound: %g, obj: %g\n",
1889 int conflictingdepth;
1893 if( conflictingdepth >= 0 )
1896 assert(conflictingdepth > 0);
1897 assert(conflictingdepth < tree->pathlen);
1899 SCIPsetDebugMsg(
set,
" -> bound change <%s> %s %g violates current local bounds [%g,%g] since depth %d: remember for later application\n",
1925 assert(!probingchange);
1927 SCIPsetDebugMsg(
set,
" -> bound change in root node: perform global bound change\n");
1934 SCIPsetDebugMsg(
set,
"marked root node to be repropagated due to global bound change <%s>:[%g,%g] -> [%g,%g] found in depth %u\n",
1970 lpsolval, NULL, NULL, NULL, 0, inferboundtype) );
1973 if( set->misc_exactsolve )
1987 0.0, infervar, infercons, inferprop, inferinfo, inferboundtype) );
1990 assert(node->
domchg != NULL);
2040 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
2041 cliquetable, var, newbound, boundtype, NULL, NULL, 0, probingchange) );
2071 assert(node != NULL);
2076 || node->
depth == 0);
2077 assert(blkmem != NULL);
2078 assert(
set != NULL);
2079 assert(tree != NULL);
2081 assert(tree->
root != NULL);
2082 assert(var != NULL);
2083 assert(node->
active || (infercons == NULL && inferprop == NULL));
2094 adjustedleft = left;
2095 adjustedright = right;
2109 SCIPsetDebugMsg(
set,
"adding hole (%g,%g) at node at depth %u to variable <%s>: bounds=[%g,%g], (infer%s=<%s>, inferinfo=%d)\n",
2140 assert(!probingchange);
2142 SCIPsetDebugMsg(
set,
" -> hole added in root node: perform global domain change\n");
2149 SCIPsetDebugMsg(
set,
"marked root node to be repropagated due to global added hole <%s>: (%g,%g) found in depth %u\n",
2159 SCIPerrorMessage(
"WARNING: currently domain holes can only be handled globally!\n");
2185 assert(node != NULL);
2189 assert(blkmem != NULL);
2191 SCIPsetDebugMsg(
set,
"adding hole (%g,%g) at node at depth %u of variable <%s>\n",
2195 NULL, NULL, 0, probingchange, added) );
2223 assert(tree != NULL);
2226 for( i = 0; i < npendingbdchgs; ++i )
2238 if( conflictdepth == 0 )
2248 assert(conflictdepth == -1);
2309 assert(node != NULL);
2310 assert(stat != NULL);
2319 if( node->
depth == 0 )
2322 if( set->misc_calcintegral )
2329 assert(newbound >= lowerbound);
2351 assert(
set != NULL);
2359 if( set->misc_exactsolve )
2397 assert(node != NULL);
2398 assert(
set != NULL);
2424 assert(node != NULL);
2429 assert(cutoff != NULL);
2431 SCIPsetDebugMsg(
set,
"implication graph propagation of node #%" SCIP_LONGINT_FORMAT
" in depth %d\n",
2438 for( i = 0; i < nboundchgs && !(*cutoff); ++i )
2468 for( j = 0; j < nimpls; ++j )
2512 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
2513 eventqueue, cliquetable, implvars[j], implbounds[j], impltypes[j], NULL, NULL, 0,
FALSE) );
2519 for( j = 0; j < ncliques; ++j )
2529 for( k = 0; k < nvars; ++k )
2539 if( vars[k] == var && values[k] == varfixing )
2545 if( values[k] ==
FALSE )
2570 SCIP_CALL(
SCIPnodeAddBoundinfer(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
2572 NULL, NULL, 0,
FALSE) );
2600 assert(tree != NULL);
2601 assert(startdepth >= 0);
2602 assert(startdepth <= tree->pathlen);
2604 if( startdepth == 0 )
2615 for( i = startdepth; i < tree->
pathlen; ++i )
2617 node = tree->
path[i];
2618 assert(node != NULL);
2620 assert((
int)(node->
depth) == i);
2634 if( i < tree->pathlen-1 )
2714 assert(tree != NULL);
2715 assert(tree->
root != NULL);
2729 assert(commonfork != NULL);
2730 assert(newlpfork != NULL);
2731 assert(newlpstatefork != NULL);
2732 assert(newsubroot != NULL);
2733 assert(cutoff != NULL);
2737 *newlpstatefork = NULL;
2773 if( lpfork == NULL )
2781 *newlpfork = lpfork;
2783 lpstatefork = lpfork;
2786 lpstatefork = lpstatefork->
parent;
2787 if( lpstatefork == NULL )
2789 if( lpstatefork->
cutoff )
2795 *newlpstatefork = lpstatefork;
2797 subroot = lpstatefork;
2800 subroot = subroot->
parent;
2801 if( subroot == NULL )
2809 *newsubroot = subroot;
2812 while( fork->
parent != NULL )
2829 assert(fork != NULL);
2834 assert(fork != NULL);
2845 if( lpstatefork == NULL
2851 assert(lpfork == NULL || !lpfork->
active || lpfork == fork);
2852 assert(lpstatefork == NULL || !lpstatefork->
active || lpstatefork == fork);
2853 assert(subroot == NULL || !subroot->
active || subroot == fork);
2866 assert(fork != NULL);
2876 if( lpfork == NULL )
2882 while( lpfork != NULL
2896 assert(lpfork == NULL || (
int)(lpfork->
depth) <= fork->
depth);
2897 assert(lpfork == NULL || lpfork->
active);
2899 assert(lpfork == NULL
2903 SCIPdebugMessage(
"find switch forks: lpforkdepth=%d\n", lpfork == NULL ? -1 : (
int)(lpfork->
depth));
2908 if( lpstatefork == NULL )
2913 if( lpfork != NULL && lpfork->
depth < fork->
depth )
2914 lpstatefork = lpfork;
2917 while( lpstatefork != NULL
2921 assert(lpstatefork->
active);
2922 lpstatefork = lpstatefork->
parent;
2930 assert(lpstatefork == NULL || (
int)(lpstatefork->
depth) <= fork->
depth);
2931 assert(lpstatefork == NULL || lpstatefork->
active);
2933 assert(lpstatefork == NULL
2936 assert(lpstatefork == NULL || (lpfork != NULL && lpstatefork->
depth <= lpfork->
depth));
2937 SCIPdebugMessage(
"find switch forks: lpstateforkdepth=%d\n", lpstatefork == NULL ? -1 : (
int)(lpstatefork->
depth));
2942 if( subroot == NULL )
2947 if( lpstatefork != NULL && lpstatefork->
depth < fork->
depth )
2948 subroot = lpstatefork;
2949 else if( lpfork != NULL && lpfork->
depth < fork->
depth )
2956 subroot = subroot->
parent;
2961 assert(subroot == NULL || subroot->
depth <= fork->
depth);
2962 assert(subroot == NULL || subroot->
active);
2965 assert(subroot == NULL || (lpstatefork != NULL && subroot->
depth <= lpstatefork->
depth));
2966 SCIPdebugMessage(
"find switch forks: subrootdepth=%d\n", subroot == NULL ? -1 : (
int)(subroot->
depth));
2980 *newlpfork = lpfork;
2981 *newlpstatefork = lpstatefork;
2982 *newsubroot = subroot;
2985 while( fork != NULL )
3022 assert(tree != NULL);
3023 assert(fork == NULL || (fork->
active && !fork->
cutoff));
3024 assert(fork == NULL || focusnode != NULL);
3025 assert(focusnode == NULL || (!focusnode->
active && !focusnode->
cutoff));
3027 assert(cutoff != NULL);
3034 focusnodedepth = (focusnode != NULL ? (int)focusnode->
depth : -1);
3035 forkdepth = (fork != NULL ? (int)fork->
depth : -1);
3036 assert(forkdepth <= focusnodedepth);
3037 assert(forkdepth < tree->pathlen);
3043 for( i = tree->
pathlen-1; i > forkdepth; --i )
3050 SCIP_CALL(
treeApplyPendingBdchgs(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue, cliquetable) );
3054 while( focusnode != fork )
3056 assert(focusnode != NULL);
3057 assert(!focusnode->
active);
3058 assert(!focusnode->
cutoff);
3059 tree->
path[focusnode->
depth] = focusnode;
3060 focusnode = focusnode->
parent;
3064 if( fork != NULL && fork->
cutoff )
3066 else if( fork != NULL && fork->
reprop )
3069 assert(tree->
path[forkdepth] == fork);
3073 SCIP_CALL(
nodeRepropagate(fork, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, conflict,
3074 eventfilter, eventqueue, cliquetable, cutoff) );
3076 assert(fork != NULL || !(*cutoff));
3089 for( i = forkdepth+1; i < focusnodedepth && !(*cutoff); ++i )
3096 SCIP_CALL(
nodeActivate(tree->
path[i], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
3097 conflict, eventfilter, eventqueue, cliquetable, cutoff) );
3104 if( !(*cutoff) && (i == focusnodedepth) )
3107 assert(tree->
pathlen == focusnodedepth);
3111 SCIP_CALL(
nodeActivate(tree->
path[focusnodedepth], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
3112 conflict, eventfilter, eventqueue, cliquetable, cutoff) );
3149 assert(subroot != NULL);
3152 assert(blkmem != NULL);
3153 assert(
set != NULL);
3161 assert(ncols == 0 || cols != NULL);
3162 assert(nrows == 0 || rows != NULL);
3164 for( c = 0; c < ncols; ++c )
3168 for( r = 0; r < nrows; ++r )
3194 assert(fork != NULL);
3197 assert(blkmem != NULL);
3198 assert(
set != NULL);
3206 assert(ncols == 0 || cols != NULL);
3207 assert(nrows == 0 || rows != NULL);
3209 for( c = 0; c < ncols; ++c )
3213 for( r = 0; r < nrows; ++r )
3239 assert(pseudofork != NULL);
3242 assert(blkmem != NULL);
3243 assert(
set != NULL);
3251 assert(ncols == 0 || cols != NULL);
3252 assert(nrows == 0 || rows != NULL);
3254 for( c = 0; c < ncols; ++c )
3258 for( r = 0; r < nrows; ++r )
3278 assert(tree != NULL);
3279 assert(tree->
path != NULL);
3283 for( d = 0; d < tree->
pathlen; ++d )
3285 node = tree->
path[d];
3286 assert(node != NULL);
3287 assert((
int)(node->
depth) == d);
3297 if( d < tree->pathlen-1 )
3328 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",
3337 #define treeCheckPath(tree) 3355 assert(tree != NULL);
3357 assert(tree->
path != NULL);
3364 assert(blkmem != NULL);
3365 assert(
set != NULL);
3367 assert(initroot != NULL);
3369 SCIPsetDebugMsg(
set,
"load LP for current fork node #%" SCIP_LONGINT_FORMAT
" at depth %d\n",
3383 if( lpfork == NULL )
3396 assert(tree->
path[lpfork->
depth] == lpfork);
3397 lpforkdepth = lpfork->
depth;
3399 assert(lpforkdepth < tree->pathlen-1);
3423 assert(lpforkdepth < tree->pathlen);
3430 pathnode = tree->
path[d];
3431 assert(pathnode != NULL);
3432 assert((
int)(pathnode->
depth) == d);
3481 int lpstateforkdepth;
3484 assert(tree != NULL);
3486 assert(tree->
path != NULL);
3494 assert(blkmem != NULL);
3495 assert(
set != NULL);
3498 SCIPsetDebugMsg(
set,
"load LP state for current fork node #%" SCIP_LONGINT_FORMAT
" at depth %d\n",
3505 if( lpstatefork == NULL )
3510 assert(lpstatefork->
active);
3511 assert(tree->
path[lpstatefork->
depth] == lpstatefork);
3512 lpstateforkdepth = lpstatefork->
depth;
3513 assert(lpstateforkdepth < tree->pathlen-1);
3514 assert(lpstateforkdepth <= tree->correctlpdepth);
3523 assert(lpstatefork->
data.
fork != NULL);
3544 checkbdchgs =
FALSE;
3564 assert(d < tree->pathlen);
3603 assert(stat != NULL);
3604 assert(lpstatefork == NULL || lpstatefork->
depth < (*node)->depth);
3605 assert(lpstatefork == NULL || lpstatefork->
active ||
SCIPsetIsGE(
set, (*node)->lowerbound, cutoffbound));
3606 assert(lpstatefork == NULL
3611 SCIPsetDebugMsg(
set,
"convert node #%" SCIP_LONGINT_FORMAT
" at depth %d to leaf with lpstatefork #%" SCIP_LONGINT_FORMAT
" at depth %d\n",
3616 (*node)->data.leaf.lpstatefork = lpstatefork;
3623 pathnode = (*node)->
parent;
3624 while( pathnode != NULL && pathnode != lpstatefork )
3628 pathnode = pathnode->
parent;
3630 assert(pathnode == lpstatefork);
3635 if(
SCIPsetIsLT(
set, (*node)->lowerbound, cutoffbound) )
3648 if( set->reopt_enable )
3650 assert(reopt != NULL);
3660 assert(*node == NULL);
3690 assert(blkmem != NULL);
3691 assert(
set != NULL);
3692 assert(stat != NULL);
3693 assert(tree != NULL);
3700 needdel = (tree->
focusnode == tree->
root ?
set->price_delvarsroot :
set->price_delvars);
3717 for( i = 0; i < transprob->
nvars; i++ )
3719 var = transprob->
vars[i];
3720 assert(var != NULL);
3757 SCIPsetDebugMsg(
set,
"delvars at node %" SCIP_LONGINT_FORMAT
", deleted %d vars\n", stat->
nnodes, ndelvars);
3784 assert(blkmem != NULL);
3785 assert(tree != NULL);
3791 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to dead-end at depth %d\n",
3795 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
TRUE) );
3823 assert(tree != NULL);
3829 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to leaf at depth %d\n",
3847 assert(tree != NULL);
3854 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to junction at depth %d\n",
3892 assert(blkmem != NULL);
3893 assert(tree != NULL);
3901 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to pseudofork at depth %d\n",
3905 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
FALSE) );
3946 assert(blkmem != NULL);
3947 assert(tree != NULL);
3957 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to fork at depth %d\n",
3973 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
TRUE, &lperror) );
3994 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles: LP %" SCIP_LONGINT_FORMAT
" not optimal -- convert node into junction instead of fork\n",
4011 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable,
FALSE) );
4061 assert(blkmem != NULL);
4062 assert(tree != NULL);
4072 SCIPsetDebugMsg(
set,
"focusnode #%" SCIP_LONGINT_FORMAT
" to subroot at depth %d\n",
4082 #ifdef SCIP_DISABLED_CODE 4097 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
TRUE, &lperror) );
4101 assert(lp->
solved || lperror);
4118 "(node %" SCIP_LONGINT_FORMAT
") numerical troubles: LP %" SCIP_LONGINT_FORMAT
" not optimal -- convert node into junction instead of subroot\n",
4135 SCIP_CALL(
focusnodeCleanupVars(blkmem,
set, stat, eventqueue, transprob, origprob, tree, lp, branchcand, cliquetable,
FALSE) );
4142 SCIP_CALL( subrootCreate(&subroot, blkmem,
set, transprob, tree, lp) );
4181 assert(tree != NULL);
4182 assert(
set != NULL);
4183 assert(nnodes != NULL);
4184 assert(*nnodes == 0 || nodes != NULL);
4186 for( i = 0; i < *
nnodes; ++i )
4189 SCIP_CALL(
nodeToLeaf(&nodes[i], blkmem,
set, stat, eventqueue, tree, reopt, lp, lpstatefork, cutoffbound) );
4190 assert(nodes[i] == NULL);
4208 assert(tree != NULL);
4268 assert(node != NULL);
4269 assert(*node == NULL
4273 assert(*node == NULL || !(*node)->
active);
4274 assert(stat != NULL);
4275 assert(tree != NULL);
4276 assert(!postponed || *node == NULL);
4277 assert(!postponed || tree->
focusnode != NULL);
4280 assert(cutoff != NULL);
4282 SCIPsetDebugMsg(
set,
"focusing node #%" SCIP_LONGINT_FORMAT
" of type %d in depth %d\n",
4293 SCIPsetDebugMsg(
set,
"focus node: focusnodedepth=%d, forkdepth=%d, lpforkdepth=%d, lpstateforkdepth=%d, subrootdepth=%d, cutoff=%u\n",
4294 *node != NULL ? (*node)->
depth : -1, fork != NULL ? fork->
depth : -1,
4295 lpfork != NULL ? lpfork->
depth : -1, lpstatefork != NULL ? lpstatefork->
depth : -1,
4296 subroot != NULL ? subroot->
depth : -1, *cutoff);
4301 assert(*node != NULL);
4309 if( set->reopt_enable )
4311 assert(reopt != NULL);
4323 assert(fork == NULL || fork->
active);
4324 assert(lpstatefork == NULL || lpfork != NULL);
4325 assert(subroot == NULL || lpstatefork != NULL);
4329 if( subroot == tree->
focussubroot && fork != NULL && lpfork != NULL )
4332 assert(subroot == NULL || subroot->
active);
4338 assert(subroot == NULL || !subroot->
active 4355 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, NULL, -
SCIPsetInfinity(
set)) );
4372 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, NULL, -
SCIPsetInfinity(
set)) );
4383 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4397 assert(*node == NULL);
4409 SCIP_CALL(
focusnodeToDeadend(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand,
4424 assert(oldcutoffdepth == INT_MAX);
4437 SCIP_CALL( focusnodeToSubroot(blkmem,
set, messagehdlr, stat, eventqueue, eventfilter, transprob, origprob, tree, lp, branchcand) );
4447 reopt, lp, branchcand, cliquetable) );
4476 branchcand, cliquetable) );
4510 SCIP_CALL(
focusnodeToDeadend(blkmem,
set, stat, eventqueue, transprob, origprob, tree, reopt, lp, branchcand, cliquetable) );
4513 assert(lpstatefork == NULL
4516 assert(childrenlpstatefork == NULL
4519 assert(lpfork == NULL
4530 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4534 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4550 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4568 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4582 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
siblings, &tree->
nsiblings, tree->
focuslpstatefork,
4601 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, childrenlpstatefork,
4624 assert(subroot == NULL || (lpstatefork != NULL && subroot->
depth <= lpstatefork->
depth));
4625 assert(lpstatefork == NULL || (lpfork != NULL && lpstatefork->
depth <= lpfork->
depth));
4626 assert(lpfork == NULL || (*node != NULL && lpfork->
depth < (*node)->depth));
4635 SCIP_CALL(
treeSwitchPath(tree, reopt, blkmem,
set, stat, transprob, origprob, primal, lp, branchcand, conflict,
4636 eventfilter, eventqueue, cliquetable, fork, *node, cutoff) );
4638 assert(*node != NULL || tree->
pathlen == 0);
4639 assert(*node == NULL || tree->
pathlen-1 <= (
int)(*node)->depth);
4644 int appliedeffectiverootdepth;
4647 assert(appliedeffectiverootdepth <= tree->effectiverootdepth);
4652 if( tree->
effectiverootdepth > appliedeffectiverootdepth && *node != NULL && !(*cutoff) )
4657 SCIPsetDebugMsg(
set,
"effective root is now at depth %d: applying constraint set and bound changes to global problem\n",
4664 SCIPsetDebugMsg(
set,
" -> applying constraint set changes of depth %d\n", d);
4702 assert(tree != NULL);
4703 assert(blkmem != NULL);
4707 (*tree)->root = NULL;
4712 for( p = 0; p <= 1; ++p )
4717 (*tree)->ndivebdchanges[p] = 0;
4718 (*tree)->divebdchgsize[p] = 1;
4721 (*tree)->path = NULL;
4722 (*tree)->focusnode = NULL;
4723 (*tree)->focuslpfork = NULL;
4724 (*tree)->focuslpstatefork = NULL;
4725 (*tree)->focussubroot = NULL;
4726 (*tree)->children = NULL;
4727 (*tree)->siblings = NULL;
4728 (*tree)->probingroot = NULL;
4729 (*tree)->childrenprio = NULL;
4730 (*tree)->siblingsprio = NULL;
4731 (*tree)->pathnlpcols = NULL;
4732 (*tree)->pathnlprows = NULL;
4733 (*tree)->probinglpistate = NULL;
4734 (*tree)->probinglpinorms = NULL;
4735 (*tree)->pendingbdchgs = NULL;
4736 (*tree)->probdiverelaxsol = NULL;
4737 (*tree)->pendingbdchgssize = 0;
4738 (*tree)->npendingbdchgs = 0;
4739 (*tree)->focuslpstateforklpcount = -1;
4740 (*tree)->childrensize = 0;
4741 (*tree)->nchildren = 0;
4742 (*tree)->siblingssize = 0;
4743 (*tree)->nsiblings = 0;
4744 (*tree)->pathlen = 0;
4745 (*tree)->pathsize = 0;
4746 (*tree)->effectiverootdepth = 0;
4747 (*tree)->appliedeffectiverootdepth = 0;
4748 (*tree)->correctlpdepth = -1;
4749 (*tree)->cutoffdepth = INT_MAX;
4750 (*tree)->repropdepth = INT_MAX;
4751 (*tree)->repropsubtreecount = 0;
4752 (*tree)->focusnodehaslp =
FALSE;
4753 (*tree)->probingnodehaslp =
FALSE;
4754 (*tree)->focuslpconstructed =
FALSE;
4755 (*tree)->cutoffdelayed =
FALSE;
4756 (*tree)->probinglpwasflushed =
FALSE;
4757 (*tree)->probinglpwassolved =
FALSE;
4758 (*tree)->probingloadlpistate =
FALSE;
4759 (*tree)->probinglpwasrelax =
FALSE;
4760 (*tree)->probingsolvedlp =
FALSE;
4761 (*tree)->forcinglpmessage =
FALSE;
4762 (*tree)->sbprobing =
FALSE;
4763 (*tree)->probinglpwasprimfeas =
TRUE;
4764 (*tree)->probinglpwasdualfeas =
TRUE;
4765 (*tree)->probdiverelaxstored =
FALSE;
4766 (*tree)->probdiverelaxincludeslp =
FALSE;
4783 assert(tree != NULL);
4784 assert(*tree != NULL);
4785 assert((*tree)->nchildren == 0);
4786 assert((*tree)->nsiblings == 0);
4787 assert((*tree)->focusnode == NULL);
4796 for( p = 0; p <= 1; ++p )
4831 assert(tree != NULL);
4841 assert(tree->
root == NULL);
4849 assert(var != NULL);
4890 assert(tree != NULL);
4893 assert(tree->
root == NULL);
4918 SCIP_CALL(
treeNodesToQueue(tree, reopt, blkmem,
set, stat, eventqueue, lp, tree->
children, &tree->
nchildren, NULL,
4946 assert(tree != NULL);
4949 assert(tree->
root == NULL);
4955 assert(tree->
root != NULL);
4958 SCIP_CALL(
SCIPnodeFocus(&tree->
root, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4959 conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
4988 assert(tree != NULL);
4989 assert(tree->
root != NULL);
4995 SCIP_CALL(
SCIPnodeFocus(&node, blkmem,
set, messagehdlr, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4996 conflict, conflictstore, eventfilter, eventqueue, cliquetable, &cutoff,
FALSE,
FALSE) );
4998 assert(tree->
root == NULL);
5013 assert(tree != NULL);
5027 assert(tree != NULL);
5028 assert(stat != NULL);
5061 assert(tree != NULL);
5062 assert(stat != NULL);
5081 for( i = tree->
nsiblings-1; i >= 0; --i )
5086 SCIPsetDebugMsg(
set,
"cut off sibling #%" SCIP_LONGINT_FORMAT
" at depth %d with lowerbound=%g at position %d\n",
5089 if( set->reopt_enable )
5091 assert(reopt != NULL);
5104 for( i = tree->
nchildren-1; i >= 0; --i )
5109 SCIPsetDebugMsg(
set,
"cut off child #%" SCIP_LONGINT_FORMAT
" at depth %d with lowerbound=%g at position %d\n",
5112 if( set->reopt_enable )
5114 assert(reopt != NULL);
5151 assert(
set != NULL);
5173 switch( set->nodesel_childsel )
5188 prio = targetvalue - varsol;
5191 prio = varrootsol - varsol;
5195 if( !isroot && haslp )
5196 prio *= (varrootsol - varsol + 1.0);
5199 SCIPerrorMessage(
"invalid child selection rule <%c>\n", set->nodesel_childsel);
5205 SCIPerrorMessage(
"invalid preferred branching direction <%d> of variable <%s>\n",
5222 switch( set->nodesel_childsel )
5237 prio = varsol - targetvalue;
5240 prio = varsol - varrootsol;
5244 if( !isroot && haslp )
5245 prio *= (varsol - varrootsol + 1.0);
5248 SCIPerrorMessage(
"invalid child selection rule <%c>\n", set->nodesel_childsel);
5259 SCIPerrorMessage(
"invalid preferred branching direction <%d> of variable <%s>\n",
5294 assert(tree != NULL);
5295 assert(var != NULL);
5318 if( estimateinc > 0.0 )
5319 estimate += estimateinc;
5371 assert(tree != NULL);
5372 assert(
set != NULL);
5373 assert(var != NULL);
5376 if( downchild != NULL )
5378 if( eqchild != NULL )
5380 if( upchild != NULL )
5405 val = (val - constant) / scalar;
5474 SCIPsetDebugMsg(
set,
"fixing continuous variable <%s> with value %g and bounds [%.15g, %.15g], priority %d (current lower bound: %g)\n",
5506 SCIPsetDebugMsg(
set,
"continuous branch on variable <%s> with bounds [%.15g, %.15g], priority %d (current lower bound: %g), node %p\n",
5532 SCIPsetDebugMsg(
set,
"continuous branch on variable <%s> with value %g, priority %d (current lower bound: %g)\n",
5557 center = (ub + lb) / 2.0;
5561 uplb = downub + 1.0;
5566 downub = uplb - 1.0;
5578 downub = fixval - 1.0;
5582 uplb = fixval + 1.0;
5584 SCIPsetDebugMsg(
set,
"integral branch on variable <%s> with value %g, priority %d (current lower bound: %g)\n",
5591 uplb = downub + 1.0;
5593 SCIPsetDebugMsg(
set,
"fractional branch on variable <%s> with value %g, root value %g, priority %d (current lower bound: %g)\n",
5611 SCIPsetDebugMsg(
set,
" -> creating child: <%s> <= %g (priority: %g, estimate: %g)\n",
5614 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5619 if( downchild != NULL )
5628 SCIPsetDebugMsg(
set,
" -> creating child: <%s> == %g (priority: %g, estimate: %g)\n",
5633 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5638 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5644 if( eqchild != NULL )
5656 SCIPsetDebugMsg(
set,
" -> creating child: <%s> >= %g (priority: %g, estimate: %g)\n",
5659 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5664 if( upchild != NULL )
5696 assert(tree != NULL);
5697 assert(
set != NULL);
5698 assert(var != NULL);
5706 if( downchild != NULL )
5708 if( upchild != NULL )
5763 SCIPsetDebugMsg(
set,
" -> creating child: <%s> <= %g (priority: %g, estimate: %g)\n",
5767 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, NULL,
5772 if( downchild != NULL )
5783 SCIPsetDebugMsg(
set,
" -> creating child: <%s> >= %g (priority: %g, estimate: %g)\n",
5787 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
5792 if( upchild != NULL )
5846 assert(tree != NULL);
5847 assert(
set != NULL);
5848 assert(var != NULL);
5850 assert(minwidth >= 0.0);
5861 SCIP_CALL(
SCIPtreeBranchVar(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue, var, val,
5862 &downchild, &fixchild, &upchild) );
5864 if( nchildren != NULL )
5865 *nchildren = (downchild != NULL ? 1 : 0) + (fixchild != NULL ? 1 : 0) + (upchild != NULL ? 1 : 0);
5892 val = (val - constant) / scalar;
5966 else if( widthfactor == 1.0 )
5984 assert(widthfactor > 1.0);
5986 width *= (widthfactor - 1.0) / (
pow(widthfactor, (
SCIP_Real)(n/2)) - 1.0);
5988 width /= 0.5 + widthfactor * (
pow(widthfactor, (
SCIP_Real)(n/2)) - 1.0) / (widthfactor - 1.0);
5991 minwidth =
MAX(1.0, minwidth);
5992 if( width < minwidth )
5996 SCIPsetDebugMsg(
set,
"%d-ary branching on variable <%s> [%g, %g] around %g, initial width = %g\n",
5999 if( nchildren != NULL )
6006 left = val - width/2.0;
6007 right = val + width/2.0;
6024 SCIPsetDebugMsg(
set,
" -> creating middle child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6025 left,
SCIPvarGetName(var), right, priority, estimate, right - left);
6028 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
6030 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6035 if( nchildren != NULL )
6047 width *= widthfactor;
6055 if( right - left < 0.5 )
6072 for( i = 0; i < n; ++i )
6103 SCIPsetDebugMsg(
set,
" -> creating left child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6109 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6112 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6117 if( nchildren != NULL )
6137 bnd = right + width;
6154 SCIPsetDebugMsg(
set,
" -> creating right child: %g <= <%s> <= %g (priority: %g, estimate: %g, width: %g)\n",
6155 right,
SCIPvarGetName(var), bnd, priority, estimate, bnd - right);
6158 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6162 SCIP_CALL(
SCIPnodeAddBoundchg(node, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
6168 if( nchildren != NULL )
6176 width *= widthfactor;
6185 #define ARRAYGROWTH 5 6195 int idx = preferred ? 0 : 1;
6198 assert(pos < tree->divebdchgsize[idx]);
6227 int idx = preferred ? 0 : 1;
6229 assert(variables != NULL);
6230 assert(directions != NULL);
6231 assert(values != NULL);
6232 assert(ndivebdchgs != NULL);
6247 for( p = 0; p < 2; ++p )
6267 assert(tree != NULL);
6270 assert(blkmem != NULL);
6271 assert(
set != NULL);
6282 assert(node != NULL);
6306 SCIPsetDebugMsg(
set,
"created probing root node #%" SCIP_LONGINT_FORMAT
" at depth %d\n",
6314 SCIPsetDebugMsg(
set,
"created probing child node #%" SCIP_LONGINT_FORMAT
" at depth %d, probing depth %d\n",
6350 assert(tree != NULL);
6356 SCIPsetDebugMsg(
set,
"probing started in depth %d (LP flushed: %u, LP solved: %u, solstat: %d), probing root in depth %d\n",
6442 assert(tree != NULL);
6444 assert(lpistate != NULL);
6445 assert(lpinorms != NULL);
6492 assert(tree != NULL);
6508 assert(node != NULL);
6529 assert(node != NULL);
6534 if( lpistate == NULL )
6545 if( lpistate != NULL )
6548 lpwasprimfeas, lpwasprimchecked, lpwasdualfeas, lpwasdualchecked) );
6552 if( lpinorms != NULL )
6573 assert(tree != NULL);
6614 assert(tree != NULL);
6630 assert(newpathlen >= 1);
6633 if( newpathlen < tree->pathlen )
6645 while( tree->
pathlen > newpathlen )
6690 assert(tree->
pathlen == newpathlen);
6718 SCIP_CALL(
treeApplyPendingBdchgs(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, branchcand, eventqueue, cliquetable) );
6756 assert(tree != NULL);
6761 SCIP_CALL(
treeBacktrackProbing(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, primal, branchcand,
6762 eventqueue, eventfilter, cliquetable, probingdepth) );
6791 assert(tree != NULL);
6802 assert(
set != NULL);
6805 SCIP_CALL(
treeBacktrackProbing(tree, reopt, blkmem,
set, stat, transprob, origprob, lp, primal, branchcand,
6806 eventqueue, eventfilter, cliquetable, -1) );
6852 SCIP_CALL(
SCIPlpSolveAndEval(lp,
set, messagehdlr, blkmem, stat, eventqueue, eventfilter, transprob, -1LL,
FALSE,
FALSE,
FALSE, &lperror) );
6856 "(node %" SCIP_LONGINT_FORMAT
") unresolved numerical troubles while resolving LP %" SCIP_LONGINT_FORMAT
" after probing\n",
6867 "LP was not resolved to a sufficient status after probing\n");
6902 SCIPsetDebugMsg(
set,
"clearing lp state at end of probing mode because LP was initially unsolved\n");
6945 assert(tree != NULL);
6946 assert(
set != NULL);
6947 assert(relaxation != NULL);
6948 assert(transprob != NULL);
6951 nvars = transprob->
nvars;
6952 vars = transprob->
vars;
6961 for( v = 0; v < nvars; ++v )
6982 assert(tree != NULL);
6983 assert(
set != NULL);
6987 nvars = transprob->
nvars;
6988 vars = transprob->
vars;
6991 for( v = 0; v < nvars; ++v )
7011 assert(tree != NULL);
7023 assert((tree->
nchildren == 0) == (bestnode == NULL));
7037 assert(tree != NULL);
7049 assert((tree->
nsiblings == 0) == (bestnode == NULL));
7064 assert(tree != NULL);
7067 assert(nodesel != NULL);
7091 assert(tree != NULL);
7094 assert(nodesel != NULL);
7113 assert(tree != NULL);
7130 assert(tree != NULL);
7133 assert(nodesel != NULL);
7141 bestnode = bestchild;
7142 if( bestsibling != NULL && (bestnode == NULL ||
SCIPnodeselCompare(nodesel,
set, bestsibling, bestnode) < 0) )
7143 bestnode = bestsibling;
7144 if( bestleaf != NULL && (bestnode == NULL ||
SCIPnodeselCompare(nodesel,
set, bestleaf, bestnode) < 0) )
7145 bestnode = bestleaf;
7161 assert(tree != NULL);
7162 assert(
set != NULL);
7201 assert(tree != NULL);
7202 assert(
set != NULL);
7217 lowerboundnode = tree->
children[i];
7232 lowerboundnode = tree->
siblings[i];
7239 return lowerboundnode;
7252 assert(tree != NULL);
7281 return nnodes == 0 ? 0.0 : lowerboundsum/
nnodes;
7297 #undef SCIPnodeGetType 7298 #undef SCIPnodeGetNumber 7299 #undef SCIPnodeGetDepth 7300 #undef SCIPnodeGetLowerbound 7301 #undef SCIPnodeGetEstimate 7302 #undef SCIPnodeGetDomchg 7303 #undef SCIPnodeGetParent 7304 #undef SCIPnodeGetConssetchg 7305 #undef SCIPnodeIsActive 7306 #undef SCIPnodeIsPropagatedAgain 7307 #undef SCIPtreeGetNLeaves 7308 #undef SCIPtreeGetNChildren 7309 #undef SCIPtreeGetNSiblings 7310 #undef SCIPtreeGetNNodes 7311 #undef SCIPtreeIsPathComplete 7312 #undef SCIPtreeProbing 7313 #undef SCIPtreeGetProbingRoot 7314 #undef SCIPtreeGetProbingDepth 7315 #undef SCIPtreeGetFocusNode 7316 #undef SCIPtreeGetFocusDepth 7317 #undef SCIPtreeHasFocusNodeLP 7318 #undef SCIPtreeSetFocusNodeLP 7319 #undef SCIPtreeIsFocusNodeLPConstructed 7320 #undef SCIPtreeInRepropagation 7321 #undef SCIPtreeGetCurrentNode 7322 #undef SCIPtreeGetCurrentDepth 7323 #undef SCIPtreeHasCurrentNodeLP 7324 #undef SCIPtreeGetEffectiveRootDepth 7325 #undef SCIPtreeGetRootNode 7326 #undef SCIPtreeProbingObjChanged 7327 #undef SCIPtreeMarkProbingObjChanged 7334 assert(node != NULL);
7344 assert(node != NULL);
7354 assert(node != NULL);
7356 return (
int) node->
depth;
7364 assert(node != NULL);
7374 assert(node != NULL);
7384 assert(node != NULL);
7395 assert(node != NULL);
7405 node->
reopttype = (
unsigned int) reopttype;
7415 assert(node != NULL);
7426 assert(node != NULL);
7427 assert(
id <= 536870911);
7439 assert(node != NULL);
7457 assert(node != NULL);
7459 count_branchings = (nbranchings != NULL);
7460 count_consprop = (nconsprop != NULL);
7461 count_prop = (nprop != NULL);
7464 if( count_branchings )
7466 if( count_consprop )
7471 if( node->
domchg != NULL )
7504 int npseudobranchvars;
7506 assert(node != NULL);
7508 if( node->
domchg == NULL )
7514 npseudobranchvars = 0;
7516 assert(boundchgs != NULL);
7517 assert(nboundchgs >= 0);
7522 for( i = nboundchgs-1; i >= 0; i--)
7533 npseudobranchvars++;
7538 return npseudobranchvars;
7557 assert(node != NULL);
7558 assert(vars != NULL);
7559 assert(bounds != NULL);
7560 assert(boundtypes != NULL);
7561 assert(nvars != NULL);
7562 assert(varssize >= 0);
7572 assert(boundchgs != NULL);
7573 assert(nboundchgs >= 0);
7578 for( i = nboundchgs-1; i >= 0; i--)
7594 if( varssize >= *nvars )
7598 for( i = i+1; i < nboundchgs; i++)
7609 vars[j] = boundchgs[i].
var;
7624 assert(node != NULL);
7645 assert(node != NULL);
7646 assert(branchvars != NULL);
7647 assert(branchbounds != NULL);
7648 assert(boundtypes != NULL);
7649 assert(nbranchvars != NULL);
7650 assert(branchvarssize >= 0);
7660 assert(boundchgs != NULL);
7661 assert(nboundchgs >= 0);
7666 for( i = 0; i < nboundchgs; i++)
7676 for( ; i < nboundchgs; i++)
7681 if( branchvarssize >= *nbranchvars )
7683 for( i = 0; i < *nbranchvars; i++)
7686 branchvars[i] = boundchgs[i].
var;
7688 branchbounds[i] = boundchgs[i].
newbound;
7705 assert(node != NULL);
7706 assert(branchvars != NULL);
7707 assert(branchbounds != NULL);
7708 assert(boundtypes != NULL);
7709 assert(nbranchvars != NULL);
7710 assert(branchvarssize >= 0);
7716 int nodenbranchvars;
7720 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
7721 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
7724 *nbranchvars += nodenbranchvars;
7743 assert(node != NULL);
7744 assert(parent != NULL);
7745 assert(branchvars != NULL);
7746 assert(branchbounds != NULL);
7747 assert(boundtypes != NULL);
7748 assert(nbranchvars != NULL);
7749 assert(branchvarssize >= 0);
7753 while( node != parent )
7755 int nodenbranchvars;
7759 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
7760 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
7763 *nbranchvars += nodenbranchvars;
7780 int conspropvarssize
7789 assert(node != NULL);
7790 assert(vars != NULL);
7791 assert(varbounds != NULL);
7792 assert(varboundtypes != NULL);
7793 assert(nconspropvars != NULL);
7794 assert(conspropvarssize >= 0);
7796 (*nconspropvars) = 0;
7804 assert(boundchgs != NULL);
7805 assert(nboundchgs >= 0);
7810 while( i < nboundchgs
7818 for(i = nskip; i < first_dual; i++)
7834 if( conspropvarssize >= *nconspropvars )
7838 for(i = nskip, pos = 0; i < first_dual; i++)
7844 vars[pos] = boundchgs[i].
var;
7846 varbounds[pos] = boundchgs[i].
newbound;
7877 assert(node != NULL);
7878 assert(vars != NULL);
7879 assert(varbounds != NULL);
7880 assert(varboundtypes != NULL);
7881 assert(nbranchvars != NULL);
7882 assert(branchvarssize >= 0);
7892 assert(boundchgs != NULL);
7893 assert(nboundchgs >= 0);
7897 while( i < nboundchgs
7905 for( ; i < nboundchgs; i++)
7918 if( branchvarssize >= *nbranchvars )
7921 for(i = first_dual, p = start; i < nboundchgs; i++)
7928 vars[p] = boundchgs[i].
var;
7930 varbounds[p] = boundchgs[i].
newbound;
7961 for( i = 0; i < nboundchgs; i++)
7969 SCIPgmlWriteNode(file, (
unsigned int)nbranchings, label,
"circle", NULL, NULL);
7971 if( nbranchings > 0 )
7973 SCIPgmlWriteArc(file, (
unsigned int)nbranchings, (
unsigned int)(nbranchings-1), NULL, NULL);
8007 assert(node != NULL);
8008 assert(branchvars != NULL);
8009 assert(branchbounds != NULL);
8010 assert(boundtypes != NULL);
8011 assert(nbranchvars != NULL);
8012 assert(branchvarssize >= 0);
8020 int nodenbranchvars;
8025 start = *nbranchvars < branchvarssize - 1 ? *nbranchvars : branchvarssize - 1;
8026 size = *nbranchvars > branchvarssize ? 0 : branchvarssize-(*nbranchvars);
8027 if( *nnodes < nodeswitchsize )
8028 nodeswitches[*
nnodes] = start;
8032 *nbranchvars += nodenbranchvars;
8045 assert(node1 != NULL);
8046 assert(node2 != NULL);
8060 return (node1 == node2);
8069 assert(node1 != NULL);
8070 assert(node2 != NULL);
8083 while( node1 != node2 )
8099 assert(node != NULL);
8109 assert(node != NULL);
8119 assert(node != NULL);
8129 assert(tree != NULL);
8139 assert(tree != NULL);
8149 assert(tree != NULL);
8159 assert(tree != NULL);
8169 assert(tree != NULL);
8186 assert(tree != NULL);
8199 assert(tree != NULL);
8212 assert(tree != NULL);
8229 assert(tree != NULL);
8246 assert(tree != NULL);
8257 assert(tree != NULL);
8267 assert(tree != NULL);
8277 assert(tree != NULL);
8287 assert(tree != NULL);
8304 assert(tree != NULL);
8321 assert(tree != NULL);
8332 assert(tree != NULL);
8343 assert(tree != NULL);
8354 assert(tree != NULL);
8365 assert(tree != NULL);
8376 assert(tree != NULL);
SCIP_RETCODE SCIPtreeClear(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_RETCODE forkAddLP(SCIP_NODE *fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
SCIP_DECL_SORTPTRCOMP(SCIPnodeCompLowerbound)
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_RETCODE SCIPtreeAddDiveBoundChange(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
SCIP_RETCODE SCIPlpGetProvedLowerbound(SCIP_LP *lp, SCIP_SET *set, SCIP_Real *bound)
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)
void SCIPnodeGetParentBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)
void SCIPnodeGetDualBoundchgs(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int *nvars, int varssize)
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
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)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
internal methods for managing events
SCIP_RETCODE SCIPlpFreeNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPnodepqBound(SCIP_NODEPQ *nodepq, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_Real cutoffbound)
SCIP_Bool lpwasdualchecked
SCIP_RETCODE SCIPnodeCreateChild(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_RETCODE SCIPtreeSetProbingLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_LP *lp, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_PSEUDOFORK * pseudofork
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 SCIPlpGetNNewrows(SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
void SCIPvisualRepropagatedNode(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)
static SCIP_RETCODE treeEnsurePendingbdchgsMem(SCIP_TREE *tree, SCIP_SET *set, int num)
unsigned int lpwasdualfeas
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
SCIP_Bool SCIPtreeHasFocusNodeLP(SCIP_TREE *tree)
static SCIP_RETCODE junctionInit(SCIP_JUNCTION *junction, SCIP_TREE *tree)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_RETCODE SCIPconssetchgFree(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set)
#define SCIPdebugRemoveNode(blkmem, set, node)
#define BMSfreeMemoryArrayNull(ptr)
SCIP_RETCODE SCIPlpShrinkRows(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, int newnrows)
void SCIPlpSetIsRelax(SCIP_LP *lp, SCIP_Bool relax)
union SCIP_BoundChg::@12 data
static SCIP_RETCODE probingnodeUpdate(SCIP_PROBINGNODE *probingnode, BMS_BLKMEM *blkmem, SCIP_TREE *tree, SCIP_LP *lp)
internal methods for branch and bound tree
SCIP_Real SCIPtreeCalcChildEstimate(SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real targetvalue)
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_Longint ndeactivatednodes
void SCIPtreeSetFocusNodeLP(SCIP_TREE *tree, SCIP_Bool solvelp)
SCIP_NODE * SCIPnodesGetCommonAncestor(SCIP_NODE *node1, SCIP_NODE *node2)
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_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_NODE * SCIPtreeGetLowerboundNode(SCIP_TREE *tree, SCIP_SET *set)
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPlpRemoveAllObsoletes(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
methods for implications, variable bounds, and cliques
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
int SCIPnodepqCompare(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node1, SCIP_NODE *node2)
SCIP_Longint focuslpstateforklpcount
static SCIP_RETCODE pseudoforkCreate(SCIP_PSEUDOFORK **pseudofork, BMS_BLKMEM *blkmem, SCIP_TREE *tree, SCIP_LP *lp)
SCIP_RETCODE SCIPtreeSetNodesel(SCIP_TREE *tree, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_NODESEL *nodesel)
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
static SCIP_RETCODE treeEnsurePathMem(SCIP_TREE *tree, SCIP_SET *set, int num)
internal methods for clocks and timing issues
SCIPInterval pow(const SCIPInterval &x, const SCIPInterval &y)
SCIP_BRANCHDIR * divebdchgdirs[2]
SCIP_BOUNDCHG * boundchgs
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
int SCIPtreeGetProbingDepth(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeDelCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)
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_Real SCIPvarGetLbLocal(SCIP_VAR *var)
void SCIProwCapture(SCIP_ROW *row)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_PROBINGNODE * probingnode
SCIP_RETCODE SCIPtreeCreate(SCIP_TREE **tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_NODESEL *nodesel)
unsigned int repropsubtreemark
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPnodeGetAddedConss(SCIP_NODE *node, SCIP_CONS **addedconss, int *naddedconss, int addedconsssize)
void SCIPnodeSetReoptID(SCIP_NODE *node, unsigned int id)
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 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)
interface methods for specific LP solvers
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_NODE * SCIPtreeGetBestNode(SCIP_TREE *tree, SCIP_SET *set)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Longint nactiveconssadded
SCIP_NODE * SCIPtreeGetProbingRoot(SCIP_TREE *tree)
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
SCIP_NODE * SCIPtreeGetBestChild(SCIP_TREE *tree, SCIP_SET *set)
SCIP_Real * divebdchgvals[2]
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
int SCIPnodepqLen(const SCIP_NODEPQ *nodepq)
SCIP_RETCODE SCIPlpFreeState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
void SCIPgmlWriteClosing(FILE *file)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
unsigned int lpwasdualchecked
static SCIP_RETCODE subrootFree(SCIP_SUBROOT **subroot, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
static void forkCaptureLPIState(SCIP_FORK *fork, int nuses)
SCIP_Bool probdiverelaxstored
SCIP_LPINORMS * probinglpinorms
static SCIP_RETCODE focusnodeToLeaf(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_NODE *lpstatefork, SCIP_Real cutoffbound)
static void treeRemoveSibling(SCIP_TREE *tree, SCIP_NODE *sibling)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
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_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)
SCIP_Bool probinglpwasdualchecked
struct SCIP_LPiNorms SCIP_LPINORMS
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Longint ncreatednodes
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPeventqueueDelay(SCIP_EVENTQUEUE *eventqueue)
SCIP_NODE * SCIPnodepqGetLowerboundNode(SCIP_NODEPQ *nodepq, SCIP_SET *set)
enum SCIP_Retcode SCIP_RETCODE
SCIP_RETCODE SCIPtreeLoadLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPlpGetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
SCIP_Real SCIPnodepqGetLowerboundSum(SCIP_NODEPQ *nodepq)
int SCIPvarGetProbindex(SCIP_VAR *var)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)
#define BMSallocMemoryArray(ptr, num)
SCIP_Bool probinglpwasflushed
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_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool *lperror)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
SCIP_RETCODE SCIPlpCleanupAll(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Bool root)
void SCIPrelaxationSetSolValid(SCIP_RELAXATION *relaxation, SCIP_Bool isvalid, SCIP_Bool includeslp)
SCIP_Bool probingsolvedlp
SCIP_Bool SCIPrelaxationIsSolValid(SCIP_RELAXATION *relaxation)
SCIP_RETCODE SCIPlpSetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS *lpinorms)
int SCIPnodeGetDepth(SCIP_NODE *node)
methods for creating output for visualization tools (VBC, BAK)
static SCIP_RETCODE treeAddChild(SCIP_TREE *tree, SCIP_SET *set, SCIP_NODE *child, SCIP_Real nodeselprio)
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
#define BMSfreeMemory(ptr)
SCIP_RETCODE SCIPlpEndProbing(SCIP_LP *lp)
SCIP_NODESEL * SCIPnodepqGetNodesel(SCIP_NODEPQ *nodepq)
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
static void treeChildrenToSiblings(SCIP_TREE *tree)
unsigned int lpwasdualfeas
SCIP_CONS ** disabledconss
static SCIP_RETCODE probingnodeFree(SCIP_PROBINGNODE **probingnode, BMS_BLKMEM *blkmem, SCIP_LP *lp)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)
static SCIP_RETCODE treeCreateProbingNode(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
#define SCIPstatIncrement(stat, set, field)
internal methods for LP management
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Bool SCIPtreeIsPathComplete(SCIP_TREE *tree)
SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)
void SCIPnodeGetAncestorBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)
internal methods for collecting primal CIP solutions and primal informations
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
int SCIPlpGetNCols(SCIP_LP *lp)
unsigned int lpwasprimchecked
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
internal methods for propagators
SCIP_Bool SCIPclockIsRunning(SCIP_CLOCK *clck)
SCIP_RETCODE SCIPnodepqInsert(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node)
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
static SCIP_RETCODE pseudoforkAddLP(SCIP_NODE *pseudofork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
enum SCIP_BranchDir SCIP_BRANCHDIR
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
int SCIPtreeGetNChildren(SCIP_TREE *tree)
SCIP_NODE * SCIPtreeGetBestLeaf(SCIP_TREE *tree)
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)
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)
unsigned int lpwasprimchecked
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_Bool probinglpwassolved
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 SCIPtreeCalcNodeselPriority(SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BRANCHDIR branchdir, SCIP_Real targetvalue)
SCIP_REOPTTYPE SCIPnodeGetReopttype(SCIP_NODE *node)
SCIP_Bool probingloadlpistate
static SCIP_RETCODE subrootConstructLP(SCIP_NODE *subroot, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp)
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
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 SCIPlpSetState(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LPISTATE *lpistate, SCIP_Bool wasprimfeas, SCIP_Bool wasprimchecked, SCIP_Bool wasdualfeas, SCIP_Bool wasdualchecked)
SCIP_RETCODE SCIPvisualNewChild(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)
void SCIPnodeUpdateLowerbound(SCIP_NODE *node, SCIP_STAT *stat, SCIP_SET *set, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real newbound)
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
int SCIPlpGetNNewcols(SCIP_LP *lp)
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
SCIP_RETCODE SCIPconssetchgApply(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
SCIP_Bool probingobjchanged
SCIP_RETCODE SCIPlpStartProbing(SCIP_LP *lp)
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_Bool SCIPnodesSharePath(SCIP_NODE *node1, SCIP_NODE *node2)
void SCIPnodeGetAncestorBranchingPath(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize, int *nodeswitches, int *nnodes, int nodeswitchsize)
#define BMSfreeMemoryArray(ptr)
static SCIP_RETCODE forkReleaseLPIState(SCIP_FORK *fork, BMS_BLKMEM *blkmem, SCIP_LP *lp)
static void treeFindSwitchForks(SCIP_TREE *tree, SCIP_NODE *node, SCIP_NODE **commonfork, SCIP_NODE **newlpfork, SCIP_NODE **newlpstatefork, SCIP_NODE **newsubroot, SCIP_Bool *cutoff)
internal methods for storing and manipulating the main problem
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_RETCODE pseudoforkFree(SCIP_PSEUDOFORK **pseudofork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
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)
void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)
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)
SCIP_RETCODE SCIPlpAddCol(SCIP_LP *lp, SCIP_SET *set, SCIP_COL *col, int depth)
SCIP_Bool SCIPtreeInRepropagation(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeFocus(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool postponed, SCIP_Bool exitsolve)
#define SCIPdebugCheckInference(blkmem, set, node, var, newbound, boundtype)
SCIP_Bool SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPlpShrinkCols(SCIP_LP *lp, SCIP_SET *set, int newncols)
SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)
SCIP_LPISTATE * probinglpistate
SCIP_RETCODE SCIPnodepqSetNodesel(SCIP_NODEPQ **nodepq, SCIP_SET *set, SCIP_NODESEL *nodesel)
void SCIPnodeMarkPropagated(SCIP_NODE *node, SCIP_TREE *tree)
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)
SCIP_NODE * focuslpstatefork
const char * SCIPconsGetName(SCIP_CONS *cons)
void SCIPlpMarkSize(SCIP_LP *lp)
SCIP_RETCODE SCIPnodePrintAncestorBranchings(SCIP_NODE *node, FILE *file)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_NODE * SCIPtreeGetBestSibling(SCIP_TREE *tree, SCIP_SET *set)
void SCIPnodeGetAncestorBranchingsPart(SCIP_NODE *node, SCIP_NODE *parent, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)
SCIP_Bool SCIPnodeIsPropagatedAgain(SCIP_NODE *node)
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
struct SCIP_LPiState SCIP_LPISTATE
static void treeCheckPath(SCIP_TREE *tree)
SCIP_DOMCHG * SCIPnodeGetDomchg(SCIP_NODE *node)
SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)
SCIP_RETCODE SCIPtreeLoadLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool *initroot)
enum SCIP_ReoptType SCIP_REOPTTYPE
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
int appliedeffectiverootdepth
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)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_Bool SCIPsetIsRelGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
static void subrootCaptureLPIState(SCIP_SUBROOT *subroot, int nuses)
internal methods for node selectors and node priority queues
SCIP_Real * probdiverelaxsol
static SCIP_RETCODE treeEnsureChildrenMem(SCIP_TREE *tree, SCIP_SET *set, int num)
#define SCIP_PROPTIMING_ALWAYS
internal methods for global SCIP settings
internal methods for storing conflicts
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPlpGetNRows(SCIP_LP *lp)
SCIP_CONSSETCHG * SCIPnodeGetConssetchg(SCIP_NODE *node)
int SCIPnodeselCompare(SCIP_NODESEL *nodesel, SCIP_SET *set, SCIP_NODE *node1, SCIP_NODE *node2)
SCIP_RETCODE SCIPconsDisable(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Bool probinglpwasprimchecked
internal methods for relaxators
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugCheckLbGlobal(scip, var, lb)
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_Longint ncreatednodesrun
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
SCIP_RETCODE SCIPnodepqFree(SCIP_NODEPQ **nodepq, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)
SCIP_Real SCIPtreeGetAvgLowerbound(SCIP_TREE *tree, SCIP_Real cutoffbound)
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
void SCIPtreeClearDiveBoundChanges(SCIP_TREE *tree)
#define BMSfreeBlockMemory(mem, ptr)
data structures and methods for collecting reoptimization information
internal methods for problem variables
void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)
int SCIPnodeGetNDualBndchgs(SCIP_NODE *node)
static SCIP_RETCODE nodeReleaseParent(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
unsigned int boundchgtype
void SCIPnodePropagateAgain(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree)
SCIP_INFERENCEDATA inferencedata
SCIP_RETCODE SCIPlpClear(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
static SCIP_RETCODE treeUpdatePathLPSize(SCIP_TREE *tree, int startdepth)
int SCIPtreeGetEffectiveRootDepth(SCIP_TREE *tree)
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
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)
void SCIPvarCapture(SCIP_VAR *var)
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)
#define BMSallocBlockMemoryArray(mem, ptr, num)
SCIP_Bool lpwasprimchecked
int SCIPsetCalcPathGrowSize(SCIP_SET *set, int num)
SCIP_Bool focuslpconstructed
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
SCIP_Longint nearlybacktracks
SCIP_RETCODE SCIPtreeStartProbing(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob, SCIP_Bool strongbranching)
SCIP_RETCODE SCIPtreeCreateRoot(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_RETCODE nodeAssignParent(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_TREE *tree, SCIP_NODE *parent, SCIP_Real nodeselprio)
SCIP_ROW ** SCIPlpGetNewrows(SCIP_LP *lp)
int SCIPvarGetBranchPriority(SCIP_VAR *var)
SCIP_RETCODE SCIPnodepqRemove(SCIP_NODEPQ *nodepq, SCIP_SET *set, SCIP_NODE *node)
void SCIPtreeGetDiveBoundChangeData(SCIP_TREE *tree, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
unsigned int lpwasdualchecked
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)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
SCIP_Longint nrepropcutoffs
static SCIP_RETCODE probingnodeCreate(SCIP_PROBINGNODE **probingnode, BMS_BLKMEM *blkmem, SCIP_LP *lp)
SCIP_RETCODE SCIPnodepqCreate(SCIP_NODEPQ **nodepq, SCIP_SET *set, SCIP_NODESEL *nodesel)
static SCIP_RETCODE forkCreate(SCIP_FORK **fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_LP *lp)
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_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
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)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
#define SCIP_EVENTTYPE_NODEINFEASIBLE
SCIP_Bool SCIPsetIsRelLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
const char * SCIPnodeselGetName(SCIP_NODESEL *nodesel)
SCIP_NODE * SCIPnodepqFirst(const SCIP_NODEPQ *nodepq)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPconshdlrsResetPropagationStatus(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
SCIP_RETCODE SCIPpropagateDomains(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICT *conflict, SCIP_CLIQUETABLE *cliquetable, int depth, int maxproprounds, SCIP_PROPTIMING timingmask, SCIP_Bool *cutoff)
SCIP_Bool probinglpwasrelax
SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)
SCIP_RETCODE SCIPvisualUpdateChild(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node)
SCIP_RETCODE SCIPnodeCaptureLPIState(SCIP_NODE *node, int nuses)
void SCIPlpSetSizeMark(SCIP_LP *lp, int nrows, int ncols)
static SCIP_RETCODE forkFree(SCIP_FORK **fork, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
void SCIPnodeGetBdChgsAfterDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int start, int *nbranchvars, int branchvarssize)
SCIP_NODESEL * SCIPtreeGetNodesel(SCIP_TREE *tree)
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool probdiverelaxincludeslp
SCIP_RETCODE SCIPlpGetNorms(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
#define SCIP_MAXTREEDEPTH
SCIP_RETCODE SCIPnodeReleaseLPIState(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_LP *lp)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_CONSSETCHG * conssetchg
SCIP_RETCODE SCIPtreeFree(SCIP_TREE **tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Real SCIPnodeGetEstimate(SCIP_NODE *node)
SCIP_Real SCIPlpGetModifiedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
enum SCIP_NodeType SCIP_NODETYPE
static SCIP_RETCODE nodeToLeaf(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_NODE *lpstatefork, SCIP_Real cutoffbound)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
SCIP_DOMCHGBOUND domchgbound
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)
int SCIPtreeGetNSiblings(SCIP_TREE *tree)
int SCIPnodeGetNAddedConss(SCIP_NODE *node)
SCIP_Bool SCIPtreeProbingObjChanged(SCIP_TREE *tree)
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)
static void treeNextRepropsubtreecount(SCIP_TREE *tree)
SCIP_Real SCIPnodepqGetLowerbound(SCIP_NODEPQ *nodepq, SCIP_SET *set)
SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)
SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)
internal methods for main solving loop and node processing
SCIP_RETCODE SCIPconssetchgUndo(SCIP_CONSSETCHG *conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
unsigned int SCIPnodeGetReoptID(SCIP_NODE *node)
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 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)
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)
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 SCIPtreeMarkProbingNodeHasLP(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_LP *lp)
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
unsigned int updatedisable
public methods for message output
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_RETCODE SCIPnodepqClear(SCIP_NODEPQ *nodepq, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)
static SCIP_RETCODE subrootReleaseLPIState(SCIP_SUBROOT *subroot, BMS_BLKMEM *blkmem, SCIP_LP *lp)
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)
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
static SCIP_RETCODE nodeCreate(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set)
void SCIPvisualCutoffNode(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_STAT *stat, SCIP_NODE *node, SCIP_Bool infeasible)
internal methods for problem statistics
void SCIPstatUpdatePrimalDualIntegral(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
SCIP_VAR ** divebdchgvars[2]
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_RETCODE SCIPtreeStoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPtreeLoadProbingLPState(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Longint nrepropboundchgs
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
#define BMSallocMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
internal methods for constraints and constraint handlers
SCIP_NODE * SCIPtreeGetPrioChild(SCIP_TREE *tree)
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
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)
SCIP_Bool SCIPnodeIsActive(SCIP_NODE *node)
SCIP_RETCODE SCIPnodeAddCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)
SCIP_Longint nactivatednodes
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPnodeUpdateLowerboundLP(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
void SCIPnodeSetReopttype(SCIP_NODE *node, SCIP_REOPTTYPE reopttype)
static SCIP_RETCODE treeNodesToQueue(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_NODE **nodes, int *nnodes, SCIP_NODE *lpstatefork, SCIP_Real cutoffbound)
SCIP_RETCODE SCIPconssetchgMakeGlobal(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_REOPT *reopt)
SCIP_CLOCK * nodeactivationtime
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
SCIP_RETCODE SCIPconssetchgAddDisabledCons(SCIP_CONSSETCHG **conssetchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS *cons)
SCIP_Bool probinglpwasprimfeas
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
#define BMSallocBlockMemory(mem, ptr)
SCIP_RETCODE SCIPtreeCutoff(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real cutoffbound)
SCIP_RETCODE SCIPtreeRestoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)
unsigned int lpwasprimfeas
SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPprobDelVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Bool *deleted)
common defines and data types used in all packages of SCIP
SCIP_Real SCIPlpGetModifiedProvedPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
void SCIPvisualMarkedRepropagateNode(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)
SCIP_PENDINGBDCHG * pendingbdchgs
SCIP_Bool probingnodehaslp
struct BMS_BlkMem BMS_BLKMEM
int SCIPtreeGetNLeaves(SCIP_TREE *tree)
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
static void treeRemoveChild(SCIP_TREE *tree, SCIP_NODE *child)
SCIP_RETCODE SCIPconshdlrsStorePropagationStatus(SCIP_SET *set, SCIP_CONSHDLR **conshdlrs, int nconshdlrs)
SCIP_COL ** SCIPlpGetNewcols(SCIP_LP *lp)
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 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)
int SCIPtreeGetNNodes(SCIP_TREE *tree)
SCIP_Bool SCIPsetIsRelGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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)
SCIP_Longint nprobholechgs
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
void SCIPchildChgNodeselPrio(SCIP_TREE *tree, SCIP_NODE *child, SCIP_Real priority)
union SCIP_Node::@10 data
unsigned int lpwasprimfeas
void SCIPnodeGetConsProps(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *nconspropvars, int conspropvarssize)
SCIP_RETCODE SCIPnodeFree(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)
SCIP_RETCODE SCIPtreeCreateProbingNode(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
void SCIPlpUnmarkDivingObjChanged(SCIP_LP *lp)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
SCIP_BOUNDCHG * boundchgs
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)
static SCIP_RETCODE focusnodeToJunction(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_TREE *tree, SCIP_LP *lp)
void SCIPtreeMarkProbingObjChanged(SCIP_TREE *tree)
SCIP_Bool SCIPrelaxationIsLpIncludedForSol(SCIP_RELAXATION *relaxation)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Bool probinglpwasdualfeas
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_NODE * SCIPtreeGetPrioSibling(SCIP_TREE *tree)