165#if defined(_WIN32) || defined(_WIN64)
172#define BOUNDSWITCH 0.51
173#define POSTPROCESS FALSE
175#define ALLOWLOCAL FALSE
198 const char* nodetype,
218#ifndef SCIP_CONFGRAPH_EDGE
281 const char* colors[] = {
439 (*conflicthdlr)->priority = priority;
447 (*conflicthdlr)->conflicthdlrdata = conflicthdlrdata;
448 (*conflicthdlr)->initialized =
FALSE;
502 assert(!(*conflicthdlr)->initialized);
506 if( (*conflicthdlr)->conflictfree !=
NULL )
536 if(
set->misc_resetstat )
644 SCIP_Real* relaxedbds,
647 SCIP_Bool usescutoffbound,
654 assert(bdchginfos !=
NULL || nbdchginfos == 0);
675 SCIPerrorMessage(
"execution method of conflict handler <%s> returned invalid result <%d>\n",
879 (*lpbdchgs)->nbdchgs = 0;
954 (*proofset)->vals =
NULL;
955 (*proofset)->inds =
NULL;
956 (*proofset)->rhs = 0.0;
957 (*proofset)->nnz = 0;
958 (*proofset)->size = 0;
959 (*proofset)->validdepth = 0;
1014 for(
i = 0;
i < proofset->
nnz;
i++ )
1028 return proofset->
inds;
1039 return proofset->
vals;
1050 return proofset->
rhs;
1061 return proofset->
nnz;
1089 if( proofset->
size == 0 )
1097 proofset->
size = nnz;
1106 if( proofset->
size < nnz )
1110 proofset->
size = nnz;
1113 for(
i = 0;
i < nnz;
i++ )
1115 proofset->
vals[
i] = vals[
i];
1116 proofset->
inds[
i] = inds[
i];
1120 proofset->
rhs = rhs;
1121 proofset->
nnz = nnz;
1151 for(
i = 0;
i < nnz;
i++ )
1185 if( proofset->
vals[pos] > 0.0 )
1198 proofset->
vals[pos] = proofset->
vals[proofset->
nnz];
1199 proofset->
inds[pos] = proofset->
inds[proofset->
nnz];
1200 proofset->
vals[proofset->
nnz] = 0.0;
1201 proofset->
inds[proofset->
nnz] = 0;
1252 var, boundtype, oldbound, newbound) );
1304 (*conflictset)->bdchginfos =
NULL;
1305 (*conflictset)->relaxedbds =
NULL;
1306 (*conflictset)->sortvals =
NULL;
1307 (*conflictset)->bdchginfossize = 0;
1333 (*targetconflictset)->bdchginfossize =
targetsize;
1428 score =
MAX(score, 0.0);
1439 score +=
set->conf_uplockscorefac
1447 score +=
set->conf_downlockscorefac
1542 SCIP_Real* relaxedbds;
1564 assert((
int)boundtype == 0 || (
int)boundtype == 1);
1565 sortval = 2*idx + (int)boundtype;
1577 if( pos > 0 &&
sortval == sortvals[pos-1] )
1629 assert(bdchginfos !=
NULL || nbdchginfos == 0);
1632 if( nbdchginfos == 0 )
1638 if( nbdchginfos == 1 )
1670 for(
i = 0;
i < nbdchginfos; ++
i )
1685 assert((
int)boundtype == 0 || (
int)boundtype == 1);
1686 sortval = 2*idx + (int)boundtype;
2013 assert((*conflictset)->validdepth <= (*conflictset)->insertdepth);
2014 assert(
set->conf_allowlocal || (*conflictset)->validdepth == 0);
2020 if(
set->conf_repropagate )
2021 (*conflictset)->insertdepth =
MIN((*conflictset)->insertdepth, (*conflictset)->repropdepth);
2023 (*conflictset)->repropdepth =
INT_MAX;
2024 assert((*conflictset)->insertdepth <= (*conflictset)->repropdepth);
2026 SCIPsetDebugMsg(
set,
"inserting conflict set (valid: %d, insert: %d, conf: %d, reprop: %d):\n",
2027 (*conflictset)->validdepth, (*conflictset)->insertdepth, (*conflictset)->conflictdepth, (*conflictset)->repropdepth);
2080#ifdef SCIP_CONFGRAPH
2084 *conflictset =
NULL;
2149 if( insertdepth > 0 )
2201 SCIP_Real* relaxedbds;
2214 for( v = conflictset->
nbdchginfos - 1; v >= 0; --v )
2224 bound = relaxedbds[v];
2271 SCIP_Bool* redundant
2275 SCIP_Real* relaxedbds;
2277 SCIP_Bool* boundtypes;
2324 for( v = nbdchginfos - 1; v >= 0; --v )
2327 bound = relaxedbds[v];
2340 bdchginfos[v] = bdchginfos[nbdchginfos - 1];
2341 relaxedbds[v] = relaxedbds[nbdchginfos - 1];
2342 sortvals[v] = sortvals[nbdchginfos - 1];
2373 for( v = 0; v < nbdchginfos; ++v )
2377 bounds[v] = relaxedbds[v];
2388 if( !boundtypes[v] )
2405 bounds[v] += ((!boundtypes[v]) ? +1.0 : -1.0);
2426 if( v == nbdchginfos && ((!
set->conf_fullshortenconflict &&
nzeroimpls < 2) || (
set->conf_fullshortenconflict &&
nzeroimpls < nbdchginfos)) )
2437 for( v = 0; v < nbdchginfos; ++v )
2440 if( v < nbdchginfos - 1 )
2449 for( v = 0; v < nbdchginfos; ++v )
2453 nbdchgs, redundant, &
glbinfeas,
set->conf_fullshortenconflict) );
2457 SCIPsetDebugMsg(
set,
"conflict set (%p) led to global infeasibility\n", (
void*) conflictset);
2469 SCIPsetDebugMsg(
set,
"conflict set (%p) led to %d global bound reductions\n", (
void*) conflictset, *nbdchgs);
2476 SCIPsetDebugMsg(
set,
"conflict set (%p) is redundant because at least one global reduction, fulfills the conflict constraint\n", (
void*)conflictset);
2487 for( v = nbdchginfos - 1; v >= 0; --v )
2494 bdchginfos[v] = bdchginfos[nbdchginfos - 1];
2495 relaxedbds[v] = relaxedbds[nbdchginfos - 1];
2496 sortvals[v] = sortvals[nbdchginfos - 1];
2507 conflictset->nbdchginfos = nbdchginfos;
2588 SCIPsetDebugMsg(
set,
"detected global infeasibility at var <%s>: locdom=[%g,%g] glbdom=[%g,%g] new %s bound=%g\n",
2646 SCIP_CALL(
SCIPnodeAddBoundchg(tree->
path[0], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, \
2647 eventqueue, cliquetable,
var, newbound, boundtype,
FALSE) );
2713 for(
i = 0;
i < nnz;
i++ )
2716 SCIP_Real
QUAD(delta);
2789 for(
i = 0;
i < nnz;
i++ )
2792 SCIP_Real
QUAD(delta);
2863 for(
i = 0;
i < nnz;
i++ )
2866 SCIP_Real
QUAD(delta);
2950 for(
i = 0;
i < nnz;
i++ )
2984 SCIP_CALL(
tightenSingleVar(conflict,
set, stat, tree, blkmem, origprob, transprob, reopt, lp, branchcand, \
2985 eventqueue, cliquetable,
var, val, rhs-
resminact, conflicttype, validdepth) );
3002 SCIP_CALL(
tightenSingleVar(conflict,
set, stat, tree, blkmem, origprob, transprob, reopt, lp, branchcand, \
3003 eventqueue, cliquetable,
var, val, rhs-
resminact, conflicttype, validdepth) );
3097 if(
set->conf_minmaxvars >= nnz )
3132 SCIP_CALL(
propagateLongProof(conflict,
set, stat, reopt, tree, blkmem, origprob, transprob, lp, branchcand,
3133 eventqueue, cliquetable, coefs, inds, nnz, rhs, conflicttype, proofset->
validdepth) );
3163 for(
i = 0;
i < nnz;
i++ )
3198 SCIP_Real scale = 1.0;
3199 SCIP_Bool updateside =
FALSE;
3261 SCIPsetDebugMsg(
set,
"added proof-constraint to node %p (#%lld) in depth %d (nproofconss %d)\n",
3361 tree, reopt, lp, branchcand, eventqueue, cliquetable, blkmem) );
3393 branchcand, eventqueue, cliquetable,
vars[inds[0]], coefs[0], rhs,
3400 transprob, tree, reopt, lp, branchcand, eventqueue, cliquetable, blkmem) );
3434 SCIP_Bool redundant;
3465 SCIP_CALL(
detectImpliedBounds(
set, transprob, stat, tree, blkmem, origprob, reopt, lp, conflictset, &nbdchgs, &
nredvars, &redundant) );
3480 SCIPsetDebugMsg(
set,
" -> conflict set led to %d global bound changes %s(cdpt:%d, fdpt:%d, confdpt:%d, len:%d):\n",
3528 reopt, lp, branchcand, eventqueue, cliquetable,
var,
bound, boundtype,
FALSE) );
3539 for(
h = 0;
h <
set->nconflicthdlrs; ++
h )
3554 SCIPsetDebugMsg(
set,
" -> call conflict handler <%s> (prio=%d) to create conflict set with %d bounds returned result %d\n",
3619 SCIPsetDebugMsg(
set,
"flushing %d conflict sets at focus depth %d (maxconflictsets: %d, maxsize: %d)\n",
3646 SCIPsetDebugMsg(
set,
" -> ignoring conflict set with insertdepth %d >= cutoffdepth %d\n",
3656 SCIPsetDebugMsg(
set,
" -> empty conflict set in depth %d cuts off sub tree at depth %d\n",
3680 branchcand, eventqueue, cliquetable, conflictset, conflictset->
insertdepth, &
success) );
3689 SCIPsetDebugMsg(
set,
" -> empty conflict set in depth %d cuts off sub tree at depth %d\n",
3693 reopt, lp, blkmem) );
3700 SCIPsetDebugMsg(
set,
" -> conflict set %d/%d added (cdpt:%d, fdpt:%d, insert:%d, valid:%d, conf:%d, reprop:%d, len:%d):\n",
3740 SCIPsetDebugMsg(
set,
" -> empty reprop conflict set in depth %d cuts off sub tree at depth %d\n",
3744 origprob, reopt, lp, blkmem) );
3750 SCIPsetDebugMsg(
set,
" -> additional reprop conflict set added (cdpt:%d, fdpt:%d, insert:%d, valid:%d, conf:%d, reprop:%d, len:%d):\n",
3762 SCIPsetDebugMsg(
set,
"marked node %p in depth %d to be repropagated due to conflicts found in depth %d\n",
3924 if( !
set->conf_enable || !
set->conf_useprop )
3928 if(
set->nconflicthdlrs == 0 )
3960 (*conflict)->conflictsets =
NULL;
3961 (*conflict)->conflictsetscores =
NULL;
3962 (*conflict)->tmpbdchginfos =
NULL;
3963 (*conflict)->conflictsetssize = 0;
3964 (*conflict)->nconflictsets = 0;
3965 (*conflict)->proofsets =
NULL;
3966 (*conflict)->proofsetssize = 0;
3967 (*conflict)->nproofsets = 0;
3968 (*conflict)->tmpbdchginfossize = 0;
3969 (*conflict)->ntmpbdchginfos = 0;
3970 (*conflict)->count = 0;
3971 (*conflict)->nglbchgbds = 0;
3972 (*conflict)->nappliedglbconss = 0;
3973 (*conflict)->nappliedglbliterals = 0;
3974 (*conflict)->nlocchgbds = 0;
3975 (*conflict)->nappliedlocconss = 0;
3976 (*conflict)->nappliedlocliterals = 0;
3977 (*conflict)->npropcalls = 0;
3978 (*conflict)->npropsuccess = 0;
3979 (*conflict)->npropconfconss = 0;
3980 (*conflict)->npropconfliterals = 0;
3981 (*conflict)->npropreconvconss = 0;
3982 (*conflict)->npropreconvliterals = 0;
3983 (*conflict)->ninflpcalls = 0;
3984 (*conflict)->ninflpsuccess = 0;
3985 (*conflict)->ninflpconfconss = 0;
3986 (*conflict)->ninflpconfliterals = 0;
3987 (*conflict)->ninflpreconvconss = 0;
3988 (*conflict)->ninflpreconvliterals = 0;
3989 (*conflict)->ninflpiterations = 0;
3990 (*conflict)->nboundlpcalls = 0;
3991 (*conflict)->nboundlpsuccess = 0;
3992 (*conflict)->nboundlpconfconss = 0;
3993 (*conflict)->nboundlpconfliterals = 0;
3994 (*conflict)->nboundlpreconvconss = 0;
3995 (*conflict)->nboundlpreconvliterals = 0;
3996 (*conflict)->nboundlpiterations = 0;
3997 (*conflict)->nsbcalls = 0;
3998 (*conflict)->nsbsuccess = 0;
3999 (*conflict)->nsbconfconss = 0;
4000 (*conflict)->nsbconfliterals = 0;
4001 (*conflict)->nsbreconvconss = 0;
4002 (*conflict)->nsbreconvliterals = 0;
4003 (*conflict)->nsbiterations = 0;
4004 (*conflict)->npseudocalls = 0;
4005 (*conflict)->npseudosuccess = 0;
4006 (*conflict)->npseudoconfconss = 0;
4007 (*conflict)->npseudoconfliterals = 0;
4008 (*conflict)->npseudoreconvconss = 0;
4009 (*conflict)->npseudoreconvliterals = 0;
4010 (*conflict)->ndualproofsinfglobal = 0;
4011 (*conflict)->ndualproofsinflocal = 0;
4012 (*conflict)->ndualproofsinfsuccess = 0;
4013 (*conflict)->dualproofsinfnnonzeros = 0;
4014 (*conflict)->ndualproofsbndglobal = 0;
4015 (*conflict)->ndualproofsbndlocal = 0;
4016 (*conflict)->ndualproofsbndsuccess = 0;
4017 (*conflict)->dualproofsbndnnonzeros = 0;
4032 assert((*conflict)->nconflictsets == 0);
4033 assert((*conflict)->ntmpbdchginfos == 0);
4035#ifdef SCIP_CONFGRAPH
4079 SCIP_Bool usescutoffbound
4104 if( conflict->
count == 0 )
4105 conflict->
count = 1;
4110 assert(0.0 <
set->conf_scorefac &&
set->conf_scorefac <= 1.0);
4119 for( v = 0; v < prob->
nvars; ++v )
4130#ifdef SCIP_CONFGRAPH
4167 SCIPsetDebugMsg(
set,
"ignoring redundant bound change <%s> >= %g since a stronger lower bound exist <%s> >= %g\n",
4198 SCIPsetDebugMsg(
set,
"ignoring redundant bound change <%s> <= %g since a stronger upper bound exist <%s> <= %g\n",
4246 SCIPsetDebugMsg(
set,
"putting bound change <%s> %s %g(%g) at depth %d to current conflict set\n",
4259#ifdef SCIP_CONFGRAPH
4264#ifdef SCIP_CONFGRAPH
4326#ifdef SCIP_CONFGRAPH
4330#ifdef SCIP_CONFGRAPH
4366 (*bound) -= constant;
4390 SCIPsetDebugMsg(
set,
" -> adding bound <%s> %s %.15g(%.15g) [status:%d, type:%d, depth:%d, pos:%d, reason:<%s>, info:%d] to candidates\n",
4550 if(
set->conf_ignorerelaxedbd )
4573 while( nbdchgs > 0 )
4585 SCIPsetDebugMsg(
set,
"lower bound change %d oldbd=%.15g, newbd=%.15g, depth=%d, pos=%d, redundant=%u\n",
4619 while( nbdchgs > 0 )
4631 SCIPsetDebugMsg(
set,
"upper bound change %d oldbd=%.15g, newbd=%.15g, depth=%d, pos=%d, redundant=%u\n",
4784#ifdef SCIP_CONFGRAPH
4855 SCIP_Bool repropagate,
4880 if( !
set->conf_allowlocal && validdepth > 0 )
4900 SCIPsetDebugMsg(
set,
"adding %d variables from the queue as temporary conflict variables\n", nbdchginfos);
4906 SCIPsetDebugMsg(
set,
" -> conflict with %d literals found at depth %d is active in depth %d and valid in depth %d\n",
4915 if( !
set->conf_settlelocal )
4984 SCIPsetDebugMsg(
set,
"processing next conflicting bound (depth: %d, valid depth: %d, bdchgtype: %s [%s], vartype: %d): [<%s> %s %g(%g)]\n",
5056 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",
5100 if( inferprop !=
NULL )
5116 SCIPsetDebugMsg(
set,
"resolving bound <%s> %s %g(%g) [status:%d, depth:%d, pos:%d]: <%s> %s %g [prop:<%s>, info:%d]\n",
5175 SCIP_Bool usescutoffbound;
5218 SCIPsetDebugMsg(
set,
"creating reconvergence constraint for UIP <%s> %s %g in depth %d pos %d\n",
5318 SCIPsetDebugMsg(
set,
"couldn't resolve forced bound change on <%s> -> new valid depth: %d\n",
5366 SCIPsetDebugMsg(
set,
"creating reconvergence constraint from UIP <%s> to UIP <%s> in depth %d with %d literals after %d resolutions\n",
5375 (*nreconvliterals) +=
nlits;
5448 SCIPsetDebugMsg(
set,
"analyzing conflict with %d+%d conflict candidates and starting conflict set of size %d in depth %d (resolvedepth=%d)\n",
5523 SCIPsetDebugMsg(
set,
"creating intermediate conflictset after %d resolutions up to depth %d (valid at depth %d): %d conflict bounds, %d bounds in queue\n",
5533 (*nliterals) +=
nlits;
5595 SCIPsetDebugMsg(
set,
"couldn't resolve forced bound change on <%s> -> new valid depth: %d\n",
5642 (*nliterals) +=
nlits;
5724 SCIP_CALL(
conflictAnalyze(conflict, blkmem,
set, stat, prob, tree,
FALSE, validdepth,
TRUE, &nconss, &
nliterals, \
5917 (*sidechgoldlhss)[*
nsidechgs] = lhs - constant;
5927 (*sidechgoldrhss)[*
nsidechgs] = rhs - constant;
6021 SCIP_Real** candscores,
6065 SCIP_Real** candscores,
6164 SCIPsetDebugMsg(
set,
" -> local <%s> %s %g, relax <%s> %s %g, proofcoef=%g, dpt=%d, resolve=%u, delta=%g, score=%g\n",
6170 for(
i = *ncands;
i >
firstcand && score > (*candscores)[
i-1]; --
i )
6172 (*cands)[
i] = (*cands)[
i-1];
6173 (*candscores)[
i] = (*candscores)[
i-1];
6174 (*newbounds)[
i] = (*newbounds)[
i-1];
6175 (*proofactdeltas)[
i] = (*proofactdeltas)[
i-1];
6178 (*candscores)[
i] = score;
6179 (*newbounds)[
i] = newbound;
6242 SCIP_Real* candscores;
6275 for( v = 0; v <
nvars; ++v )
6302 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g\n",
6315 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g\n",
6343 for(
i = 0;
i < ncands; ++
i )
6358 SCIPsetDebugMsg(
set,
" -> relaxing variable <%s>[%g,%g] to [%g,%g]: proofcoef=%g, %g <= %g + %g\n",
6436#define NUMSTOP 9007199254740992.0
6574 SCIP_Bool usescutoffbound;
6685 SCIP_CALL(
conflictAnalyze(conflict, blkmem,
set, stat, prob, tree, diving, 0,
FALSE, nconss,
nliterals, \
6716 SCIPsetDebugMsg(
set,
" -> add %s row <%s>[%g,%g](lp depth: %d): dual=%g -> dualrhs=%g\n",
6717 row->
local ?
"local" :
"global",
6761 SCIPsetDebugMsg(
set,
" -> invalid dual solution value %g for row <%s>: lhs=%g, rhs=%g\n",
6799 for(
i = 0;
i < nrows;
i++ )
6808 for(
i = 0;
i < nrows;
i++ )
6831 for(
i = 0;
i < nrows-1;
i++ )
6867 if( !
set->conf_uselocalrows )
6998 SCIP_Real* dualfarkas;
7051 for(
r = 0;
r < nrows; ++
r )
7230 for(
r = 0;
r < nrows;
r++ )
7274 for(
r = 0;
r < nrows; ++
r )
7391#define debugPrintViolationInfo(...)
7400 SCIP_Bool* redundant
7408 for(
i = 0;
i < proofset->
nnz;
i++ )
7422 for(
i = 0;
i < proofset->
nnz;
i++ )
7428 SCIPsetDebugMsg(
set,
"coefficient tightening: [%.15g,%.15g] -> [%.15g,%.15g] (nnz: %d, nchg: %d rhs: %.15g)\n",
7430 printf(
"coefficient tightening: [%.15g,%.15g] -> [%.15g,%.15g] (nnz: %d, nchg: %d rhs: %.15g)\n",
7495 for(
i = 0;
i < nnz;
i++ )
7522 NULL,
NULL,
MINFRAC,
MAXFRAC,
proofrow,
cutcoefs, &
cutrhs,
cutinds, &
cutnnz, &
cutefficacy,
NULL, \
7530 SCIP_Bool redundant;
7588 SCIP_Bool redundant;
7609 for(
i = 0;
i < nnz;
i++ )
7627 if(
set->conf_sepaaltproofs )
7651 for(
i = 0;
i < nnz;
i++ )
7703 SCIPsetDebugMsg(
set,
"-> remove continuous variable <%s>: glb=[%g,%g], loc=[%g,%g], val=%g\n",
7724 SCIP_Real
eps =
MIN(0.01, 10.0*
set->num_feastol);
7913 solvelp = (
set->conf_maxlploops != 0 &&
set->conf_lpiterations != 0);
7961 for(
r = 0;
r < nrows; ++
r )
8027 (*iterations) +=
iter;
8076 if(
set->conf_useinflp ==
'd' ||
set->conf_useinflp ==
'b' )
8098 (*proofactivity) = -(*proofactivity);
8103 for( v = 0; v < nnz; v++ )
8147 (*proofactivity) = -(*proofactivity);
8152 for( v = 0; v < nnz; v++ )
8170 SCIPsetDebugMsg(
set,
" -> finished infeasible LP conflict analysis loop %d (iter: %d, nbdchgs: %d)\n",
8174 SCIPsetDebugMsg(
set,
"finished undoing bound changes after %d loops (valid=%u, nbdchgs: %d)\n",
8339 (*iterations) +=
iter;
8459 SCIP_CALL(
conflictAnalyzeDualProof(conflict,
set, stat, blkmem, origprob, transprob, tree, reopt, lp,
farkasrow, \
8478 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible LP (infeasible: %u, objlimexc: %u, optimal:%u) in depth %d (diving: %u)\n",
8495 for( v = 0; v < nnz; v++ )
8504 SCIP_CALL(
runBoundHeuristic(conflict,
set, stat, origprob, transprob, tree, reopt, lp, lpi, blkmem,
farkascoefs,
8518 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, \
8519 eventqueue, cliquetable) );
8526 SCIP_CALL(
conflictFlushProofset(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, \
8527 branchcand, eventqueue, cliquetable) );
8579 if( !
set->conf_enable ||
set->conf_useinflp ==
'o' )
8583 if(
set->nconflicthdlrs == 0 )
8586 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible LP in depth %d (solstat: %d, objchanged: %u)\n",
8598 SCIP_CALL(
conflictAnalyzeLP(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, \
8656 if( !
set->conf_enable ||
set->conf_useboundlp ==
'o')
8660 if(
set->nconflicthdlrs == 0 )
8663 SCIPsetDebugMsg(
set,
"analyzing conflict on bound exceeding LP in depth %d (solstat: %d)\n",
8677 SCIP_CALL(
conflictAnalyzeLP(conflict, conflictstore, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, \
8728 if( !
set->conf_enable || (
set->conf_useinflp ==
'o' &&
set->conf_useboundlp ==
'o') )
8792 reopt, lp, branchcand, eventqueue, cliquetable,
success) );
8797 reopt, lp, branchcand, eventqueue, cliquetable,
success) );
9069 if( !
set->conf_enable || !
set->conf_usesb )
9073 if(
set->nconflicthdlrs == 0 )
9101 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible downwards strongbranch for variable <%s>[%g,%g] in depth %d\n",
9165 SCIPsetDebugMsg(
set,
"analyzing conflict on infeasible upwards strongbranch for variable <%s>[%g,%g] in depth %d\n",
9465 if( !
set->conf_enable || !
set->conf_usepseudo )
9469 if(
set->nconflicthdlrs == 0 )
9472 SCIPsetDebugMsg(
set,
"analyzing pseudo solution (obj: %g) that exceeds objective limit (%g)\n",
9512 for( v = 0; v <
nvars; ++v )
9567 SCIP_CALL(
SCIPconflictFlushConss(conflict, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue, cliquetable) );
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
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)
int SCIPconflictGetNConflicts(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedGlobalConss(SCIP_CONFLICT *conflict)
static 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)
SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
SCIP_Longint SCIPconflictGetNDualproofsInfLocal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(SCIP_CONFLICT *conflict)
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)
SCIP_Longint SCIPconflictGetNPropCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchIterations(SCIP_CONFLICT *conflict)
SCIP_Real SCIPconflictGetInfeasibleLPTime(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictQueueBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
SCIP_RETCODE SCIPconflictCreate(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem, SCIP_SET *set)
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)
SCIP_Real SCIPconflictGetGlobalApplTime(SCIP_CONFLICT *conflict)
static void conflictClear(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(SCIP_CONFLICT *conflict)
void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)
static void proofsetFree(SCIP_PROOFSET **proofset, BMS_BLKMEM *blkmem)
static SCIP_RETCODE conflictEnsureTmpbdchginfosMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNGlobalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNAppliedLiterals(SCIP_CONFLICT *conflict)
static SCIP_Bool checkDualFeasibility(SCIP_SET *set, SCIP_ROW *row, SCIP_Real weight, SCIP_Bool *zerocontribution)
SCIP_RETCODE SCIPconflictAnalyzeStrongbranch(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_COL *col, SCIP_Bool *downconflict, SCIP_Bool *upconflict)
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)
SCIP_Longint SCIPconflictGetNPropConflictLiterals(SCIP_CONFLICT *conflict)
void SCIPconflicthdlrSetFree(SCIP_CONFLICTHDLR *conflicthdlr,)
SCIP_Longint SCIPconflictGetNAppliedConss(SCIP_CONFLICT *conflict)
static char varGetChar(SCIP_VAR *var)
static SCIP_RETCODE conflictInitProofset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem)
static SCIP_RETCODE tightenSingleVar(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Real val, SCIP_Real rhs, SCIP_CONFTYPE prooftype, int validdepth)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE tightenDualproof(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_AGGRROW *proofrow, int validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool initialproof)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNStrongbranchCalls(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool diving, SCIP_Bool *dualproofsuccess, int *iterations, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals, SCIP_Bool marklpunsolved)
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)
SCIP_Longint SCIPconflictGetNPropReconvergenceConss(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictAnalyzePseudo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
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_Real SCIPconflictGetBoundexceedingLPTime(SCIP_CONFLICT *conflict)
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 createAndAddProofcons(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_PROOFSET *proofset, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem)
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,)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(SCIP_CONFLICT *conflict)
static SCIP_Real * proofsetGetVals(SCIP_PROOFSET *proofset)
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)
SCIP_Real SCIPconflictGetPseudoTime(SCIP_CONFLICT *conflict)
static SCIP_RETCODE getDualProof(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)
static SCIP_CONFTYPE proofsetGetConftype(SCIP_PROOFSET *proofset)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictEnsureProofsetsMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)
static SCIP_RETCODE conflictsetCreate(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
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_Longint SCIPconflictGetNPropReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_Bool SCIPconflictApplicable(SCIP_SET *set)
static SCIP_Real getMaxActivity(SCIP_SET *set, SCIP_PROB *transprob, SCIP_Real *coefs, int *inds, int nnz, SCIP_Real *curvarlbs, SCIP_Real *curvarubs)
static SCIP_RETCODE conflictResolveBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd, int validdepth, SCIP_Bool *resolved)
static SCIP_RETCODE addLocalRows(SCIP_SET *set, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_AGGRROW *proofrow, SCIP_ROW **rows, SCIP_Real *dualsols, int *localrowinds, int *localrowdepth, int nlocalrows, SCIP_Real *proofact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)
static void conflictsetFree(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)
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 int * proofsetGetInds(SCIP_PROOFSET *proofset)
static SCIP_Real conflictsetCalcScore(SCIP_CONFLICTSET *conflictset, SCIP_SET *set)
static int conflictCalcMaxsize(SCIP_SET *set, SCIP_PROB *prob)
static SCIP_Real getMinActivity(SCIP_SET *set, SCIP_PROB *transprob, SCIP_Real *coefs, int *inds, int nnz, SCIP_Real *curvarlbs, SCIP_Real *curvarubs)
static SCIP_RETCODE conflictAddConflictBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)
static SCIP_RETCODE propagateLongProof(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_REOPT *reopt, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real *coefs, int *inds, int nnz, SCIP_Real rhs, SCIP_CONFTYPE conflicttype, int validdepth)
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)
SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE separateAlternativeProofs(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_AGGRROW *proofrow, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_CONFTYPE conflicttype)
SCIP_Longint SCIPconflictGetNAppliedLocalConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE runBoundHeuristic(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 sortLocalRows(SCIP_SET *set, SCIP_AGGRROW *aggrrow, SCIP_ROW **rows, int *rowinds, int *rowdepth, int nrows)
SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeBoundexceedingLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
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 int proofsetGetNVars(SCIP_PROOFSET *proofset)
static 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)
static SCIP_RETCODE proofsetAddAggrrow(SCIP_PROOFSET *proofset, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_AGGRROW *aggrrow)
SCIP_Real SCIPconflictGetVarUb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
static SCIP_Real aggrRowGetMinActivity(SCIP_SET *set, SCIP_PROB *transprob, SCIP_AGGRROW *aggrrow, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *infdelta)
SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(SCIP_CONFLICT *conflict)
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_Real SCIPconflictGetStrongbranchTime(SCIP_CONFLICT *conflict)
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)
SCIP_Longint SCIPconflictGetNPseudoSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(SCIP_CONFLICT *conflict)
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)
SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(SCIP_CONFLICT *conflict)
static SCIP_Bool bdchginfoIsResolvable(SCIP_BDCHGINFO *bdchginfo)
static SCIP_Bool checkRedundancy(SCIP_SET *set, SCIP_CONFLICTSET *conflictset)
static void lpbdchgsReset(SCIP_LPBDCHGS *lpbdchgs, int ncols)
SCIP_Longint SCIPconflictGetNLocalChgBds(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictIsVarUsed(SCIP_CONFLICT *conflict, SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)
static SCIP_RETCODE undoBdchgsProof(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)
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_Longint SCIPconflictGetNPropSuccess(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(SCIP_CONFLICT *conflict)
#define debugPrintViolationInfo(...)
static SCIP_RETCODE getFarkasProof(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_Longint SCIPconflictGetNBoundexceedingLPCalls(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictsetCalcInsertDepth(SCIP_CONFLICTSET *conflictset, SCIP_SET *set, SCIP_TREE *tree)
SCIP_Longint SCIPconflictGetNPropConflictConss(SCIP_CONFLICT *conflict)
static void proofsetCancelVarWithBound(SCIP_PROOFSET *proofset, SCIP_SET *set, SCIP_VAR *var, int pos, SCIP_Bool *valid)
static SCIP_BDCHGINFO * conflictRemoveCand(SCIP_CONFLICT *conflict)
static void tightenCoefficients(SCIP_SET *set, SCIP_PROOFSET *proofset, int *nchgcoefs, SCIP_Bool *redundant)
SCIP_Longint SCIPconflictGetNStrongbranchSuccess(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeRemainingBdchgs(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 void proofsetClear(SCIP_PROOFSET *proofset)
SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictAnalyzeInfeasibleLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)
SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictsetEnsureBdchginfosMem(SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(SCIP_CONFLICT *conflict)
static SCIP_BDCHGINFO * conflictFirstCand(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsBndLocal(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_Longint SCIPconflictGetNPseudoCalls(SCIP_CONFLICT *conflict)
static SCIP_RETCODE proofsetCreate(SCIP_PROOFSET **proofset, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
static void skipRedundantBdchginfos(SCIP_VAR *var, int *lbchginfopos, int *ubchginfopos)
void SCIPconflictEnableOrDisableClocks(SCIP_CONFLICT *conflict, SCIP_Bool enable)
static SCIP_RETCODE conflictInsertConflictset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONFLICTSET **conflictset)
static SCIP_RETCODE conflictFlushProofset(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
static SCIP_Real proofsetGetRhs(SCIP_PROOFSET *proofset)
SCIP_Real SCIPconflictGetPropTime(SCIP_CONFLICT *conflict)
static SCIP_RETCODE conflictEnsureConflictsetsMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)
SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(SCIP_CONFLICT *conflict)
static void lpbdchgsFree(SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set)
SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)
static SCIP_RETCODE addRowToAggrRow(SCIP_SET *set, SCIP_ROW *row, SCIP_Real weight, SCIP_AGGRROW *aggrrow)
SCIP_Longint SCIPconflictGetNPseudoConflictConss(SCIP_CONFLICT *conflict)
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 conflictAnalyzeDualProof(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)
SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(SCIP_CONFLICT *conflict)
SCIP_RETCODE SCIPconflictFree(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem)
SCIP_Real SCIPconflictGetVarLb(SCIP_CONFLICT *conflict, SCIP_VAR *var)
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,)
SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(SCIP_CONFLICT *conflict)
SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(SCIP_CONFLICT *conflict)
static SCIP_RETCODE proofsetAddSparseData(SCIP_PROOFSET *proofset, BMS_BLKMEM *blkmem, SCIP_Real *vals, int *inds, int nnz, SCIP_Real rhs)
static SCIP_RETCODE conflictInsertProofset(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_PROOFSET *proofset)
internal methods for conflict analysis
SCIP_RETCODE SCIPconflictstoreAddDualraycons(SCIP_CONFLICTSTORE *conflictstore, SCIP_CONS *dualproof, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_REOPT *reopt, SCIP_Bool hasrelaxvar)
int SCIPconflictstoreGetNDualInfProofs(SCIP_CONFLICTSTORE *conflictstore)
SCIP_Real SCIPconflictstoreGetAvgNnzDualInfProofs(SCIP_CONFLICTSTORE *conflictstore)
int SCIPconflictstoreGetNDualBndProofs(SCIP_CONFLICTSTORE *conflictstore)
SCIP_Real SCIPconflictstoreGetAvgNnzDualBndProofs(SCIP_CONFLICTSTORE *conflictstore)
SCIP_RETCODE SCIPconflictstoreAddDualsolcons(SCIP_CONFLICTSTORE *conflictstore, SCIP_CONS *dualproof, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_REOPT *reopt, SCIP_Real scale, SCIP_Bool updateside, SCIP_Bool hasrelaxvar)
internal methods for storing conflicts
void SCIPconsMarkConflict(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
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 SCIPquadprecProdDD(r, a, b)
#define SCIPquadprecProdQD(r, a, b)
#define QUAD_ASSIGN(a, constant)
#define SCIPquadprecSumDD(r, a, b)
#define SCIPquadprecSumQQ(r, a, b)
#define SCIPdebugCheckConflict(blkmem, set, node, bdchginfos, relaxedbds, nliterals)
#define SCIPdebugCheckConflictFrontier(blkmem, set, node, bdchginfo, bdchginfos, relaxedbds, nliterals, bdchgqueue, forcedbdchgqueue)
#define SCIP_CALL_FINALLY(x, y)
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPupgradeConsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **upgdcons)
SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)
void SCIPgmlWriteClosing(FILE *file)
void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)
void 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_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
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_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
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 SCIPpqueueCreate(SCIP_PQUEUE **pqueue, int initsize, SCIP_Real sizefac, SCIP_DECL_SORTPTRCOMP((*ptrcomp)),)
void SCIPpqueueFree(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)
SCIP_VAR * SCIPcolGetVar(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)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
int SCIPconsGetValidDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPcutGenerationHeuristicCMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxtestdelta, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
SCIP_Bool SCIPcutsTightenCoefficients(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, int *nchgcoefs)
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)
SCIP_RETCODE SCIPcalcFlowCover(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool allowlocal, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)
SCIP_Real SCIPaggrRowCalcEfficacyNorm(SCIP *scip, SCIP_AGGRROW *aggrrow)
#define SCIPfreeBufferArrayNull(scip, ptr)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
int SCIPnodeGetDepth(SCIP_NODE *node)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
int SCIProwGetLPDepth(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_Real SCIPvarGetObj(SCIP_VAR *var)
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 SCIPvarGetAvgSol(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_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
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 SCIPsortIntInt(int *intarray1, int *intarray2, int len)
void SCIPsortedvecInsertIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)
void SCIPsortIntIntInt(int *intarray1, int *intarray2, int *intarray3, int len)
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,...)
SCIPfreeSol(scip, &heurdata->sol))
SCIPcreateSol(scip, &heurdata->sol, heur))
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_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
static const SCIP_Real scalars[]
int SCIPlpGetNRows(SCIP_LP *lp)
SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
internal methods for LP management
interface methods for specific LP solvers
static const char * paramname[]
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define 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)
SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobAddCons(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
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 solutions
public methods for SCIP variables
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
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_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool 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_Real SCIPsetCutoffbounddelta(SCIP_SET *set)
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)
SCIP_RETCODE SCIPsolSetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_VAR *var, SCIP_Real val)
internal methods for storing primal CIP solutions
unsigned int hasrelaxonlyvar
SCIP_BDCHGINFO ** bdchginfos
SCIP_CONFTYPE conflicttype
unsigned int usescutoffbound
SCIP_Longint ninflpiterations
SCIP_Real * conflictsetscores
SCIP_Longint ndualproofsbndglobal
SCIP_Longint ndualproofsinfsuccess
SCIP_Longint nappliedglbconss
SCIP_Longint nsbiterations
SCIP_Longint npropconfconss
SCIP_Longint ninflpconfconss
SCIP_Longint npseudoreconvliterals
SCIP_Longint npseudosuccess
SCIP_Longint ninflpconfliterals
SCIP_CLOCK * propanalyzetime
SCIP_Longint nboundlpconfliterals
SCIP_PROOFSET ** proofsets
SCIP_Longint ndualproofsinflocal
SCIP_Longint npseudoconfconss
SCIP_Longint nboundlpcalls
SCIP_PQUEUE * forcedbdchgqueue
SCIP_Longint nappliedglbliterals
SCIP_Longint nboundlpreconvliterals
SCIP_CONFLICTSET ** conflictsets
SCIP_Longint npseudocalls
SCIP_Longint ninflpreconvconss
SCIP_Longint dualproofsbndnnonzeros
SCIP_CLOCK * pseudoanalyzetime
SCIP_Longint nsbconfliterals
SCIP_CLOCK * inflpanalyzetime
SCIP_Longint nboundlpiterations
SCIP_Longint npseudoreconvconss
SCIP_Longint npseudoconfliterals
SCIP_Longint nsbreconvconss
SCIP_Longint nsbreconvliterals
SCIP_Longint npropsuccess
SCIP_Longint ndualproofsinfglobal
SCIP_Longint nappliedlocconss
SCIP_Longint nsbconfconss
SCIP_Longint ninflpsuccess
SCIP_CLOCK * sbanalyzetime
SCIP_Longint nboundlpreconvconss
SCIP_Longint ndualproofsbndsuccess
SCIP_Longint dualproofsinfnnonzeros
SCIP_Longint nboundlpconfconss
SCIP_Longint npropreconvliterals
SCIP_CLOCK * boundlpanalyzetime
SCIP_Longint nboundlpsuccess
SCIP_BDCHGINFO ** tmpbdchginfos
SCIP_Longint npropconfliterals
SCIP_Longint ninflpreconvliterals
SCIP_CONFLICTSET * conflictset
SCIP_Longint ndualproofsbndlocal
SCIP_Longint nappliedlocliterals
SCIP_Longint npropreconvconss
SCIP_BOUNDCHG * boundchgs
SCIP_Bool strongbranching
SCIP_CONFTYPE conflicttype
SCIP_Longint nconflictlps
SCIP_HISTORY * glbhistory
SCIP_Longint lastconflictnode
SCIP_HISTORY * glbhistorycrun
SCIP_Longint nconflictlpiterations
SCIP_CLOCK * conflictlptime
SCIP_BDCHGINFO * lbchginfos
SCIP_Real conflictrelaxedub
SCIP_BDCHGINFO * ubchginfos
SCIP_Real conflictrelaxedlb
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)
SCIP_RETCODE SCIPnodeAddCons(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_CONS *cons)
int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)
internal methods for branch and bound tree
#define SCIP_DECL_CONFLICTEXIT(x)
#define SCIP_DECL_CONFLICTCOPY(x)
#define SCIP_DECL_CONFLICTEXEC(x)
#define SCIP_DECL_CONFLICTINITSOL(x)
#define SCIP_DECL_CONFLICTFREE(x)
@ SCIP_CONFTYPE_ALTINFPROOF
@ SCIP_CONFTYPE_BNDEXCEEDING
@ SCIP_CONFTYPE_PROPAGATION
@ SCIP_CONFTYPE_ALTBNDPROOF
#define SCIP_DECL_CONFLICTINIT(x)
enum SCIP_ConflictType SCIP_CONFTYPE
struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA
#define SCIP_DECL_CONFLICTEXITSOL(x)
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BranchDir SCIP_BRANCHDIR
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
#define SCIP_DECL_SORTPTRCOMP(x)
struct SCIP_ParamData SCIP_PARAMDATA
#define SCIP_DECL_PARAMCHGD(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_PROPINFER
@ SCIP_BOUNDCHGTYPE_BRANCHING
@ SCIP_BOUNDCHGTYPE_CONSINFER
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
enum SCIP_Vartype SCIP_VARTYPE
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)
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
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)