167#if defined(_WIN32) || defined(_WIN64)
176#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
184static FILE* confgraphfile =
NULL;
186static int confgraphnconflictsets = 0;
190void confgraphWriteNode(
193 const char* nodetype,
194 const char* fillcolor,
195 const char* bordercolor
200#ifdef SCIP_CONFGRAPH_DOT
201 SCIPdotWriteNode(confgraphfile, (
int)(
size_t) idptr, label, nodetype, fillcolor, bordercolor);
204 SCIPgmlWriteNode(confgraphfile, (
unsigned int)(
size_t)idptr, label, nodetype, fillcolor, bordercolor);
211void confgraphWriteEdge(
219#ifdef SCIP_CONFGRAPH_DOT
220 SCIPdotWriteArc(confgraphfile, (
int)(
size_t)source, (
int)(
size_t)target, color);
223#ifndef SCIP_CONFGRAPH_EDGE
224 SCIPgmlWriteArc(confgraphfile, (
unsigned int)(
size_t)source, (
unsigned int)(
size_t)target,
NULL, color);
227 SCIPgmlWriteEdge(confgraphfile, (
unsigned int)(
size_t)source, (
unsigned int)(
size_t)target,
NULL, color);
244#ifdef SCIP_CONFGRAPH_DOT
251 confgraphfile = fopen(fname,
"w");
253 if( confgraphfile ==
NULL )
260#ifdef SCIP_CONFGRAPH_DOT
265 confgraphWriteNode(
NULL,
"conflict",
"ellipse",
"#ff0000",
"#000000");
267 confgraphcurrentbdchginfo =
NULL;
278 if( confgraphfile !=
NULL )
280#ifdef SCIP_CONFGRAPH_DOT
285 fclose(confgraphfile);
287 confgraphfile =
NULL;
288 confgraphnconflictsets = 0;
294void confgraphAddBdchg(
298 const char* colors[] = {
332 confgraphWriteNode(bdchginfo, label,
"ellipse", colors[col],
"#000000");
333 confgraphWriteEdge(bdchginfo, confgraphcurrentbdchginfo,
"#000000");
338void confgraphLinkBdchg(
342 confgraphWriteEdge(bdchginfo, confgraphcurrentbdchginfo,
"#000000");
347void confgraphSetCurrentBdchg(
351 confgraphcurrentbdchginfo = bdchginfo;
356void confgraphMarkConflictset(
365 confgraphnconflictsets++;
367 confgraphWriteNode((
void*)(
size_t)confgraphnconflictsets, label,
"rectangle",
"#ff00ff",
"#000000");
369 confgraphWriteEdge((
void*)(
size_t)confgraphnconflictsets, conflictset->
bdchginfos[
i],
"#ff00ff");
398 assert(num <= conflictset->bdchginfossize);
436 assert((
int)boundtype == 0 || (
int)boundtype == 1);
437 sortval = 2*idx + (int)boundtype;
449 if( pos > 0 && sortval == sortvals[pos-1] )
465 relaxedbds[pos-1] = boundtype ==
SCIP_BOUNDTYPE_LOWER ?
MAX(relaxedbds[pos-1], relaxedbd) :
MIN(relaxedbds[pos-1], relaxedbd);
594 sortval = conflictset2->
sortvals[i2];
610void conflictsetPrint(
653 for( v = conflictset->
nbdchginfos - 1; v >= 0; --v )
663 bound = relaxedbds[v];
763 for( v = nbdchginfos - 1; v >= 0; --v )
766 bound = relaxedbds[v];
771 bound += (isupper ? -1.0 : +1.0);
779 bdchginfos[v] = bdchginfos[nbdchginfos - 1];
780 relaxedbds[v] = relaxedbds[nbdchginfos - 1];
781 sortvals[v] = sortvals[nbdchginfos - 1];
789 SCIPsetDebugMsg(
set,
"trivially removed %d redundant of %d variables from conflictset (%p)\n", ntrivialredvars, conflictset->
nbdchginfos, (
void*)conflictset);
799 *nredvars = ntrivialredvars;
812 for( v = 0; v < nbdchginfos; ++v )
816 bounds[v] = relaxedbds[v];
844 bounds[v] += ((!boundtypes[v]) ? +1.0 : -1.0);
860 if( nbinimpls[v] == 0 )
865 if( v == nbdchginfos && ((!
set->conf_fullshortenconflict && nzeroimpls < 2) || (
set->conf_fullshortenconflict && nzeroimpls < nbdchginfos)) )
876 for( v = 0; v < nbdchginfos; ++v )
879 if( v < nbdchginfos - 1 )
888 for( v = 0; v < nbdchginfos; ++v )
892 nbdchgs, redundant, &glbinfeas,
set->conf_fullshortenconflict) );
896 SCIPsetDebugMsg(
set,
"conflict set (%p) led to global infeasibility\n", (
void*) conflictset);
908 SCIPsetDebugMsg(
set,
"conflict set (%p) led to %d global bound reductions\n", (
void*) conflictset, *nbdchgs);
915 SCIPsetDebugMsg(
set,
"conflict set (%p) is redundant because at least one global reduction, fulfills the conflict constraint\n", (
void*)conflictset);
920 else if( *nredvars > 0 )
926 for( v = nbdchginfos - 1; v >= 0; --v )
933 bdchginfos[v] = bdchginfos[nbdchginfos - 1];
934 relaxedbds[v] = relaxedbds[nbdchginfos - 1];
935 sortvals[v] = sortvals[nbdchginfos - 1];
945 SCIPsetDebugMsg(
set,
"removed %d redundant of %d variables from conflictset (%p)\n", (*nredvars), conflictset->
nbdchginfos, (
void*)conflictset);
946 conflictset->nbdchginfos = nbdchginfos;
964 *nredvars += ntrivialredvars;
997 (*conflictset)->bdchginfos =
NULL;
998 (*conflictset)->relaxedbds =
NULL;
999 (*conflictset)->sortvals =
NULL;
1000 (*conflictset)->bdchginfossize = 0;
1013 int nadditionalelems
1021 targetsize = sourceconflictset->
nbdchginfos + nadditionalelems;
1026 (*targetconflictset)->bdchginfossize = targetsize;
1032 (*targetconflictset)->nbdchginfos = sourceconflictset->
nbdchginfos;
1033 (*targetconflictset)->validdepth = sourceconflictset->
validdepth;
1034 (*targetconflictset)->insertdepth = sourceconflictset->
insertdepth;
1035 (*targetconflictset)->conflictdepth = sourceconflictset->
conflictdepth;
1036 (*targetconflictset)->repropdepth = sourceconflictset->
repropdepth;
1037 (*targetconflictset)->usescutoffbound = sourceconflictset->
usescutoffbound;
1038 (*targetconflictset)->hasrelaxonlyvar = sourceconflictset->
hasrelaxonlyvar;
1039 (*targetconflictset)->conflicttype = sourceconflictset->
conflicttype;
1118 if( conflicthdlr->conflictcopy !=
NULL )
1121 SCIP_CALL( conflicthdlr->conflictcopy(
set->scip, conflicthdlr) );
1159 (*conflicthdlr)->priority = priority;
1160 (*conflicthdlr)->conflictcopy = conflictcopy;
1161 (*conflicthdlr)->conflictfree = conflictfree;
1162 (*conflicthdlr)->conflictinit = conflictinit;
1163 (*conflicthdlr)->conflictexit = conflictexit;
1164 (*conflicthdlr)->conflictinitsol = conflictinitsol;
1165 (*conflicthdlr)->conflictexitsol = conflictexitsol;
1166 (*conflicthdlr)->conflictexec = conflictexec;
1167 (*conflicthdlr)->conflicthdlrdata = conflicthdlrdata;
1168 (*conflicthdlr)->initialized =
FALSE;
1177 priority, INT_MIN, INT_MAX, paramChgdConflicthdlrPriority, (
SCIP_PARAMDATA*)(*conflicthdlr)) );
1207 conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec,
1220 if( *conflicthdlr ==
NULL )
1222 assert(!(*conflicthdlr)->initialized);
1226 if( (*conflicthdlr)->conflictfree !=
NULL )
1228 SCIP_CALL( (*conflicthdlr)->conflictfree(
set->scip, *conflicthdlr) );
1256 if(
set->misc_resetstat )
1263 if( conflicthdlr->conflictinit !=
NULL )
1268 SCIP_CALL( conflicthdlr->conflictinit(
set->scip, conflicthdlr) );
1294 if( conflicthdlr->conflictexit !=
NULL )
1299 SCIP_CALL( conflicthdlr->conflictexit(
set->scip, conflicthdlr) );
1319 if( conflicthdlr->conflictinitsol !=
NULL )
1324 SCIP_CALL( conflicthdlr->conflictinitsol(
set->scip, conflicthdlr) );
1343 if( conflicthdlr->conflictexitsol !=
NULL )
1348 SCIP_CALL( conflicthdlr->conflictexitsol(
set->scip, conflicthdlr) );
1374 assert(bdchginfos !=
NULL || nbdchginfos == 0);
1379 if( conflicthdlr->conflictexec !=
NULL )
1384 SCIP_CALL( conflicthdlr->conflictexec(
set->scip, conflicthdlr, node, validnode, bdchginfos, relaxedbds, nbdchginfos,
1386 set->conf_removable, resolved,
result) );
1395 SCIPerrorMessage(
"execution method of conflict handler <%s> returned invalid result <%d>\n",
1433 conflicthdlr->conflictcopy = conflictcopy;
1444 conflicthdlr->conflictfree = conflictfree;
1456 conflicthdlr->conflictinit = conflictinit;
1467 conflicthdlr->conflictexit = conflictexit;
1478 conflicthdlr->conflictinitsol = conflictinitsol;
1489 conflicthdlr->conflictexitsol = conflictexitsol;
1499 return conflicthdlr->
name;
1509 return conflicthdlr->
desc;
1586 if( !
set->conf_enable || !
set->conf_useprop )
1590 if(
set->nconflicthdlrs == 0 )
1615 assert(num <= conflict->tmpbdchginfossize);
1636 var, boundtype, oldbound, newbound) );
1701 if( insertdepth > 0 )
1712 for(
i = 0;
i < conflictlength;
i++ )
1792 SCIP_CALL(
detectImpliedBounds(
set, transprob, stat, tree, blkmem, origprob, reopt, lp, conflictset, &nbdchgs, &nredvars, &redundant) );
1806 SCIPsetDebugMsg(
set,
" -> conflict set removed %d redundant variables (old nvars %d, new nvars = %d)\n", nredvars, oldnbdchginfos, conflictset->
nbdchginfos);
1807 SCIPsetDebugMsg(
set,
" -> conflict set led to %d global bound changes %s(cdpt:%d, fdpt:%d, confdpt:%d, len:%d):\n",
1810 conflictsetPrint(conflictset);
1855 reopt, lp, branchcand, eventqueue, cliquetable,
var,
bound, boundtype,
FALSE) );
1866 for(
h = 0;
h <
set->nconflicthdlrs; ++
h )
1881 SCIPsetDebugMsg(
set,
" -> call conflict handler <%s> (prio=%d) to create conflict set with %d bounds returned result %d\n",
1907 maxsize =
MAX(maxsize,
set->conf_minmaxvars);
1941 int nconflictsetsused;
1948 int maxconflictsets;
1953 maxconflictsets = (
set->conf_maxconss == -1 ? INT_MAX :
set->conf_maxconss);
1959 assert(focusdepth <= currentdepth);
1963 SCIPsetDebugMsg(
set,
"flushing %d conflict sets at focus depth %d (maxconflictsets: %d, maxsize: %d)\n",
1964 conflict->
nconflictsets, focusdepth, maxconflictsets, maxsize);
1970 nconflictsetsused = 0;
1971 cutoffdepth = INT_MAX;
1972 repropdepth = INT_MAX;
1973 repropconflictset =
NULL;
1974 for(
i = 0;
i < conflict->
nconflictsets && nconflictsetsused < maxconflictsets; ++
i )
1990 SCIPsetDebugMsg(
set,
" -> ignoring conflict set with insertdepth %d >= cutoffdepth %d\n",
2000 SCIPsetDebugMsg(
set,
" -> empty conflict set in depth %d cuts off sub tree at depth %d\n",
2015 repropconflictset = conflictset;
2024 branchcand, eventqueue, cliquetable, conflictset, conflictset->
insertdepth, &success) );
2033 SCIPsetDebugMsg(
set,
" -> empty conflict set in depth %d cuts off sub tree at depth %d\n",
2037 reopt, lp, blkmem) );
2044 SCIPsetDebugMsg(
set,
" -> conflict set %d/%d added (cdpt:%d, fdpt:%d, insert:%d, valid:%d, conf:%d, reprop:%d, len:%d):\n",
2048 SCIPdebug(conflictsetPrint(conflictset));
2053 repropconflictset =
NULL;
2055 nconflictsetsused++;
2061 if(
set->conf_repropagate && repropdepth < cutoffdepth && repropdepth < tree->pathlen )
2063 assert(0 <= repropdepth && repropdepth < tree->pathlen);
2067 if( repropconflictset !=
NULL )
2075 branchcand, eventqueue, cliquetable, repropconflictset, repropdepth, &success) );
2084 SCIPsetDebugMsg(
set,
" -> empty reprop conflict set in depth %d cuts off sub tree at depth %d\n",
2088 origprob, reopt, lp, blkmem) );
2094 SCIPsetDebugMsg(
set,
" -> additional reprop conflict set added (cdpt:%d, fdpt:%d, insert:%d, valid:%d, conf:%d, reprop:%d, len:%d):\n",
2098 SCIPdebug(conflictsetPrint(repropconflictset));
2106 SCIPsetDebugMsg(
set,
"marked node %p in depth %d to be repropagated due to conflicts found in depth %d\n",
2107 (
void*)tree->
path[repropdepth], repropdepth, focusdepth);
2144 assert(num <= conflict->conflictsetssize);
2167 assert((*conflictset)->validdepth <= (*conflictset)->insertdepth);
2168 assert(
set->conf_allowlocal || (*conflictset)->validdepth == 0);
2174 if(
set->conf_repropagate )
2175 (*conflictset)->insertdepth =
MIN((*conflictset)->insertdepth, (*conflictset)->repropdepth);
2177 (*conflictset)->repropdepth = INT_MAX;
2178 assert((*conflictset)->insertdepth <= (*conflictset)->repropdepth);
2180 SCIPsetDebugMsg(
set,
"inserting conflict set (valid: %d, insert: %d, conf: %d, reprop: %d):\n",
2181 (*conflictset)->validdepth, (*conflictset)->insertdepth, (*conflictset)->conflictdepth, (*conflictset)->repropdepth);
2182 SCIPdebug(conflictsetPrint(*conflictset));
2231 assert(j <= conflict->nconflictsets);
2234#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2235 confgraphMarkConflictset(*conflictset);
2238 *conflictset =
NULL;
2267 if(
var->conflictlbcount == conflict->
count )
2270 if(
var->conflictlb > newbound )
2272 SCIPsetDebugMsg(
set,
"ignoring redundant bound change <%s> >= %g since a stronger lower bound exist <%s> >= %g\n",
2276 else if(
var->conflictlb == newbound )
2280 var->conflictrelaxedlb =
MAX(
var->conflictrelaxedlb, relaxedbd);
2286 var->conflictlbcount = conflict->
count;
2291 var->conflictlb = newbound;
2292 var->conflictrelaxedlb = relaxedbd;
2298 if(
var->conflictubcount == conflict->
count )
2301 if(
var->conflictub < newbound )
2303 SCIPsetDebugMsg(
set,
"ignoring redundant bound change <%s> <= %g since a stronger upper bound exist <%s> <= %g\n",
2307 else if(
var->conflictub == newbound )
2311 var->conflictrelaxedub =
MIN(
var->conflictrelaxedub, relaxedbd);
2317 var->conflictubcount = conflict->
count;
2322 var->conflictub = newbound;
2323 var->conflictrelaxedub = relaxedbd;
2351 SCIPsetDebugMsg(
set,
"putting bound change <%s> %s %g(%g) at depth %d to current conflict set\n",
2364#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2365 if( bdchginfo != confgraphcurrentbdchginfo )
2366 confgraphAddBdchg(bdchginfo);
2369#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2371 confgraphLinkBdchg(bdchginfo);
2431#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2432 confgraphAddBdchg(bdchginfo);
2435#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2437 confgraphLinkBdchg(bdchginfo);
2460 SCIPsetDebugMsg(
set,
" -> adding bound <%s> %s %.15g(%.15g) [status:%d, type:%d, depth:%d, pos:%d, reason:<%s>, info:%d] to candidates\n",
2516 int* nreconvliterals
2539 *nreconvliterals = 0;
2560 for( v = 0; v <
nvars && nbdchgs < maxsize; ++v )
2566 assert(-1 <= lbchginfoposs[v] && lbchginfoposs[v] <=
var->nlbchginfos);
2567 assert(-1 <= ubchginfoposs[v] && ubchginfoposs[v] <=
var->nubchginfos);
2569 if( lbchginfoposs[v] ==
var->nlbchginfos || ubchginfoposs[v] ==
var->nubchginfos )
2577 assert((lbchginfoposs[v] ==
var->nlbchginfos) != (ubchginfoposs[v] ==
var->nubchginfos));
2584 if( lbchginfoposs[v] ==
var->nlbchginfos )
2614 if( lbchginfoposs[v] >= 0 )
2620 if( ubchginfoposs[v] >= 0 )
2633 SCIP_CALL(
conflictAnalyze(conflict, blkmem,
set, stat, prob, tree, diving, 0,
FALSE, nconss, nliterals, \
2634 nreconvconss, nreconvliterals) );
2730 int confnbdchginfos;
2740 assert(bdchginfos !=
NULL || nbdchginfos == 0);
2743 if( nbdchginfos == 0 )
2749 if( nbdchginfos == 1 )
2751 bdchginfo = bdchginfos[0];
2776 confsortvals = conflictset->
sortvals;
2781 for(
i = 0;
i < nbdchginfos; ++
i )
2783 bdchginfo = bdchginfos[
i];
2796 assert((
int)boundtype == 0 || (
int)boundtype == 1);
2797 sortval = 2*idx + (int)boundtype;
2800 confbdchginfos[confnbdchginfos] = bdchginfo;
2802 confsortvals[confnbdchginfos] = sortval;
2816 assert(confnbdchginfos <= conflictset->nbdchginfos + nbdchginfos);
2824 SCIPsortIntPtrReal(confsortvals, (
void**)confbdchginfos, confrelaxedbds, confnbdchginfos);
2828 while(
i < confnbdchginfos )
2833 if( confsortvals[k] == confsortvals[
i] )
2840 confbdchginfos[k] = confbdchginfos[
i];
2841 confrelaxedbds[k] = confrelaxedbds[
i];
2842 confsortvals[k] = confsortvals[
i];
2847 assert(confsortvals[k] == confsortvals[
i]);
2850 confrelaxedbds[k] = (confsortvals[k] % 2 == 0) ?
MAX(confrelaxedbds[k], confrelaxedbds[
i]) :
MIN(confrelaxedbds[k], confrelaxedbds[
i]);
2863 confbdchginfos[k] = confbdchginfos[
i];
2864 confrelaxedbds[k] = confrelaxedbds[
i];
2865 confsortvals[k] = confsortvals[
i];
2876 assert(k + 1 <= confnbdchginfos);
2911 var->conflictlbcount = 0;
2917 var->conflictubcount = 0;
2921#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
2922 confgraphSetCurrentBdchg(bdchginfo);
3017 if( !
set->conf_allowlocal && validdepth > 0 )
3023 assert(focusdepth <= currentdepth);
3025 assert(0 <= validdepth && validdepth <= currentdepth);
3037 SCIPsetDebugMsg(
set,
"adding %d variables from the queue as temporary conflict variables\n", nbdchginfos);
3043 SCIPsetDebugMsg(
set,
" -> conflict with %d literals found at depth %d is active in depth %d and valid in depth %d\n",
3052 if( !
set->conf_settlelocal )
3098 int nforcedbdchgqueue;
3121 SCIPsetDebugMsg(
set,
"processing next conflicting bound (depth: %d, valid depth: %d, bdchgtype: %s [%s], vartype: %d): [<%s> %s %g(%g)]\n",
3193 SCIPsetDebugMsg(
set,
"resolving bound <%s> %s %g(%g) [status:%d, type:%d, depth:%d, pos:%d]: <%s> %s %g [cons:<%s>(%s), info:%d]\n",
3207 if( actvar != infervar )
3226 relaxedbd *= scalar;
3227 relaxedbd += constant;
3237 if( inferprop !=
NULL )
3253 SCIPsetDebugMsg(
set,
"resolving bound <%s> %s %g(%g) [status:%d, depth:%d, pos:%d]: <%s> %s %g [prop:<%s>, info:%d]\n",
3285 assert((*resolved) || (nforcedbdchgqueue == 0 && nbdchgqueue == 0));
3336 if( conflict->
count == 0 )
3337 conflict->
count = 1;
3342 assert(0.0 <
set->conf_scorefac &&
set->conf_scorefac <= 1.0);
3351 for( v = 0; v < prob->
nvars; ++v )
3362#if defined(SCIP_CONFGRAPH) || defined(SCIP_CONFGRAPH_DOT)
3398 (*bound) -= constant;
3436 int* nreconvliterals
3456 assert(focusdepth <= currentdepth);
3461 maxvaliddepth = (
set->conf_allowlocal ?
MIN(currentdepth-1, focusdepth) : 0);
3462 if( validdepth > maxvaliddepth )
3484 SCIPsetDebugMsg(
set,
"creating reconvergence constraint for UIP <%s> %s %g in depth %d pos %d\n",
3521 while( bdchginfo !=
NULL && validdepth <= maxvaliddepth )
3544 assert(bdchgdepth <= firstuipdepth);
3549 if( bdchgdepth > validdepth && bdchginfo != nextbdchginfo )
3565 if( bdchginfo == uip
3566 || (bdchgdepth == firstuipdepth
3567 && nextbdchginfo !=
NULL
3576 else if( forceresolve )
3581 assert(bdchgdepth >= validdepth);
3582 validdepth = bdchgdepth;
3584 SCIPsetDebugMsg(
set,
"couldn't resolve forced bound change on <%s> -> new valid depth: %d\n",
3587 else if( bdchginfo != uip )
3598 nextuip = bdchginfo;
3620 if( nextuip !=
NULL && nresolutions >= 2 && bdchginfo ==
NULL && validdepth <= maxvaliddepth )
3632 SCIPsetDebugMsg(
set,
"creating reconvergence constraint from UIP <%s> to UIP <%s> in depth %d with %d literals after %d resolutions\n",
3641 (*nreconvliterals) += nlits;
3674 int* nreconvliterals
3686 int lastconsnresolutions;
3687 int lastconsresoldepth;
3703 assert(focusdepth <= currentdepth);
3705 resolvedepth = ((
set->conf_fuiplevels >= 0 &&
set->conf_fuiplevels <= currentdepth)
3706 ? currentdepth -
set->conf_fuiplevels + 1 : 0);
3707 assert(0 <= resolvedepth && resolvedepth <= currentdepth + 1);
3711 resolvedepth =
MIN(resolvedepth, currentdepth);
3713 SCIPsetDebugMsg(
set,
"analyzing conflict with %d+%d conflict candidates and starting conflict set of size %d in depth %d (resolvedepth=%d)\n",
3720 *nreconvliterals = 0;
3725 maxvaliddepth = (
set->conf_allowlocal ?
MIN(currentdepth-1, focusdepth) : 0);
3726 if( validdepth > maxvaliddepth )
3736 lastconsnresolutions = (mustresolve ? 0 : -1);
3737 lastconsresoldepth = (mustresolve ? currentdepth : INT_MAX);
3746 while( bdchginfo !=
NULL && validdepth <= maxvaliddepth )
3760 assert(0 <= bdchgdepth && bdchgdepth <= currentdepth);
3762 assert(bdchgdepth < tree->pathlen);
3777 assert(nresolutions >= lastconsnresolutions);
3780 if( nresolutions == lastconsnresolutions )
3781 lastconsresoldepth = bdchgdepth;
3782 else if( bdchgdepth < lastconsresoldepth && (
set->conf_interconss == -1 || *nconss < set->conf_interconss) )
3788 SCIPsetDebugMsg(
set,
"creating intermediate conflictset after %d resolutions up to depth %d (valid at depth %d): %d conflict bounds, %d bounds in queue\n",
3793 lastconsnresolutions = nresolutions;
3794 lastconsresoldepth = bdchgdepth;
3798 (*nliterals) += nlits;
3824 if( bdchgdepth > validdepth && bdchginfo != nextbdchginfo )
3841 if( (mustresolve && nresolutions == 0)
3842 || (bdchgdepth >= resolvedepth
3843 && nextbdchginfo !=
NULL
3852 else if( forceresolve )
3857 assert(bdchgdepth >= validdepth);
3858 validdepth = bdchgdepth;
3860 SCIPsetDebugMsg(
set,
"couldn't resolve forced bound change on <%s> -> new valid depth: %d\n",
3870 assert(nfirstuips < 2*(currentdepth+1));
3871 firstuips[nfirstuips] = bdchginfo;
3893 if( bdchginfo ==
NULL
3894 && nresolutions > lastconsnresolutions
3895 && validdepth <= maxvaliddepth
3907 (*nliterals) += nlits;
3912 if(
set->conf_reconvlevels != 0 && validdepth <= maxvaliddepth )
3917 reconvlevels = (
set->conf_reconvlevels == -1 ? INT_MAX :
set->conf_reconvlevels);
3918 for(
i = 0;
i < nfirstuips; ++
i )
3924 validdepth, firstuips[
i], nreconvconss, nreconvliterals) );
3960 score =
set->conf_proofscorefac * (1.0 - proofactdelta/(prooflhs - proofact));
3961 score =
MAX(score, 0.0);
3969 if( proofcoef > 0.0 )
3972 score +=
set->conf_uplockscorefac
3980 score +=
set->conf_downlockscorefac
4004 if( num > *candssize )
4013 *candssize = newsize;
4015 assert(num <= *candssize);
4034 assert(-1 <= *lbchginfopos && *lbchginfopos <= var->nlbchginfos);
4035 assert(-1 <= *ubchginfopos && *ubchginfopos <= var->nubchginfos);
4036 assert(*lbchginfopos == -1 || *lbchginfopos ==
var->nlbchginfos
4037 ||
var->lbchginfos[*lbchginfopos].redundant
4038 == (
var->lbchginfos[*lbchginfopos].oldbound ==
var->lbchginfos[*lbchginfopos].newbound));
4039 assert(*ubchginfopos == -1 || *ubchginfopos ==
var->nubchginfos
4040 ||
var->ubchginfos[*ubchginfopos].redundant
4041 == (
var->ubchginfos[*ubchginfopos].oldbound ==
var->ubchginfos[*ubchginfopos].newbound));
4043 if( *lbchginfopos >= 0 && *lbchginfopos < var->nlbchginfos &&
var->lbchginfos[*lbchginfopos].redundant )
4048 if( *ubchginfopos >= 0 && *ubchginfopos < var->nubchginfos &&
var->ubchginfos[*ubchginfopos].redundant )
4106 if( bdchginfo ==
NULL )
4162 if( bdchginfo ==
NULL )
4169 nbdchgs = (int) bdchginfo->
pos;
4175 if(
set->conf_ignorerelaxedbd )
4190 relaxedbd =
MIN(relaxedbd, newbound);
4198 while( nbdchgs > 0 )
4210 SCIPsetDebugMsg(
set,
"lower bound change %d oldbd=%.15g, newbd=%.15g, depth=%d, pos=%d, redundant=%u\n",
4236 relaxedbd =
MAX(relaxedbd, newbound);
4244 while( nbdchgs > 0 )
4256 SCIPsetDebugMsg(
set,
"upper bound change %d oldbd=%.15g, newbd=%.15g, depth=%d, pos=%d, redundant=%u\n",
4308 if(
var->conflictlbcount == conflict->
count &&
var->conflictlb >= newbound )
4320 if(
var->conflictubcount == conflict->
count &&
var->conflictub <= newbound )
4386 idx = relaxedlpbdchgs->
nbdchgs;
4455 assert(-1 <= lbchginfopos && lbchginfopos <= var->nlbchginfos);
4456 assert(-1 <= ubchginfopos && ubchginfopos <= var->nubchginfos);
4465 assert(*ncands <= *candssize);
4466 assert(0 <= firstcand && firstcand <= *ncands);
4469 if( proofcoef > 0.0 )
4471 assert(ubchginfopos >= 0);
4474 if( ubchginfopos ==
var->nubchginfos )
4479 depth = currentdepth+1;
4486 depth =
var->ubchginfos[ubchginfopos].bdchgidx.depth;
4487 oldbound =
var->ubchginfos[ubchginfopos].newbound;
4488 newbound =
var->ubchginfos[ubchginfopos].oldbound;
4493 assert(lbchginfopos >= 0);
4496 if( lbchginfopos ==
var->nlbchginfos )
4501 depth = currentdepth+1;
4508 depth =
var->lbchginfos[lbchginfopos].bdchgidx.depth;
4509 oldbound =
var->lbchginfos[lbchginfopos].newbound;
4510 newbound =
var->lbchginfos[lbchginfopos].oldbound;
4536 SCIPsetDebugMsg(
set,
" -> local <%s> %s %g, relax <%s> %s %g, proofcoef=%g, dpt=%d, resolve=%u, delta=%g, score=%g\n",
4542 for(
i = *ncands;
i > firstcand && score > (*candscores)[
i-1]; --
i )
4544 (*cands)[
i] = (*cands)[
i-1];
4545 (*candscores)[
i] = (*candscores)[
i-1];
4546 (*newbounds)[
i] = (*newbounds)[
i-1];
4547 (*proofactdeltas)[
i] = (*proofactdeltas)[
i-1];
4550 (*candscores)[
i] = score;
4551 (*newbounds)[
i] = newbound;
4595 if( resolve !=
NULL )
4611 for( v = 0; v <
nvars; ++v )
4625 if( (lbchginfoposs[v] == -1 && ubchginfoposs[v] == -1) )
4627 proofcoefs[v] = 0.0;
4636 if( lbchginfoposs[v] >= 0 )
4638 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g\n",
4640 proofcoefs[v], prooflhs, (*proofact));
4642 lbchginfoposs[v] = -1;
4649 if( ubchginfoposs[v] >= 0 )
4651 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g\n",
4653 proofcoefs[v], prooflhs, (*proofact));
4655 ubchginfoposs[v] = -1;
4659 if( relaxed && oldlpbdchgs !=
NULL )
4665 if( lbchginfoposs[v] >= 0 || ubchginfoposs[v] >= 0 )
4668 prooflhs, (*proofact), &cands, &candscores, &newbounds, &proofactdeltas, &candssize, &ncands, 0) );
4672 proofcoefs[v] = 0.0;
4679 for(
i = 0;
i < ncands; ++
i )
4681 assert(proofactdeltas[
i] > 0.0);
4692 assert((lbchginfoposs[v] >= 0) != (ubchginfoposs[v] >= 0));
4694 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g + %g\n",
4696 proofcoefs[v] > 0.0 ? curvarlbs[v] : newbounds[
i],
4697 proofcoefs[v] > 0.0 ? newbounds[
i] : curvarubs[v],
4698 proofcoefs[v], prooflhs, (*proofact), proofactdeltas[
i]);
4721 if( proofcoefs[v] > 0.0 )
4723 assert(ubchginfoposs[v] >= 0);
4724 assert(lbchginfoposs[v] == -1);
4725 curvarubs[v] = newbounds[
i];
4730 assert(lbchginfoposs[v] >= 0);
4731 assert(ubchginfoposs[v] == -1);
4732 curvarlbs[v] = newbounds[
i];
4735 if( oldlpbdchgs !=
NULL )
4737 SCIP_CALL(
addBdchg(
set, cands[
i], curvarlbs[v], curvarubs[v], oldlpbdchgs, relaxedlpbdchgs, lpi) );
4739 (*proofact) += proofactdeltas[
i];
4750 if( lbchginfoposs[v] >= 0 || ubchginfoposs[v] >= 0 )
4752 SCIP_CALL(
addCand(
set, currentdepth, cands[
i], lbchginfoposs[v], ubchginfoposs[v], proofcoefs[v],
4753 prooflhs, (*proofact), &cands, &candscores, &newbounds, &proofactdeltas, &candssize, &ncands,
i+1) );
4756 proofcoefs[v] = 0.0;
4814 curvarlbs, curvarubs, lbchginfoposs, ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, resolve, lpi) );
4847 (*lpbdchgs)->nbdchgs = 0;
4877 if( num > *sidechgssize )
4887 *sidechgssize = newsize;
4889 assert(num <= *sidechgssize);
4930 sidechgssize, (*nsidechgs)+1) );
4931 assert(*nsidechgs < *sidechgssize);
4942 (*sidechgoldlhss)[*nsidechgs] = -lpiinfinity;
4943 (*sidechgnewlhss)[*nsidechgs] = -lpiinfinity;
4947 (*sidechgoldlhss)[*nsidechgs] = lhs - constant;
4948 (*sidechgnewlhss)[*nsidechgs] = -lpiinfinity;
4952 (*sidechgoldrhss)[*nsidechgs] = lpiinfinity;
4953 (*sidechgnewrhss)[*nsidechgs] = lpiinfinity;
4957 (*sidechgoldrhss)[*nsidechgs] = rhs - constant;
4958 (*sidechgnewrhss)[*nsidechgs] = lpiinfinity;
5048 lbchginfoposs, ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, resolve, lpi) );
5118 ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs,
valid, &resolve, proofcoefs, *prooflhs, proofactivity) );
5124 oldlpbdchgs, relaxedlpbdchgs,
valid, &resolve, proofcoefs, *prooflhs, proofactivity) );
5130 solvelp = (
set->conf_maxlploops != 0 &&
set->conf_lpiterations != 0);
5132 if( (*
valid) && resolve && solvelp )
5155 maxlploops = (
set->conf_maxlploops >= 0 ?
set->conf_maxlploops : INT_MAX);
5156 lpiterations = (
set->conf_lpiterations >= 0 ?
set->conf_lpiterations : INT_MAX);
5171 sidechgssize = nrows;
5178 for(
r = 0;
r < nrows; ++
r )
5187 &sidechgnewlhss, &sidechgnewrhss, &sidechgssize, &nsidechgs) );
5201 globalinfeasible =
FALSE;
5202 while( (*
valid) && resolve && nloops < maxlploops )
5206 assert(!globalinfeasible);
5211 SCIPsetDebugMsg(
set,
"infeasible LP conflict analysis loop %d (changed col bounds: %d)\n", nloops, relaxedlpbdchgs->
nbdchgs);
5215 if( relaxedlpbdchgs->
nbdchgs > 0 )
5244 (*iterations) += iter;
5283 curvarlbs, curvarubs,
valid) );
5293 if(
set->conf_useinflp ==
'd' ||
set->conf_useinflp ==
'b' )
5301 farkasrow, validdepth, curvarlbs, curvarubs,
FALSE, &globalinfeasible, dualproofsuccess) );
5315 (*proofactivity) = -(*proofactivity);
5320 for( v = 0; v < nnz; v++ )
5333 ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs,
valid, &resolve, proofcoefs, (*prooflhs), proofactivity) );
5352 curvarlbs, curvarubs,
valid) );
5364 (*proofactivity) = -(*proofactivity);
5369 for( v = 0; v < nnz; v++ )
5382 ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs,
valid, &resolve, proofcoefs, *prooflhs, proofactivity) );
5387 SCIPsetDebugMsg(
set,
" -> finished infeasible LP conflict analysis loop %d (iter: %d, nbdchgs: %d)\n",
5388 nloops, iter, relaxedlpbdchgs->
nbdchgs);
5391 SCIPsetDebugMsg(
set,
"finished undoing bound changes after %d loops (valid=%u, nbdchgs: %d)\n",
5396 if( oldlpbdchgs->
nbdchgs > 0 )
5408 if( oldlpbdchgs->
nbdchgs > 0 || nsidechgs > 0 )
5413 if ( marklpunsolved )
5462 int nreconvliterals;
5469 if( success !=
NULL )
5489 SCIP_CALL(
conflictAnalyze(conflict, blkmem,
set, stat, prob, tree,
FALSE, validdepth,
TRUE, &nconss, &nliterals, \
5490 &nreconvconss, &nreconvliterals) );
5496 if( success !=
NULL )
5497 *success = (nconss > 0);
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
void SCIPclockReset(SCIP_CLOCK *clck)
void SCIPclockFree(SCIP_CLOCK **clck)
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
internal methods for clocks and timing issues
internal methods for conflict analysis
SCIP_RETCODE SCIPconflictAnalyzeDualProof(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_AGGRROW *proofrow, int validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool initialproof, SCIP_Bool *globalinfeasible, SCIP_Bool *success)
internal methods for dual proof conflict analysis
SCIP_RETCODE SCIPgetFarkasProof(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
SCIP_RETCODE SCIPgetDualProof(SCIP_SET *set, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
void SCIPconflictsetFree(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
static SCIP_Bool conflictsetIsRedundant(SCIP_CONFLICTSET *conflictset1, SCIP_CONFLICTSET *conflictset2)
static SCIP_RETCODE detectImpliedBounds(SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CONFLICTSET *conflictset, int *nbdchgs, int *nredvars, SCIP_Bool *redundant)
SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
static SCIP_RETCODE ensureSidechgsSize(SCIP_SET *set, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int num)
static SCIP_RETCODE conflictQueueBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
static SCIP_RETCODE undoBdchgsDualsol(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *dualcoefs, SCIP_Real duallhs, SCIP_Real *dualactivity)
static void conflictClear(SCIP_CONFLICT *conflict)
void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)
SCIP_RETCODE conflictCreateTmpBdchginfo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BDCHGINFO **bdchginfo)
SCIP_RETCODE SCIPconflictAnalyzeRemainingBdchgs(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int *lbchginfoposs, int *ubchginfoposs, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)
static SCIP_RETCODE conflictEnsureTmpbdchginfosMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)
static SCIP_Bool isBoundchgUseless(SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPconflicthdlrCreate(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
void SCIPconflicthdlrSetExitsol(SCIP_CONFLICTHDLR *conflicthdlr,)
static void conflictsetCalcConflictDepth(SCIP_CONFLICTSET *conflictset)
SCIP_RETCODE SCIPconflicthdlrExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
void SCIPconflicthdlrSetFree(SCIP_CONFLICTHDLR *conflicthdlr,)
static SCIP_Bool bdchginfoIsInvalid(SCIP_CONFLICT *conflict, SCIP_BDCHGINFO *bdchginfo)
static SCIP_Real calcBdchgScore(SCIP_Real prooflhs, SCIP_Real proofact, SCIP_Real proofactdelta, SCIP_Real proofcoef, int depth, int currentdepth, SCIP_VAR *var, SCIP_SET *set)
int conflictCalcMaxsize(SCIP_SET *set, SCIP_PROB *prob)
void SCIPconflicthdlrSetPriority(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, int priority)
SCIP_RETCODE SCIPconflictAddBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)
static SCIP_RETCODE conflictAddConflictCons(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_CONFLICTSET *conflictset, int insertdepth, SCIP_Bool *success)
SCIP_RETCODE SCIPconflicthdlrFree(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)
SCIP_RETCODE SCIPconflictAnalyze(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, int validdepth, SCIP_Bool *success)
static SCIP_RETCODE undoBdchgsDualfarkas(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *farkascoefs, SCIP_Real farkaslhs, SCIP_Real *farkasactivity)
void SCIPconflicthdlrSetCopy(SCIP_CONFLICTHDLR *conflicthdlr,)
static SCIP_RETCODE addCand(SCIP_SET *set, int currentdepth, SCIP_VAR *var, int lbchginfopos, int ubchginfopos, SCIP_Real proofcoef, SCIP_Real prooflhs, SCIP_Real proofact, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int *ncands, int firstcand)
static SCIP_RETCODE addBdchg(SCIP_SET *set, SCIP_VAR *var, SCIP_Real newlb, SCIP_Real newub, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_LPI *lpi)
static SCIP_RETCODE conflictCreateReconvergenceConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_BDCHGINFO *firstuip, int *nreconvconss, int *nreconvliterals)
SCIP_RETCODE SCIPconflicthdlrExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_Bool SCIPconflictApplicable(SCIP_SET *set)
SCIP_RETCODE SCIPrunBoundHeuristic(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_Real *proofcoefs, SCIP_Real *prooflhs, SCIP_Real *proofactivity, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, int *iterations, SCIP_Bool marklpunsolved, SCIP_Bool *dualproofsuccess, SCIP_Bool *valid)
static SCIP_RETCODE conflictResolveBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd, int validdepth, SCIP_Bool *resolved)
static void conflictsetClear(SCIP_CONFLICTSET *conflictset)
SCIP_RETCODE SCIPconflictAddRelaxedBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)
static SCIP_Real conflictsetCalcScore(SCIP_CONFLICTSET *conflictset, SCIP_SET *set)
static SCIP_RETCODE conflictAddConflictBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
static SCIP_RETCODE lpbdchgsCreate(SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set, int ncols)
static SCIP_RETCODE doConflicthdlrCreate(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
static SCIP_RETCODE conflictsetCopy(SCIP_CONFLICTSET **targetconflictset, BMS_BLKMEM *blkmem, SCIP_CONFLICTSET *sourceconflictset, int nadditionalelems)
static SCIP_RETCODE conflictsetAddBound(SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
static SCIP_Bool conflictMarkBoundCheckPresence(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
SCIP_RETCODE SCIPconflicthdlrCopyInclude(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
SCIP_RETCODE SCIPundoBdchgsProof(SCIP_SET *set, SCIP_PROB *prob, int currentdepth, SCIP_Real *proofcoefs, SCIP_Real prooflhs, SCIP_Real *proofact, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *resolve, SCIP_LPI *lpi)
void SCIPconflicthdlrSetExit(SCIP_CONFLICTHDLR *conflicthdlr,)
static SCIP_RETCODE conflictsetAddBounds(SCIP_CONFLICT *conflict, SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO **bdchginfos, int nbdchginfos)
static SCIP_RETCODE addSideRemoval(SCIP_SET *set, SCIP_ROW *row, SCIP_Real lpiinfinity, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int *nsidechgs)
static SCIP_RETCODE convertToActiveVar(SCIP_VAR **var, SCIP_SET *set, SCIP_BOUNDTYPE *boundtype, SCIP_Real *bound)
static SCIP_RETCODE incVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BOUNDTYPE boundtype, SCIP_Real value, SCIP_Real weight)
static SCIP_Bool bdchginfoIsResolvable(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE conflictAnalyze(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_Bool mustresolve, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)
static SCIP_Bool checkRedundancy(SCIP_SET *set, SCIP_CONFLICTSET *conflictset)
static void lpbdchgsReset(SCIP_LPBDCHGS *lpbdchgs, int ncols)
SCIP_RETCODE SCIPconflictIsVarUsed(SCIP_CONFLICT *conflict, SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
static SCIP_RETCODE conflictAddBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
SCIP_RETCODE SCIPconflictsetCreate(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
static SCIP_RETCODE conflictsetCalcInsertDepth(SCIP_CONFLICTSET *conflictset, SCIP_SET *set, SCIP_TREE *tree)
static SCIP_BDCHGINFO * conflictRemoveCand(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictsetEnsureBdchginfosMem(SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
static SCIP_BDCHGINFO * conflictFirstCand(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictInit(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound)
static SCIP_RETCODE ensureCandsSize(SCIP_SET *set, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int num)
SCIP_RETCODE SCIPconflicthdlrExec(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, SCIP_NODE *node, SCIP_NODE *validnode, SCIP_BDCHGINFO **bdchginfos, SCIP_Real *relaxedbds, int nbdchginfos, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound, SCIP_Bool resolved, SCIP_RESULT *result)
void SCIPconflicthdlrSetInit(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
static void skipRedundantBdchginfos(SCIP_VAR *var, int *lbchginfopos, int *ubchginfopos)
static SCIP_RETCODE conflictInsertConflictset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONFLICTSET **conflictset)
static SCIP_RETCODE conflictEnsureConflictsetsMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)
static void lpbdchgsFree(SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set)
SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
static SCIP_RETCODE conflictAddConflictset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int validdepth, SCIP_Bool diving, SCIP_Bool repropagate, SCIP_Bool *success, int *nliterals)
static void conflictFreeTmpBdchginfos(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem)
static SCIP_RETCODE updateStatistics(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONFLICTSET *conflictset, int insertdepth)
void SCIPconflicthdlrSetInitsol(SCIP_CONFLICTHDLR *conflicthdlr,)
methods and datastructures for conflict analysis
SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
internal methods for constraints and constraint handlers
Constraint handler for linear constraints in their most general form, .
methods for the aggregation rows
#define SCIPquadprecProdQD(r, a, b)
#define SCIPquadprecSumDD(r, a, b)
#define SCIPdebugCheckConflict(blkmem, set, node, bdchginfos, relaxedbds, nliterals)
#define SCIPdebugCheckConflictFrontier(blkmem, set, node, bdchginfo, bdchginfos, relaxedbds, nliterals, bdchgqueue, forcedbdchgqueue)
#define SCIP_LONGINT_FORMAT
#define SCIP_CALL_FINALLY(x, y)
void SCIPdotWriteOpening(FILE *file)
void SCIPdotWriteClosing(FILE *file)
void SCIPdotWriteArc(FILE *file, int source, int target, const char *color)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPgmlWriteClosing(FILE *file)
void SCIPdotWriteNode(FILE *file, int node, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void SCIPgmlWriteEdge(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)
void SCIPpqueueClear(SCIP_PQUEUE *pqueue)
SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)
void * SCIPpqueueFirst(SCIP_PQUEUE *pqueue)
int SCIPcolGetLPPos(SCIP_COL *col)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)
SCIP_CONFLICTHDLRDATA * SCIPconflicthdlrGetData(SCIP_CONFLICTHDLR *conflicthdlr)
int SCIPconflicthdlrGetPriority(SCIP_CONFLICTHDLR *conflicthdlr)
const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)
void SCIPconflicthdlrSetData(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_CONFLICTHDLRDATA *conflicthdlrdata)
SCIP_Bool SCIPconflicthdlrIsInitialized(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_Real SCIPconflicthdlrGetTime(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_Real SCIPconflicthdlrGetSetupTime(SCIP_CONFLICTHDLR *conflicthdlr)
const char * SCIPconflicthdlrGetDesc(SCIP_CONFLICTHDLR *conflicthdlr)
SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
int SCIPnodeGetDepth(SCIP_NODE *node)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(SCIP *scip, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_Bool *boundtypes, SCIP_Bool *redundants, int nvars, int *nredvars, int *nglobalred, SCIP_Bool *setredundant, SCIP_Bool *glbinfeas, SCIP_Bool fullshortening)
SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
void SCIPsortedvecInsertIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int len)
void SCIPsortLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)
void SCIPsortedvecDelPosIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int pos, int *len)
int SCIPsnprintf(char *t, int len, const char *s,...)
assert(minobj< SCIPgetCutoffbound(scip))
void SCIPhistoryIncNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real length)
void SCIPhistoryScaleVSIDS(SCIP_HISTORY *history, SCIP_Real scalar)
void SCIPhistoryIncVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
internal methods for branching and inference history
SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
static const SCIP_Real scalars[]
int SCIPlpGetNRows(SCIP_LP *lp)
internal methods for LP management
interface methods for specific LP solvers
static const char * paramname[]
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSclearMemory(ptr)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)
int SCIPparamGetInt(SCIP_PARAM *param)
methods commonly used for presolving
const char * SCIPprobGetName(SCIP_PROB *prob)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
internal methods for storing and manipulating the main problem
SCIP_RETCODE SCIPpropResolvePropagation(SCIP_PROP *prop, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
internal methods for propagators
public methods for conflict analysis handlers
public methods for managing constraints
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for handling parameter settings
public methods for propagators
public methods for branch and bound tree
public methods for problem variables
public methods for conflict handler plugins and conflict analysis
public methods for constraint handler plugins and constraints
public methods for memory management
public methods for message handling
public methods for solutions
public methods for SCIP variables
SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPsetIsGE(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_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
void SCIPsetSortConflicthdlrs(SCIP_SET *set)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetFreeCleanBufferArray(set, ptr)
#define SCIPsetDebugMsgPrint
#define SCIPsetAllocBufferArray(set, ptr, num)
#define SCIPsetFreeBuffer(set, ptr)
#define SCIPsetAllocCleanBufferArray(set, ptr, num)
#define SCIPsetAllocBuffer(set, ptr)
#define SCIPsetReallocBufferArray(set, ptr, num)
internal methods for storing primal CIP solutions
unsigned int hasrelaxonlyvar
SCIP_BDCHGINFO ** bdchginfos
SCIP_CONFTYPE conflicttype
unsigned int usescutoffbound
SCIP_Real * conflictsetscores
SCIP_Longint nappliedglbconss
SCIP_Longint npropconfconss
SCIP_CLOCK * propanalyzetime
SCIP_PQUEUE * forcedbdchgqueue
SCIP_Longint nappliedglbliterals
SCIP_CONFLICTSET ** conflictsets
SCIP_Longint npropsuccess
SCIP_Longint nappliedlocconss
SCIP_Longint npropreconvliterals
SCIP_BDCHGINFO ** tmpbdchginfos
SCIP_Longint npropconfliterals
SCIP_CONFLICTSET * conflictset
SCIP_Longint nappliedlocliterals
SCIP_Longint npropreconvconss
SCIP_CONFLICTHDLRDATA * conflicthdlrdata
SCIP_CLOCK * conflicttime
SCIP_BOUNDCHG * boundchgs
SCIP_Bool strongbranching
SCIP_Longint nconflictlps
SCIP_HISTORY * glbhistory
SCIP_Longint lastconflictnode
SCIP_HISTORY * glbhistorycrun
SCIP_Longint nconflictlpiterations
SCIP_CLOCK * conflictlptime
datastructures for conflict analysis
data structures for LP management
datastructures for storing and manipulating the main problem
datastructures for global SCIP settings
datastructures for problem statistics
data structures for branch and bound tree
datastructures for problem variables
SCIP_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)
int SCIPtreeGetFocusDepth(SCIP_TREE *tree)
void SCIPnodePropagateAgain(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree)
SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)
int SCIPtreeGetEffectiveRootDepth(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)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
internal methods for branch and bound tree
struct SCIP_BranchCand SCIP_BRANCHCAND
struct SCIP_Conflicthdlr SCIP_CONFLICTHDLR
#define SCIP_DECL_CONFLICTEXIT(x)
#define SCIP_DECL_CONFLICTCOPY(x)
struct SCIP_ConflictSet SCIP_CONFLICTSET
struct SCIP_Conflict SCIP_CONFLICT
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTINITSOL(x)
#define SCIP_DECL_CONFLICTFREE(x)
struct SCIP_LPBdChgs SCIP_LPBDCHGS
@ SCIP_CONFTYPE_BNDEXCEEDING
@ SCIP_CONFTYPE_PROPAGATION
#define SCIP_DECL_CONFLICTINIT(x)
enum SCIP_ConflictType SCIP_CONFTYPE
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONFLICTEXITSOL(x)
struct SCIP_Cons SCIP_CONS
struct SCIP_AggrRow SCIP_AGGRROW
struct SCIP_EventQueue SCIP_EVENTQUEUE
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BranchDir SCIP_BRANCHDIR
struct SCIP_CliqueTable SCIP_CLIQUETABLE
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_NOTSOLVED
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
#define SCIP_DECL_SORTPTRCOMP(x)
struct SCIP_ParamData SCIP_PARAMDATA
#define SCIP_DECL_PARAMCHGD(x)
struct SCIP_Prob SCIP_PROB
struct SCIP_Prop SCIP_PROP
struct SCIP_Reopt SCIP_REOPT
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_Stat SCIP_STAT
struct SCIP_Node SCIP_NODE
struct SCIP_Tree SCIP_TREE
struct SCIP_BdChgIdx SCIP_BDCHGIDX
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_PROPINFER
@ SCIP_BOUNDCHGTYPE_BRANCHING
@ SCIP_BOUNDCHGTYPE_CONSINFER
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
struct SCIP_BdChgInfo SCIP_BDCHGINFO
SCIP_DOMCHGBOUND domchgbound
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
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_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
internal methods for problem variables
void SCIPvisualFoundConflict(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)
methods for creating output for visualization tools (VBC, BAK)