77#define MAXIMPLSCLOSURE 100
79#define MAXABSVBCOEF 1e+5
94#ifdef DEBUGUSES_VARNAME
115 for(
i = 1;
i < size; ++
i )
125#ifndef DEBUGUSES_NOADDR2LINE
164 SCIPsetDebugMsg(
set,
"create hole list element (%.15g,%.15g) in blkmem %p\n", left, right, (
void*)blkmem);
167 (*holelist)->hole.left = left;
168 (*holelist)->hole.right = right;
169 (*holelist)->next =
NULL;
184 while( *holelist !=
NULL )
189 (*holelist)->hole.left, (*holelist)->hole.right, (
void*)blkmem);
191 next = (*holelist)->
next;
216 target = &(*target)->next;
241 while( *
insertpos !=
NULL && (*insertpos)->hole.left < left )
245 if( *
insertpos !=
NULL && (*insertpos)->hole.left == left && (*insertpos)->hole.right >= right )
247 SCIPsetDebugMsg(
set,
"new hole (%.15g,%.15g) is redundant through known hole (%.15g,%.15g)\n",
248 left, right, (*insertpos)->hole.left, (*insertpos)->hole.right);
258 (*insertpos)->next = next;
294 if( (*holelistptr)->next !=
NULL )
297 lastleft = (*holelistptr)->hole.left;
313 SCIPsetDebugMsg(
set,
"check hole (%.15g,%.15g) last right interval was <%.15g>\n", (*holelistptr)->hole.left, (*holelistptr)->hole.right, *
lastrightptr);
321 SCIPsetDebugMsg(
set,
"remove remaining hole since upper bound <%.15g> is less then the left hand side of the current hole\n",
dom->ub);
331 SCIPsetDebugMsg(
set,
"upper bound <%.15g> lays in current hole; store new upper bound and remove this and all remaining holes\n",
dom->ub);
336 dom->ub = (*holelistptr)->hole.left;
339 *
newub = (*holelistptr)->hole.left;
358 SCIPsetDebugMsg(
set,
"lower bound <%.15g> lays in current hole; store new lower bound and remove hole\n",
dom->lb);
369 SCIPsetDebugMsg(
set,
"current hole overlaps with the previous one (...,%.15g); merge to (...,%.15g)\n",
374 (*holelistptr)->next =
NULL;
505 SCIPsetDebugMsg(
set,
"adding lower bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
527 switch( boundchgtype )
580 SCIPsetDebugMsg(
set,
"adding upper bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
602 switch( boundchgtype )
684 SCIPsetDebugMsg(
set,
" -> constraint <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
694 SCIPsetDebugMsg(
set,
" -> propagator <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
751 SCIPsetDebugMsg(
set,
" -> constraint <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
761 SCIPsetDebugMsg(
set,
" -> propagator <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
858 SCIPsetDebugMsg(
set,
"removed lower bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
879 SCIPsetDebugMsg(
set,
"removed upper bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
1049 (*domchg)->domchgdyn.nboundchgs = 0;
1050 (*domchg)->domchgdyn.boundchgs =
NULL;
1051 (*domchg)->domchgdyn.nholechgs = 0;
1052 (*domchg)->domchgdyn.holechgs =
NULL;
1053 (*domchg)->domchgdyn.boundchgssize = 0;
1054 (*domchg)->domchgdyn.holechgssize = 0;
1071 if( *domchg !=
NULL )
1076 for(
i = 0;
i < (int)(*domchg)->domchgbound.nboundchgs; ++
i )
1082 switch( (*domchg)->domchgdyn.domchgtype )
1117 SCIPdebugMessage(
"making domain change data %p pointing to %p dynamic\n", (
void*)domchg, (
void*)*domchg);
1119 if( *domchg ==
NULL )
1125 switch( (*domchg)->domchgdyn.domchgtype )
1129 (*domchg)->domchgdyn.nholechgs = 0;
1130 (*domchg)->domchgdyn.holechgs =
NULL;
1131 (*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;
1132 (*domchg)->domchgdyn.holechgssize = 0;
1137 (*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;
1138 (*domchg)->domchgdyn.holechgssize = (*domchg)->domchgdyn.nholechgs;
1151 for(
i = 0;
i < (int)(*domchg)->domchgbound.nboundchgs; ++
i )
1153 ||
EPSISINT((*domchg)->domchgbound.boundchgs[
i].newbound, 1
e-06));
1172 SCIPsetDebugMsg(
set,
"making domain change data %p pointing to %p static\n", (
void*)domchg, (
void*)*domchg);
1174 if( *domchg !=
NULL )
1176 switch( (*domchg)->domchgdyn.domchgtype )
1179 if( (*domchg)->domchgbound.nboundchgs == 0 )
1185 if( (*domchg)->domchgboth.nholechgs == 0 )
1187 if( (*domchg)->domchgbound.nboundchgs == 0 )
1199 if( (*domchg)->domchgboth.nholechgs == 0 )
1201 if( (*domchg)->domchgbound.nboundchgs == 0 )
1209 (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );
1221 (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );
1223 (*domchg)->domchgdyn.holechgssize, (*domchg)->domchgdyn.nholechgs) );
1235 if( *domchg !=
NULL )
1238 for(
i = 0;
i < (int)(*domchg)->domchgbound.nboundchgs; ++
i )
1319 if( domchg ==
NULL )
1361 if( domchg ==
NULL )
1401 if( domchg ==
NULL )
1404 SCIPsetDebugMsg(
set,
"applying domain changes at %p to the global problem\n", (
void*)domchg);
1410 branchcand, eventqueue, cliquetable,
cutoff) );
1449 SCIPsetDebugMsg(
set,
"adding %s bound change <%s: %g> of variable <%s> to domain change at %p pointing to %p\n",
1451 newbound,
var->
name, (
void*)domchg, (
void*)*domchg);
1456 if( *domchg ==
NULL )
1470 boundchg = &(*domchg)->domchgdyn.boundchgs[(*domchg)->domchgdyn.nboundchgs];
1472 switch( boundchgtype )
1475 boundchg->data.branchingdata.lpsolval = lpsolval;
1480 boundchg->data.inferencedata.reason.cons = infercons;
1481 boundchg->data.inferencedata.info = inferinfo;
1485 boundchg->data.inferencedata.reason.prop = inferprop;
1486 boundchg->data.inferencedata.info = inferinfo;
1494 boundchg->boundchgtype = boundchgtype;
1496 boundchg->inferboundtype = inferboundtype;
1499 (*domchg)->domchgdyn.nboundchgs++;
1504#ifdef SCIP_DISABLED_CODE
1505#ifdef SCIP_MORE_DEBUG
1508 for(
i = 0;
i < (int)(*domchg)->domchgbound.nboundchgs; ++
i )
1536 if( *domchg ==
NULL )
1550 holechg = &(*domchg)->domchgdyn.holechgs[(*domchg)->domchgdyn.nholechgs];
1554 (*domchg)->domchgdyn.nholechgs++;
1651 for(
i = 0;
i < nimpls;
i++ )
1673 implvar->closestvblpcount = -1;
1685 implvar->closestvblpcount = -1;
1706 SCIP_Real* constants;
1766 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1769 implvar->closestvblpcount = -1;
1774 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1777 implvar->closestvblpcount = -1;
1800 SCIP_Real* constants;
1860 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1863 implvar->closestvblpcount = -1;
1868 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1871 implvar->closestvblpcount = -1;
1940 SCIP_Bool removable,
1969 SCIPerrorMessage(
"invalid bounds [%.2g,%.2g] for binary variable <%s>\n", lb, ub, name);
1983 (*var)->scip =
set->scip;
1986 (*var)->unchangedobj =
obj;
1987 (*var)->branchfactor = 1.0;
1988 (*var)->rootsol = 0.0;
1989 (*var)->bestrootsol = 0.0;
1990 (*var)->bestrootredcost = 0.0;
1992 (*var)->relaxsol = 0.0;
1993 (*var)->nlpsol = 0.0;
1994 (*var)->primsolavg = 0.5 * (lb + ub);
1997 (*var)->conflictrelaxedlb = (*var)->conflictlb;
1998 (*var)->conflictrelaxedub = (*var)->conflictub;
2001 (*var)->glbdom.holelist =
NULL;
2002 (*var)->glbdom.lb = lb;
2003 (*var)->glbdom.ub = ub;
2004 (*var)->locdom.holelist =
NULL;
2005 (*var)->locdom.lb = lb;
2006 (*var)->locdom.ub = ub;
2011 (*var)->vardata = vardata;
2012 (*var)->parentvars =
NULL;
2013 (*var)->negatedvar =
NULL;
2014 (*var)->vlbs =
NULL;
2015 (*var)->vubs =
NULL;
2016 (*var)->implics =
NULL;
2017 (*var)->cliquelist =
NULL;
2018 (*var)->eventfilter =
NULL;
2019 (*var)->lbchginfos =
NULL;
2020 (*var)->ubchginfos =
NULL;
2021 (*var)->index = stat->
nvaridx;
2022 (*var)->probindex = -1;
2023 (*var)->pseudocandindex = -1;
2024 (*var)->eventqueueindexobj = -1;
2025 (*var)->eventqueueindexlb = -1;
2026 (*var)->eventqueueindexub = -1;
2027 (*var)->parentvarssize = 0;
2028 (*var)->nparentvars = 0;
2030 (*var)->branchpriority = 0;
2032 (*var)->lbchginfossize = 0;
2033 (*var)->nlbchginfos = 0;
2034 (*var)->ubchginfossize = 0;
2035 (*var)->nubchginfos = 0;
2036 (*var)->conflictlbcount = 0;
2037 (*var)->conflictubcount = 0;
2038 (*var)->closestvlbidx = -1;
2039 (*var)->closestvubidx = -1;
2040 (*var)->closestvblpcount = -1;
2041 (*var)->initial = initial;
2042 (*var)->removable = removable;
2043 (*var)->deleted =
FALSE;
2044 (*var)->donotaggr =
FALSE;
2045 (*var)->donotmultaggr =
FALSE;
2046 (*var)->vartype = vartype;
2047 (*var)->pseudocostflag =
FALSE;
2048 (*var)->eventqueueimpl =
FALSE;
2049 (*var)->deletable =
FALSE;
2050 (*var)->delglobalstructs =
FALSE;
2051 (*var)->relaxationonly =
FALSE;
2055 (*var)->nlocksdown[
i] = 0;
2056 (*var)->nlocksup[
i] = 0;
2066 (*var)->valuehistory =
NULL;
2085 SCIP_Bool removable,
2098 SCIP_CALL(
varCreate(
var, blkmem,
set, stat, name, lb, ub,
obj, vartype, initial, removable,
2103 (*var)->data.original.origdom.holelist =
NULL;
2104 (*var)->data.original.origdom.lb = lb;
2105 (*var)->data.original.origdom.ub = ub;
2106 (*var)->data.original.transvar =
NULL;
2128 SCIP_Bool removable,
2140 SCIP_CALL(
varCreate(
var, blkmem,
set, stat, name, lb, ub,
obj, vartype, initial, removable,
2214 (*var)->donotaggr =
sourcevar->donotaggr;
2215 (*var)->donotmultaggr =
sourcevar->donotmultaggr;
2240 (*var)->vardelorig =
sourcevar->vardelorig;
2242 (*var)->vardeltrans =
sourcevar->vardeltrans;
2248 if(
set->history_allowtransfer )
2259 (*var)->vardelorig =
sourcevar->vardelorig;
2261 (*var)->vardeltrans =
sourcevar->vardeltrans;
2283 (*endptr) = (
char*)
str + 4;
2288 (*endptr) = (
char*)
str + 4;
2321 || (
strncmp(type,
"original", 8) != 0 &&
strncmp(type,
"global", 6) != 0 &&
strncmp(type,
"local", 5) != 0 &&
strncmp(type,
"lazy", 4) != 0 ) )
2387 if(
strncmp(token,
"binary", 3) == 0 )
2389 else if(
strncmp(token,
"integer", 3) == 0 )
2391 else if(
strncmp(token,
"implicit", 3) == 0 )
2393 else if(
strncmp(token,
"continuous", 3) == 0 )
2457 if(
strncmp(token,
"local", 5) == 0 && local )
2462 else if(
strncmp(token,
"lazy", 4) == 0 )
2478 SCIPerrorMessage(
"Parsed invalid bounds for binary variable <%s>: [%f, %f].\n", name, *lb, *ub);
2484 SCIPerrorMessage(
"Parsed invalid lazy bounds for binary variable <%s>: [%f, %f].\n", name, *lazylb, *lazyub);
2504 SCIP_Bool removable,
2529 SCIP_CALL(
varParse(
set, messagehdlr,
str, name, &lb, &ub, &
obj, &vartype, &lazylb, &lazyub,
FALSE,
endptr,
success) );
2534 SCIP_CALL(
varCreate(
var, blkmem,
set, stat, name, lb, ub,
obj, vartype, initial, removable,
2539 (*var)->data.original.origdom.holelist =
NULL;
2540 (*var)->data.original.origdom.lb = lb;
2541 (*var)->data.original.origdom.ub = ub;
2542 (*var)->data.original.transvar =
NULL;
2545 (*var)->lazylb = lazylb;
2546 (*var)->lazyub = lazyub;
2568 SCIP_Bool removable,
2592 SCIP_CALL(
varParse(
set, messagehdlr,
str, name, &lb, &ub, &
obj, &vartype, &lazylb, &lazyub,
TRUE,
endptr,
success) );
2597 SCIP_CALL(
varCreate(
var, blkmem,
set, stat, name, lb, ub,
obj, vartype, initial, removable,
2607 (*var)->lazylb = lazylb;
2608 (*var)->lazyub = lazyub;
2685 for(
i = 0;
i < (*var)->nparentvars; ++
i )
2725 (*var)->negatedvar =
NULL;
2729 SCIPerrorMessage(
"parent variable is neither ORIGINAL, AGGREGATED nor NEGATED\n");
2755 assert((*var)->nuses == 0);
2756 assert((*var)->probindex == -1);
2765 assert((*var)->data.original.transvar ==
NULL);
2766 holelistFree(&(*var)->data.original.origdom.holelist, blkmem);
2767 assert((*var)->data.original.origdom.holelist ==
NULL);
2794 if( (*var)->vardelorig !=
NULL )
2801 if( (*var)->vardeltrans !=
NULL )
2808 if( (*var)->eventfilter !=
NULL )
2857#ifdef DEBUGUSES_VARNAME
2882 assert((*var)->nuses >= 1);
2886 SCIPsetDebugMsg(
set,
"release variable <%s> with nuses=%d\n", (*var)->name, (*var)->nuses);
2889#ifdef DEBUGUSES_VARNAME
2897 printf(
"Released variable " DEBUGUSES_VARNAME " in SCIP %p, now %d uses; released at\n", (
void*)(*var)->scip, (*var)->nuses);
2902 if( (*var)->nuses == 0 )
2982 if( holelist ==
NULL )
2992 while(holelist !=
NULL )
3065 printHolelist(messagehdlr, file, holelist,
"original holes");
3189 SCIPsetDebugMsg(
set,
"add rounding locks %d/%d to variable <%s> (locks=%d/%d, type=%u)\n",
3236 if(
lockvar->data.aggregate.scalar < 0.0 )
3258 for( v =
lockvar->data.multaggr.nvars - 1; v >= 0; --v )
3260 if(
lockvar->data.multaggr.scalars[v] > 0.0 )
3484 *transvar =
origvar->data.original.transvar;
3499 (*transvar)->branchfactor =
origvar->branchfactor;
3500 (*transvar)->branchpriority =
origvar->branchpriority;
3501 (*transvar)->branchdirection =
origvar->branchdirection;
3508 origvar->data.original.transvar = *transvar;
3514 (*transvar)->nlocksdown[
i] =
origvar->nlocksdown[
i];
3515 (*transvar)->nlocksup[
i] =
origvar->nlocksup[
i];
3516 assert((*transvar)->nlocksdown[
i] >= 0);
3517 assert((*transvar)->nlocksup[
i] >= 0);
3521 (*transvar)->donotaggr =
origvar->donotaggr;
3522 (*transvar)->donotmultaggr =
origvar->donotmultaggr;
3525 (*transvar)->lazylb =
origvar->lazylb;
3526 (*transvar)->lazyub =
origvar->lazyub;
3539 (*transvar)->vardata =
origvar->vardata;
3565 if(
origvar->negatedvar->data.original.transvar ==
NULL )
3573 *transvar =
origvar->data.original.transvar;
3765 SCIP_Bool* infeasible,
3781 *infeasible =
FALSE;
3808 lp, branchcand, eventfilter, eventqueue, cliquetable,
fixedval, infeasible,
fixed) );
3868 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
3893 SCIP_CALL(
SCIPvarFix(
var->
data.
aggregate.
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3894 branchcand, eventfilter, eventqueue, cliquetable,
childfixedval, infeasible,
fixed) );
3908 SCIP_CALL(
SCIPvarFix(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3935 SCIP_Real* constant,
4016 for( v =
ntmpvars - 1; v >= 0; --v )
4066#ifdef SCIP_MORE_DEBUG
4217#ifdef SCIP_MORE_DEBUG
4232 while( v >= 0 &&
k >= 0 )
4238 tmpvars[pos] = tmpvars[v];
4254 tmpvars[pos] = tmpvars[v];
4268#ifdef SCIP_MORE_DEBUG
4402 for( v = 0; v < *
nvars; ++v )
4568 SCIP_Bool* infeasible,
4585 *infeasible =
FALSE;
4635 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4636 eventfilter, eventqueue, cliquetable,
varlb, infeasible,
fixed) );
4637 if( !(*infeasible) )
4641 SCIP_CALL(
SCIPvarFix(
aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4642 eventfilter, eventqueue, cliquetable, (
varlb-constant)/scalar, infeasible, &
aggfixed) );
4700 SCIP_CALL(
SCIPvarFix(
aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4701 eventfilter, eventqueue, cliquetable,
aggvarlb, infeasible,
fixed) );
4702 if( !(*infeasible) )
4706 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4707 eventfilter, eventqueue, cliquetable,
aggvarlb * scalar + constant, infeasible, &
varfixed) );
4759 SCIP_Bool* infeasible,
4765 SCIP_Real* constants;
4767 SCIP_Real branchfactor;
4786 *infeasible =
FALSE;
4795 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventfilter,
4796 eventqueue, cliquetable, constant, infeasible,
aggregated) );
4831 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4832 eventfilter, eventqueue, cliquetable, constant/(1.0-scalar), infeasible,
aggregated) );
4838 SCIP_CALL(
varUpdateAggregationBounds(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
4839 branchcand, eventfilter, eventqueue, cliquetable,
aggvar, scalar, constant, infeasible, &
fixed) );
4840 if( *infeasible ||
fixed )
4920 for(
i = 0;
i <
nvbds && !(*infeasible); ++
i )
4922 SCIP_CALL(
SCIPvarAddVlb(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4932 for(
i = 0;
i <
nvbds && !(*infeasible); ++
i )
4934 SCIP_CALL(
SCIPvarAddVub(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4948 for(
i = 0;
i < 2; ++
i )
4960 for(
j = 0;
j < nimpls && !(*infeasible); ++
j )
4965 SCIP_CALL(
SCIPvarAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
5032 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5073 SCIP_Bool* infeasible,
5095#define MAXDNOM 1000000LL
5120 *infeasible =
FALSE;
5174 SCIP_CALL(
SCIPvarAggregate(
varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5175 branchcand, eventfilter, eventqueue,
vary, (SCIP_Real)(-
b/
a), (SCIP_Real)(
c/
a), infeasible,
aggregated) );
5183 SCIP_CALL(
SCIPvarAggregate(
vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5184 branchcand, eventfilter, eventqueue,
varx, (SCIP_Real)(-
a/
b), (SCIP_Real)(
c/
b), infeasible,
aggregated) );
5262 SCIP_CALL(
SCIPvarAggregate(
varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5263 branchcand, eventfilter, eventqueue,
aggvar, (SCIP_Real)(-
b), (SCIP_Real)
xsol, infeasible,
aggregated) );
5266 if( !(*infeasible) )
5268 SCIP_CALL(
SCIPvarAggregate(
vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5269 branchcand, eventfilter, eventqueue,
aggvar, (SCIP_Real)
a, (SCIP_Real)
ysol, infeasible,
aggregated) );
5311 SCIP_Bool* infeasible,
5338 *infeasible =
FALSE;
5430 SCIP_CALL(
SCIPvarAggregate(
varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5431 branchcand, eventfilter, eventqueue,
vary, scalar, constant, infeasible,
aggregated) );
5438 SCIP_CALL(
tryAggregateIntVars(
set, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5465 SCIP_Bool* infeasible,
5472 SCIP_Real branchfactor;
5496 *infeasible =
FALSE;
5504 SCIPerrorMessage(
"cannot multi-aggregate an untransformed original variable\n");
5508 reopt, lp, cliquetable, branchcand, eventfilter, eventqueue,
naggvars,
aggvars,
scalars, constant, infeasible,
aggregated) );
5537 for( v =
ntmpvars - 1; v >= 0; --v )
5542 if( tmpvars[v]->index ==
var->
index )
5545 tmpvars[v] = tmpvars[
ntmpvars - 1];
5558 SCIPsetDebugMsg(
set,
"Possible multi-aggregation was completely resolved and detected to be redundant.\n");
5563 SCIPsetDebugMsg(
set,
"Multi-aggregation was completely resolved and led to infeasibility.\n");
5574 SCIP_CALL(
SCIPvarFix(tmpvars[0], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5575 branchcand, eventfilter, eventqueue, cliquetable, -constant/
tmpscalars[0], infeasible,
aggregated) );
5581 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5585 cliquetable, branchcand, eventfilter, eventqueue, tmpvars[0], tmpvars[1],
tmpscalars[0],
5601 for( v =
ntmpvars - 1; v >= 0; --v )
5609 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5617 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5697 branchfactor =
MAX(tmpvars[v]->branchfactor, branchfactor);
5698 branchpriority =
MAX(tmpvars[v]->branchpriority, branchpriority);
5734 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5757 SCIPerrorMessage(
"cannot multi-aggregate a multiple aggregated variable again\n");
5774 SCIP_CALL(
SCIPvarMultiaggregate(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5825 if (
retvar->data.multaggr.nvars == 1 )
5865 return retvar->donotaggr;
5898 return retvar->donotmultaggr;
5952 (*negvar)->data.negate.constant = 1.0;
5963 (*negvar)->glbdom.lb = (*negvar)->data.negate.constant -
var->
glbdom.
ub;
5964 (*negvar)->glbdom.ub = (*negvar)->data.negate.constant -
var->
glbdom.
lb;
5965 (*negvar)->locdom.lb = (*negvar)->data.negate.constant -
var->
locdom.
ub;
5966 (*negvar)->locdom.ub = (*negvar)->data.negate.constant -
var->
locdom.
lb;
5971 (*negvar)->negatedvar =
var;
5987 (*negvar)->lazylb = (*negvar)->data.negate.constant -
var->
lazyub;
5988 (*negvar)->lazyub = (*negvar)->data.negate.constant -
var->
lazylb;
5992 assert((*negvar)->nuses == 1);
6127 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be aggregated.\n");
6163 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be multi-aggregated.\n");
6197 SCIPerrorMessage(
"cannot change type of variable already in the problem\n");
6326 SCIPerrorMessage(
"cannot change objective value of a fixed, aggregated, multi-aggregated, or negated variable\n");
6409 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6416 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6425 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6439 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6440 SCIP_CALL(
SCIPvarAddObj(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
6441 eventfilter, eventqueue, -
addobj) );
6497 SCIPerrorMessage(
"cannot change diving objective value of a multi-aggregated variable\n");
6700 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6738 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6907 SCIPsetDebugMsg(
set,
" -> adjust lower bound change <%s>: %g -> %g due to new global lower bound %g\n",
6954 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
6997 parentvar->data.negate.constant - newbound) );
7082 SCIPsetDebugMsg(
set,
" -> adjust upper bound change <%s>: %g -> %g due to new global upper bound %g\n",
7129 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7170 parentvar->data.negate.constant - newbound) );
7240 cliquetable, newbound) );
7306 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7449 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7723 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7790 parentvar->data.negate.constant - newbound) );
7890 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7955 parentvar->data.negate.constant - newbound) );
8075 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8201 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8281 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8320 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8371 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8410 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8824 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8913 left, right,
added) );
9072 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
9164 left, right,
added) );
9208 SCIPerrorMessage(
"cannot add domain hole to a multi-aggregated variable.\n");
9387 SCIP_Bool* redundant,
9388 SCIP_Bool* infeasible
9428 SCIP_Bool* infeasible,
9437 *infeasible =
FALSE;
9467 if( nbdchgs !=
NULL )
9497 if( nbdchgs !=
NULL )
9530 SCIP_Bool* infeasible,
9535 SCIP_Bool redundant;
9549 *infeasible =
FALSE;
9554 assert(!redundant || !conflict);
9583 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
9610 SCIP_CALL(
SCIPcliquetableAdd(cliquetable, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
9611 eventqueue,
vars, vals, 2,
FALSE, &conflict, nbdchgs) );
9664 if( nbdchgs !=
NULL )
9736 SCIP_Bool* infeasible,
9746 *infeasible =
FALSE;
9763 while (
i >= 0 && !(*infeasible) )
9774 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9811 SCIP_Bool* infeasible,
9825 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9845 if( !(*infeasible) )
9874 while (
i >= 0 && !(*infeasible) )
9905 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9907 infeasible, nbdchgs, &
added) );
9912 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9914 infeasible, nbdchgs, &
added) );
9944 while (
i >= 0 && !(*infeasible) )
9975 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9977 infeasible, nbdchgs, &
added) );
9982 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9984 infeasible, nbdchgs, &
added) );
10018 SCIP_Bool* infeasible,
10030 *infeasible =
FALSE;
10031 if( nbdchgs !=
NULL )
10053 *infeasible =
TRUE;
10073 if( nbdchgs !=
NULL )
10083 *infeasible =
TRUE;
10098 *infeasible =
TRUE;
10123 if( nbdchgs !=
NULL )
10138 *infeasible =
TRUE;
10163 if( nbdchgs !=
NULL )
10205 *infeasible =
TRUE;
10231 if( nbdchgs !=
NULL )
10261 *infeasible =
TRUE;
10287 if( nbdchgs !=
NULL )
10312 *infeasible =
TRUE;
10339 if( nbdchgs !=
NULL )
10382 infeasible, nbdchgs) );
10448 SCIP_CALL(
SCIPvarAddVub(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10482 SCIP_Bool* infeasible,
10494 *infeasible =
FALSE;
10495 if( nbdchgs !=
NULL )
10511 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10518 *infeasible =
TRUE;
10538 if( nbdchgs !=
NULL )
10548 *infeasible =
TRUE;
10563 *infeasible =
TRUE;
10588 if( nbdchgs !=
NULL )
10603 *infeasible =
TRUE;
10628 if( nbdchgs !=
NULL )
10665 *infeasible =
TRUE;
10691 if( nbdchgs !=
NULL )
10716 *infeasible =
TRUE;
10742 if( nbdchgs !=
NULL )
10767 *infeasible =
TRUE;
10795 if( nbdchgs !=
NULL )
10838 infeasible, nbdchgs) );
10893 SCIP_CALL(
SCIPvarAddVlb(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10930 SCIP_Bool* infeasible,
10940 *infeasible =
FALSE;
10941 if( nbdchgs !=
NULL )
10963 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10973 SCIP_CALL(
varAddTransitiveImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10983 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
11045 SCIP_CALL(
SCIPvarAddImplic(
implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11048 infeasible, nbdchgs) );
11082 SCIP_CALL(
SCIPvarAddVub(
implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11091 SCIP_CALL(
SCIPvarAddVlb(
implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11170 if( bounds ==
NULL )
11196 SCIP_Bool* infeasible,
11205 *infeasible =
FALSE;
11207 if( value ==
FALSE )
11210 *infeasible =
TRUE;
11230 if( nbdchgs !=
NULL )
11237 *infeasible =
TRUE;
11257 if( nbdchgs !=
NULL )
11285 SCIP_Bool* infeasible,
11295 *infeasible =
FALSE;
11323 SCIP_CALL(
SCIPvarFixBinary(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11324 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
11340 for(
i = 0;
i <
nvars && !(*infeasible); ++
i )
11345 SCIP_CALL(
SCIPvarFixBinary(
vars[
i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11346 eventqueue, cliquetable, !values[
i], infeasible, nbdchgs) );
11374 for( v =
nvars - 1; v >= 0; --v )
11499 SCIP_Real branchfactor
11512 branchfactor =
MAX(branchfactor,
eps);
11538 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11563 SCIP_Real branchfactor
11571 assert(branchfactor >= 0.0);
11641 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11666 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11761 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11786 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11791 if(
parentvar->data.aggregate.scalar > 0.0 )
11952 else if(
var1->index >
var2->index )
12057 for( v =
ntmpvars - 1; v > 0; --v )
12082 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12138 for( v =
ntmpvars - 1; v > 0; --v )
12207 for( v =
nvars - 1; v >= 0; --v )
12237 if(
retvar->data.original.transvar ==
NULL )
12239 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12253 if (
retvar->data.multaggr.nvars == 1 )
12293 for( v =
nvars - 1; v >= 0; --v )
12295 var = &((*vars)[v]);
12296 negated = &((*negatedarr)[v]);
12317 SCIP_Real constant = 0.0;
12335 if( (*var)->data.original.transvar ==
NULL )
12348 if ( (*var)->data.multaggr.nvars == 1 )
12350 assert( (*var)->data.multaggr.vars !=
NULL );
12351 assert( (*var)->data.multaggr.scalars !=
NULL );
12353 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1
e-06));
12363 if(
EPSEQ((*var)->data.multaggr.constant, -1.0, 1
e-06) || (
EPSEQ((*var)->data.multaggr.constant, 1.0, 1
e-06) &&
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1
e-06)) )
12365 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1
e-06));
12374 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1
e-06) )
12384 assert(
EPSZ((*var)->data.multaggr.constant, 1
e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1
e-06)
12385 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1
e-06)
12386 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1
e-06));
12388 if( !
EPSZ((*var)->data.multaggr.constant, 1
e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1
e-06) )
12394 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1
e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1
e-06));
12396 if(
EPSZ((*var)->data.multaggr.constant, 1
e-06) )
12402 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1
e-06) ?
12408 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1
e-06));
12410 constant += (*negated) !=
orignegated ? -1.0 : 1.0;
12424 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1
e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1
e-06));
12425 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1
e-06));
12427 constant += (*negated) !=
orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
12430 *
negated = ((*var)->data.aggregate.scalar > 0.0) ? *
negated : !(*negated);
12437 constant += (*negated) !=
orignegated ? -1.0 : 1.0;
12480 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
12485 if( (*var)->data.original.transvar ==
NULL )
12487 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12501 if ( (*var)->data.multaggr.nvars == 1 )
12503 assert( (*var)->data.multaggr.vars !=
NULL );
12504 assert( (*var)->data.multaggr.scalars !=
NULL );
12505 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
12507 (*bound) /= (*var)->data.multaggr.scalars[0];
12508 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
12509 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
12523 assert((*var)->data.aggregate.scalar != 0.0);
12525 (*bound) /= (*var)->data.aggregate.scalar;
12526 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12527 if( (*var)->data.aggregate.scalar < 0.0 )
12541 assert((*var)->negatedvar->negatedvar == *
var);
12542 (*bound) = (*var)->data.negate.constant - *
bound;
12573 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
12578 if( (*var)->data.original.transvar ==
NULL )
12580 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12595 assert((*var)->data.aggregate.scalar != 0.0);
12598 (*left) /= (*var)->data.aggregate.scalar;
12599 (*right) /= (*var)->data.aggregate.scalar;
12602 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12603 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12608 if( (*var)->data.aggregate.scalar < 0.0 )
12621 assert((*var)->negatedvar->negatedvar == *
var);
12624 (*left) = (*var)->data.negate.constant - (*left);
12625 (*right) = (*var)->data.negate.constant - (*right);
12651 SCIP_Real* constant
12663 if( (*var)->data.original.transvar ==
NULL )
12665 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12681 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12687 (*constant) += *scalar * (*var)->glbdom.lb;
12703 if ( (*var)->data.multaggr.nvars == 1 )
12706 assert((*var)->data.multaggr.scalars !=
NULL);
12707 assert((*var)->data.multaggr.vars[0] !=
NULL);
12717 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12730 (*constant) += *scalar * (*var)->data.multaggr.constant;
12732 (*scalar) *= (*var)->data.multaggr.scalars[0];
12743 (*constant) += *scalar * (*var)->data.aggregate.constant;
12744 (*scalar) *= (*var)->data.aggregate.scalar;
12751 assert((*var)->negatedvar->negatedvar == *
var);
12755 (*constant) += *scalar * (*var)->data.negate.constant;
12777 SCIP_Real* constant
12792 if( (*var)->nparentvars == 0 )
12798 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *
var) )
12801 *constant -= (*var)->data.negate.constant * (*scalar);
12830 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12836 *scalar /=
parentvar->data.aggregate.scalar;
12837 *constant -=
parentvar->data.aggregate.constant * (*scalar);
12845 *constant -=
parentvar->data.negate.constant * (*scalar);
12912 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12982 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
13051 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
13095 SCIP_Real lpsolval;
13285 SCIP_Real rootlpobjval
13300 SCIP_Real cutoffbound;
13464#define MAX_CLIQUELENGTH 50
13487#ifdef SCIP_MORE_DEBUG
13525 for(
c = ncliques - 1;
c >= 0; --
c )
13527 clique = cliques[
c];
13542 for( v =
nclqvars - 1; v >= 0; --v )
13552 assert(0 < probindex && probindex < nentries);
13560 if(
entries[probindex] == 0 )
13562 ids[
nids] = probindex;
13576 for( v =
nids - 1; v >= 0; --v )
13579 assert(0 <
id &&
id < nentries);
13602#ifdef SCIP_MORE_DEBUG
13628 for( v =
nvars - 1; v >= 0; --v )
13656 redcost *= (lb - bounds[v]);
13658 redcost *= (bounds[v] - lb);
13666 redcost *= (bounds[v] - ub);
13668 redcost *= (ub - bounds[v]);
13682 redcost *= (lb - bounds[v]);
13684 redcost *= (bounds[v] - lb);
13692 redcost *= (bounds[v] - ub);
13694 redcost *= (ub - bounds[v]);
13704#ifdef SCIP_MORE_DEBUG
13705 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13851 SCIP_Real rootlpobjval
13892 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13904 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14031 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
14044 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14141 *closestvlbidx = -1;
14162 *closestvlbidx =
i;
14178 *closestvlbidx =
i;
14215 *closestvubidx = -1;
14236 *closestvubidx =
i;
14252 *closestvubidx =
i;
14370#ifdef SCIP_HISTORYTOFILE
14371SCIP_Longint counter = 0
l;
14403 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
14424#ifdef SCIP_HISTORYTOFILE
14427 char filename[256];
14434 f =
fopen(filename,
"a");
14437 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
14453 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
14463 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
14941 SCIP_Real probability;
15036 if( !
set->history_valuebased )
15076 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15125 value = 1.0 - value;
15149 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15209 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
15252 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
15256 value = 1.0 - value;
15470 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
15497 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
15515 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
15519 value = 1.0 - value;
15554 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
15581 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15599 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15603 value = 1.0 - value;
15638 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15683 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15687 value = 1.0 - value;
16538 SCIP_Real oldbound,
16545 (*bdchginfo)->oldbound = oldbound;
16546 (*bdchginfo)->newbound = newbound;
16547 (*bdchginfo)->var =
var;
16548 (*bdchginfo)->inferencedata.var =
var;
16549 (*bdchginfo)->inferencedata.reason.prop =
NULL;
16550 (*bdchginfo)->inferencedata.info = 0;
16551 (*bdchginfo)->bdchgidx.depth =
INT_MAX;
16552 (*bdchginfo)->bdchgidx.pos = -1;
16553 (*bdchginfo)->pos = 0;
16555 (*bdchginfo)->boundtype = boundtype;
16556 (*bdchginfo)->inferboundtype = boundtype;
16557 (*bdchginfo)->redundant =
FALSE;
16722 switch( varstatus )
16730 if( bdchgidx ==
NULL )
16808 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16841 switch( varstatus )
16849 if( bdchgidx ==
NULL )
16928 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
17039 return bdchgidx->
depth;
17148 assert(
var1->nlbchginfos == 0 || !
var1->lbchginfos[0].redundant);
17149 assert(
var1->nubchginfos == 0 || !
var1->ubchginfos[0].redundant);
17150 assert(
var2->nlbchginfos == 0 || !
var2->lbchginfos[0].redundant);
17151 assert(
var2->nubchginfos == 0 || !
var2->ubchginfos[0].redundant);
17153 if(
var1->nlbchginfos == 1 )
17155 else if(
var1->nubchginfos == 1 )
17160 if(
var2->nlbchginfos == 1 )
17162 else if(
var2->nubchginfos == 1 )
17198#undef SCIPboundchgGetNewbound
17199#undef SCIPboundchgGetVar
17200#undef SCIPboundchgGetBoundchgtype
17201#undef SCIPboundchgGetBoundtype
17202#undef SCIPboundchgIsRedundant
17203#undef SCIPdomchgGetNBoundchgs
17204#undef SCIPdomchgGetBoundchg
17205#undef SCIPholelistGetLeft
17206#undef SCIPholelistGetRight
17207#undef SCIPholelistGetNext
17208#undef SCIPvarGetName
17209#undef SCIPvarGetNUses
17210#undef SCIPvarGetData
17211#undef SCIPvarSetData
17212#undef SCIPvarSetDelorigData
17213#undef SCIPvarSetTransData
17214#undef SCIPvarSetDeltransData
17215#undef SCIPvarGetStatus
17216#undef SCIPvarIsOriginal
17217#undef SCIPvarIsTransformed
17218#undef SCIPvarIsNegated
17219#undef SCIPvarGetType
17220#undef SCIPvarIsBinary
17221#undef SCIPvarIsIntegral
17222#undef SCIPvarIsInitial
17223#undef SCIPvarIsRemovable
17224#undef SCIPvarIsDeleted
17225#undef SCIPvarIsDeletable
17226#undef SCIPvarMarkDeletable
17227#undef SCIPvarMarkNotDeletable
17228#undef SCIPvarIsActive
17229#undef SCIPvarGetIndex
17230#undef SCIPvarGetProbindex
17231#undef SCIPvarGetTransVar
17232#undef SCIPvarGetCol
17233#undef SCIPvarIsInLP
17234#undef SCIPvarGetAggrVar
17235#undef SCIPvarGetAggrScalar
17236#undef SCIPvarGetAggrConstant
17237#undef SCIPvarGetMultaggrNVars
17238#undef SCIPvarGetMultaggrVars
17239#undef SCIPvarGetMultaggrScalars
17240#undef SCIPvarGetMultaggrConstant
17241#undef SCIPvarGetNegatedVar
17242#undef SCIPvarGetNegationVar
17243#undef SCIPvarGetNegationConstant
17244#undef SCIPvarGetObj
17245#undef SCIPvarGetLbOriginal
17246#undef SCIPvarGetUbOriginal
17247#undef SCIPvarGetHolelistOriginal
17248#undef SCIPvarGetLbGlobal
17249#undef SCIPvarGetUbGlobal
17250#undef SCIPvarGetHolelistGlobal
17251#undef SCIPvarGetBestBoundGlobal
17252#undef SCIPvarGetWorstBoundGlobal
17253#undef SCIPvarGetLbLocal
17254#undef SCIPvarGetUbLocal
17255#undef SCIPvarGetHolelistLocal
17256#undef SCIPvarGetBestBoundLocal
17257#undef SCIPvarGetWorstBoundLocal
17258#undef SCIPvarGetBestBoundType
17259#undef SCIPvarGetWorstBoundType
17260#undef SCIPvarGetLbLazy
17261#undef SCIPvarGetUbLazy
17262#undef SCIPvarGetBranchFactor
17263#undef SCIPvarGetBranchPriority
17264#undef SCIPvarGetBranchDirection
17265#undef SCIPvarGetNVlbs
17266#undef SCIPvarGetVlbVars
17267#undef SCIPvarGetVlbCoefs
17268#undef SCIPvarGetVlbConstants
17269#undef SCIPvarGetNVubs
17270#undef SCIPvarGetVubVars
17271#undef SCIPvarGetVubCoefs
17272#undef SCIPvarGetVubConstants
17273#undef SCIPvarGetNImpls
17274#undef SCIPvarGetImplVars
17275#undef SCIPvarGetImplTypes
17276#undef SCIPvarGetImplBounds
17277#undef SCIPvarGetImplIds
17278#undef SCIPvarGetNCliques
17279#undef SCIPvarGetCliques
17280#undef SCIPvarGetLPSol
17281#undef SCIPvarGetNLPSol
17282#undef SCIPvarGetBdchgInfoLb
17283#undef SCIPvarGetNBdchgInfosLb
17284#undef SCIPvarGetBdchgInfoUb
17285#undef SCIPvarGetNBdchgInfosUb
17286#undef SCIPvarGetValuehistory
17287#undef SCIPvarGetPseudoSol
17288#undef SCIPvarCatchEvent
17289#undef SCIPvarDropEvent
17290#undef SCIPvarGetVSIDS
17291#undef SCIPvarGetCliqueComponentIdx
17292#undef SCIPvarIsRelaxationOnly
17293#undef SCIPvarMarkRelaxationOnly
17294#undef SCIPbdchgidxGetPos
17295#undef SCIPbdchgidxIsEarlierNonNull
17296#undef SCIPbdchgidxIsEarlier
17297#undef SCIPbdchginfoGetOldbound
17298#undef SCIPbdchginfoGetNewbound
17299#undef SCIPbdchginfoGetVar
17300#undef SCIPbdchginfoGetChgtype
17301#undef SCIPbdchginfoGetBoundtype
17302#undef SCIPbdchginfoGetDepth
17303#undef SCIPbdchginfoGetPos
17304#undef SCIPbdchginfoGetIdx
17305#undef SCIPbdchginfoGetInferVar
17306#undef SCIPbdchginfoGetInferCons
17307#undef SCIPbdchginfoGetInferProp
17308#undef SCIPbdchginfoGetInferInfo
17309#undef SCIPbdchginfoGetInferBoundtype
17310#undef SCIPbdchginfoIsRedundant
17311#undef SCIPbdchginfoHasInferenceReason
17312#undef SCIPbdchginfoIsTighter
17412 return holelist->
next;
17524 SCIP_Bool removable
17954 SCIP_Real
mult = 1.0;
17976 if (
probvar->data.multaggr.nvars == 1 )
17992 for( v =
probvar->data.multaggr.nvars - 1; v >= 0; --v )
18577 eventtype,
var->
name, (
void*)eventhdlr, (
void*)eventdata);
18616 return bdchgidx->
pos;
18760 return bdchginfo->inferencedata.reason.cons;
18771 return bdchginfo->inferencedata.reason.prop;
static GRAPHNODE ** active
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
internal methods for constraints and constraint handlers
#define SCIPdebugCheckLbGlobal(scip, var, lb)
#define SCIPdebugCheckImplic(set, var, varfixing, implvar, impltype, implbound)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
#define SCIPdebugCheckVbound(set, var, vbtype, vbvar, vbcoef, vbconstant)
#define SCIPdebugCheckAggregation(set, var, aggrvars, scalars, constant, naggrvars)
#define SCIP_DEFAULT_INFINITY
#define SCIP_CALL_ABORT(x)
SCIP_RETCODE SCIPeventCreateLbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateVarFixed(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateUbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateVarUnlocked(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateObjChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)
SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPeventCreateGholeAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)
SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPeventCreateImplAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPeventCreateGubChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateGlbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateTypeChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_VARTYPE oldtype, SCIP_VARTYPE newtype)
internal methods for managing events
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
void SCIPvarSetTransData(SCIP_VAR *var,)
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
void SCIPvarSetDelorigData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
void SCIPvarMarkDeletable(SCIP_VAR *var)
void SCIPvarGetImplicVarBounds(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Real *lb, SCIP_Real *ub)
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
int SCIPvarGetNUses(SCIP_VAR *var)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
void SCIPvarSetDeltransData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
int SCIPvarGetBranchPriority(SCIP_VAR *var)
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
int SCIPvarGetNLocksUp(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
void SCIPvarSetCopyData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
SCIP_Real SCIPnormalCDF(SCIP_Real mean, SCIP_Real variance, SCIP_Real value)
SCIP_Real SCIPcomputeTwoSampleTTestValue(SCIP_Real meanx, SCIP_Real meany, SCIP_Real variancex, SCIP_Real variancey, SCIP_Real countx, SCIP_Real county)
SCIP_Real SCIPstudentTGetCriticalValue(SCIP_CONFIDENCELEVEL clevel, int df)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
SCIP_RETCODE SCIPvaluehistoryCreate(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvaluehistoryFind(SCIP_VALUEHISTORY *valuehistory, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real value, SCIP_HISTORY **history)
void SCIPvaluehistoryFree(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
void SCIPvaluehistoryScaleVSIDS(SCIP_VALUEHISTORY *valuehistory, SCIP_Real scalar)
assert(minobj< SCIPgetCutoffbound(scip))
void SCIPhistoryReset(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPhistoryGetNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistorySetLastGMIeff(SCIP_HISTORY *history, SCIP_Real gmieff)
void SCIPhistoryIncInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)
void SCIPhistoryIncNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real length)
void SCIPhistoryScaleVSIDS(SCIP_HISTORY *history, SCIP_Real scalar)
void SCIPhistoryIncCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
void SCIPhistoryIncNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, int depth)
void SCIPhistoryUpdatePseudocost(SCIP_HISTORY *history, SCIP_SET *set, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgBranchdepth(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetLastGMIeff(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetAvgGMIeff(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistoryUnite(SCIP_HISTORY *history, SCIP_HISTORY *addhistory, SCIP_Bool switcheddirs)
void SCIPhistoryIncGMIeffSum(SCIP_HISTORY *history, SCIP_Real gmieff)
SCIP_BRANCHDIR SCIPbranchdirOpposite(SCIP_BRANCHDIR dir)
void SCIPhistoryIncVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
internal methods for branching and inference history
SCIP_VAR ** SCIPimplicsGetVars(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
void SCIPcliqueDelVar(SCIP_CLIQUE *clique, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool value)
void SCIPcliquelistRemoveFromCliques(SCIP_CLIQUELIST *cliquelist, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool irrelevantvar)
void SCIPvboundsFree(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem)
SCIP_Real * SCIPvboundsGetCoefs(SCIP_VBOUNDS *vbounds)
void SCIPvboundsShrink(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, int newnvbds)
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
SCIP_CLIQUE ** SCIPcliquelistGetCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_Bool SCIPcliquelistsHaveCommonClique(SCIP_CLIQUELIST *cliquelist1, SCIP_Bool value1, SCIP_CLIQUELIST *cliquelist2, SCIP_Bool value2)
SCIP_Real * SCIPimplicsGetBounds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
void SCIPcliquelistCheck(SCIP_CLIQUELIST *cliquelist, SCIP_VAR *var)
SCIP_VAR ** SCIPvboundsGetVars(SCIP_VBOUNDS *vbounds)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPvboundsDel(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_VAR *vbdvar, SCIP_Bool negativecoef)
SCIP_RETCODE SCIPcliquetableAdd(SCIP_CLIQUETABLE *cliquetable, 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_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
int * SCIPimplicsGetIds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_RETCODE SCIPimplicsAdd(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool isshortcut, SCIP_Bool *conflict, SCIP_Bool *added)
SCIP_RETCODE SCIPvboundsAdd(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BOUNDTYPE vboundtype, SCIP_VAR *var, SCIP_Real coef, SCIP_Real constant, SCIP_Bool *added)
void SCIPcliquelistFree(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem)
int SCIPimplicsGetNImpls(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_RETCODE SCIPcliqueAddVar(SCIP_CLIQUE *clique, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Bool value, SCIP_Bool *doubleentry, SCIP_Bool *oppositeentry)
SCIP_BOUNDTYPE * SCIPimplicsGetTypes(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
int SCIPcliquelistGetNCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_RETCODE SCIPcliquelistDel(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_Bool SCIPcliqueIsCleanedUp(SCIP_CLIQUE *clique)
void SCIPimplicsGetVarImplicPoss(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, int *lowerimplicpos, int *upperimplicpos)
SCIP_RETCODE SCIPimplicsDel(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_Real * SCIPvboundsGetConstants(SCIP_VBOUNDS *vbounds)
int SCIPvboundsGetNVbds(SCIP_VBOUNDS *vbounds)
SCIP_Bool SCIPimplicsContainsImpl(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
void SCIPimplicsFree(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPcliquelistAdd(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
methods for implications, variable bounds, and cliques
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
void SCIPlpDecNLoosevars(SCIP_LP *lp)
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
SCIP_RETCODE SCIProwIncCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real incval)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPcolCreate(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, int len, SCIP_ROW **rows, SCIP_Real *vals, SCIP_Bool removable)
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static const SCIP_Real scalars[]
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
internal methods for LP management
#define BMSreallocBlockMemorySize(mem, ptr, oldsize, newsize)
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSfreeBlockMemorySize(mem, ptr, size)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSallocBlockMemorySize(mem, ptr, size)
struct BMS_BlkMem BMS_BLKMEM
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_RETCODE SCIPprimalUpdateObjoffset(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
internal methods for collecting primal CIP solutions and primal informations
void SCIPprobUpdateNObjVars(SCIP_PROB *prob, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
int SCIPprobGetNContVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobAddVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var)
SCIP_RETCODE SCIPprobVarChangedStatus(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
const char * SCIPprobGetName(SCIP_PROB *prob)
void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
internal methods for storing and manipulating the main problem
public methods for managing constraints
public methods for branching and inference history structure
public methods for implications, variable bounds, and cliques
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 propagators
public methods for problem variables
void SCIPrelaxationSolObjAdd(SCIP_RELAXATION *relaxation, SCIP_Real val)
internal methods for relaxators
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
SCIP_Real SCIPsetCeil(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 SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
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 SCIPsetIsDualfeasPositive(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)
SCIP_Real SCIPsetGetHugeValue(SCIP_SET *set)
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetFreeCleanBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define SCIPsetAllocCleanBufferArray(set, ptr, num)
#define SCIPsetDuplicateBufferArray(set, ptr, source, num)
#define SCIPsetReallocBufferArray(set, ptr, num)
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
internal methods for storing primal CIP solutions
SCIP_RETCODE SCIPstatUpdateVarRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldrootpscostscore)
internal methods for problem statistics
#define SCIPstatIncrement(stat, set, field)
SCIP_INFERENCEDATA inferencedata
unsigned int boundchgtype
unsigned int inferboundtype
SCIP_BOUNDCHG * boundchgs
SCIP_BOUNDCHG * boundchgs
SCIP_HISTORY * glbhistory
SCIP_BRANCHDIR lastbranchdir
SCIP_Bool collectvarhistory
SCIP_HISTORY * glbhistorycrun
SCIP_Real lastbranchvalue
SCIP_EVENTFILTER * eventfilter
SCIP_BDCHGINFO * lbchginfos
int nlocksdown[NLOCKTYPES]
SCIP_HISTORY * historycrun
unsigned int relaxationonly
unsigned int donotmultaggr
SCIP_BDCHGINFO * ubchginfos
SCIP_Real bestrootredcost
SCIP_CLIQUELIST * cliquelist
unsigned int branchdirection
unsigned int delglobalstructs
SCIP_Longint closestvblpcount
SCIP_Real bestrootlpobjval
SCIP_VALUEHISTORY * valuehistory
datastructures for managing events
data structures for LP management
datastructures for storing and manipulating the main problem
SCIP main data structure.
datastructures for global SCIP settings
datastructures for problem statistics
datastructures for problem variables
SCIP_NODE * SCIPtreeGetRootNode(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)
internal methods for branch and bound tree
#define SCIP_EVENTTYPE_GHOLEADDED
#define SCIP_EVENTTYPE_GUBCHANGED
struct SCIP_EventData SCIP_EVENTDATA
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_VARCHANGED
#define SCIP_EVENTTYPE_LBCHANGED
#define SCIP_EVENTTYPE_UBCHANGED
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BranchDir SCIP_BRANCHDIR
enum SCIP_BoundType SCIP_BOUNDTYPE
enum SCIP_BaseStat SCIP_BASESTAT
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_HASHKEYEQ(x)
#define SCIP_DECL_HASHGETKEY(x)
#define SCIP_DECL_HASHKEYVAL(x)
@ SCIP_CONFIDENCELEVEL_MAX
@ SCIP_CONFIDENCELEVEL_MEDIUM
@ SCIP_CONFIDENCELEVEL_HIGH
@ SCIP_CONFIDENCELEVEL_MIN
@ SCIP_CONFIDENCELEVEL_LOW
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
enum SCIP_Objsense SCIP_OBJSENSE
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
struct SCIP_VarData SCIP_VARDATA
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
#define SCIP_DECL_VARDELORIG(x)
@ SCIP_DOMCHGTYPE_DYNAMIC
#define SCIP_DECL_VARTRANS(x)
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_PROPINFER
@ SCIP_BOUNDCHGTYPE_BRANCHING
@ SCIP_BOUNDCHGTYPE_CONSINFER
@ SCIP_VARSTATUS_ORIGINAL
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
#define SCIP_DECL_VARCOPY(x)
#define SCIP_DECL_VARDELTRANS(x)
enum SCIP_LockType SCIP_LOCKTYPE
enum SCIP_Vartype SCIP_VARTYPE
enum SCIP_Varstatus SCIP_VARSTATUS
SCIP_DOMCHGBOUND domchgbound
SCIP_DOMCHGBOTH domchgboth
SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final)
static SCIP_RETCODE varParse(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *str, char *name, SCIP_Real *lb, SCIP_Real *ub, SCIP_Real *obj, SCIP_VARTYPE *vartype, SCIP_Real *lazylb, SCIP_Real *lazyub, SCIP_Bool local, char **endptr, SCIP_Bool *success)
SCIP_RETCODE SCIPvarAddObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_Real addobj)
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
static SCIP_RETCODE tryAggregateIntVars(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
SCIP_RETCODE SCIPvarIncNBranchings(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, int depth)
static SCIP_RETCODE varEventGlbChanged(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldbound, SCIP_Real newbound)
static SCIP_RETCODE varEnsureUbchginfosSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
static SCIP_RETCODE domchgEnsureBoundchgsSize(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_RETCODE SCIPvarCreateTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
static SCIP_RETCODE varProcessChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
static SCIP_RETCODE domAddHole(SCIP_DOM *dom, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)
static SCIP_RETCODE varProcessChgBranchPriority(SCIP_VAR *var, int branchpriority)
static SCIP_RETCODE parseValue(SCIP_SET *set, const char *str, SCIP_Real *value, char **endptr)
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
static SCIP_RETCODE boundchgApplyGlobal(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
static SCIP_RETCODE varCreate(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata)
SCIP_RETCODE SCIPvarSetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
SCIP_RETCODE SCIPvarFix(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
static SCIP_RETCODE varAddImplic(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool isshortcut, SCIP_Bool *infeasible, int *nbdchgs, SCIP_Bool *added)
void SCIPvarInitSolve(SCIP_VAR *var)
SCIP_RETCODE SCIPvarIncInferenceSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
static void printBounds(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Real lb, SCIP_Real ub, const char *name)
SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
static SCIP_RETCODE varProcessChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
static SCIP_RETCODE varAddLbchginfo(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real oldbound, SCIP_Real newbound, int depth, int pos, SCIP_VAR *infervar, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BOUNDCHGTYPE boundchgtype)
SCIP_RETCODE SCIPdomchgUndo(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
static SCIP_RETCODE varProcessAddHoleLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPboundchgApply(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, int pos, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static void checkImplic(SCIP_SET *set, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *redundant, SCIP_Bool *infeasible)
static SCIP_VAR * varGetActiveVar(SCIP_VAR *var)
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
SCIP_RETCODE SCIPvarAddHoleOriginal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
SCIP_RETCODE SCIPvarAddCliqueToList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
static SCIP_RETCODE varEventObjChanged(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldobj, SCIP_Real newobj)
static SCIP_RETCODE varFree(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPvarAddHoleGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
static SCIP_RETCODE varEventImplAdded(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
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_RETCODE SCIPvarDropEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)
SCIP_RETCODE SCIPvarCopy(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP *sourcescip, SCIP_VAR *sourcevar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
static SCIP_BDCHGIDX presolvebdchgidx
static SCIP_RETCODE varEventLbChanged(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
SCIP_RETCODE SCIPvarAddToRow(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
static SCIP_RETCODE varEventUbChanged(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
SCIP_Real SCIPvarGetAvgGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
static SCIP_RETCODE varEventVarFixed(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, int fixeventtype)
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
static SCIP_RETCODE varUpdateAggregationBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_Bool SCIPvarSignificantPscostDifference(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
void SCIPvarCapture(SCIP_VAR *var)
static SCIP_RETCODE varEventGubChanged(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
static SCIP_Real adjustedLb(SCIP_SET *set, SCIP_VARTYPE vartype, SCIP_Real lb)
SCIP_RETCODE SCIPdomchgAddHolechg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST **ptr, SCIP_HOLELIST *newlist, SCIP_HOLELIST *oldlist)
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
static SCIP_RETCODE domchgEnsureHolechgsSize(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
static SCIP_RETCODE varEnsureLbchginfosSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Bool SCIPvarDoNotAggr(SCIP_VAR *var)
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_VARTYPE vartype)
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_Longint SCIPvarGetNActiveConflicts(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
SCIP_RETCODE SCIPvarCreateOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetVSIDS_rec(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarChgBdLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
SCIP_RETCODE SCIPvarFixBinary(SCIP_VAR *var, 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 value, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
static SCIP_RETCODE findValuehistoryEntry(SCIP_VAR *var, SCIP_Real value, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HISTORY **history)
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
static SCIP_RETCODE varProcessChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
static SCIP_RETCODE varEnsureParentvarsSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_RETCODE SCIPvarGetActiveRepresentatives(SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize, SCIP_Bool mergemultiples)
SCIP_RETCODE SCIPvarParseTransformed(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPvarColumn(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
static void domMerge(SCIP_DOM *dom, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real *newlb, SCIP_Real *newub)
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
static SCIP_RETCODE varEventVarUnlocked(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazyub)
static SCIP_RETCODE varAddVbound(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_BOUNDTYPE vbtype, SCIP_VAR *vbvar, SCIP_Real vbcoef, SCIP_Real vbconstant)
SCIP_Bool SCIPvarPscostThresholdProbabilityTest(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
SCIP_RETCODE SCIPdomchgApplyGlobal(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPvarTryAggregateVars(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
SCIP_RETCODE SCIPboundchgUndo(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
void SCIPvarMarkDeleted(SCIP_VAR *var)
static SCIP_RETCODE varSetName(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_STAT *stat, const char *name)
void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)
static SCIP_RETCODE varEventGholeAdded(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right)
static void printHolelist(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_HOLELIST *holelist, const char *name)
static SCIP_RETCODE varAddUbchginfo(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real oldbound, SCIP_Real newbound, int depth, int pos, SCIP_VAR *infervar, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BOUNDCHGTYPE boundchgtype)
SCIP_RETCODE SCIPvarCatchEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPvarAddHoleLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(SCIP_VAR *var)
SCIP_RETCODE SCIPdomchgApply(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, int depth, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPvarDelClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPvarAggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
SCIP_Real SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPvarDelCliqueFromList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
SCIP_RETCODE SCIPvarChgBdGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype)
static SCIP_Bool useValuehistory(SCIP_VAR *var, SCIP_Real value, SCIP_SET *set)
static SCIP_Real adjustedUb(SCIP_SET *set, SCIP_VARTYPE vartype, SCIP_Real ub)
SCIP_RETCODE SCIPvarAddImplic(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPvarsAddClique(SCIP_VAR **vars, SCIP_Bool *values, int nvars, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPvarMarkDoNotAggr(SCIP_VAR *var)
static SCIP_RETCODE varProcessChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
SCIP_RETCODE SCIPdomchgAddBoundchg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_BOUNDCHGTYPE boundchgtype, SCIP_Real lpsolval, SCIP_VAR *infervar, SCIP_CONS *infercons, SCIP_PROP *inferprop, int inferinfo, SCIP_BOUNDTYPE inferboundtype)
SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
static SCIP_RETCODE varFreeParents(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_BDCHGIDX initbdchgidx
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
static SCIP_RETCODE domchgCreate(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
static SCIP_RETCODE holelistCreate(SCIP_HOLELIST **holelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LOCKTYPE locktype, int addnlocksdown, int addnlocksup)
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
static SCIP_RETCODE varAddTransitiveImplic(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_RETCODE SCIPvarIncGMIeffSum(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real gmieff)
static void holelistFree(SCIP_HOLELIST **holelist, BMS_BLKMEM *blkmem)
static SCIP_RETCODE varProcessChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
static SCIP_RETCODE applyImplic(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 *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPvarGetLastGMIScore(SCIP_VAR *var, SCIP_STAT *stat)
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
static SCIP_Real getImplVarRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
SCIP_RETCODE SCIPvarMultiaggregate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
static SCIP_Real SCIPvarGetPseudoSol_rec(SCIP_VAR *var)
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
static SCIP_RETCODE domchgMakeDynamic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvarAddVlb(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_RETCODE SCIPvarParseOriginal(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
static SCIP_RETCODE parseBounds(SCIP_SET *set, const char *str, char *type, SCIP_Real *lb, SCIP_Real *ub, char **endptr)
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
static void varIncRootboundchgs(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat)
void SCIPvarSetNamePointer(SCIP_VAR *var, const char *name)
static SCIP_RETCODE holelistDuplicate(SCIP_HOLELIST **target, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST *source)
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
void SCIPvarSetHistory(SCIP_VAR *var, SCIP_HISTORY *history, SCIP_STAT *stat)
static SCIP_RETCODE varProcessAddHoleGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
SCIP_RETCODE SCIPvarAddVub(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool transitive, SCIP_Bool *infeasible, int *nbdchgs)
static SCIP_RETCODE varAddParent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *parentvar)
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
static SCIP_RETCODE boundchgReleaseData(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarAddClique(SCIP_VAR *var, 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 value, SCIP_CLIQUE *clique, SCIP_Bool *infeasible, int *nbdchgs)
static SCIP_RETCODE boundchgCaptureData(SCIP_BOUNDCHG *boundchg)
static SCIP_RETCODE varProcessChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
SCIP_RETCODE SCIPvarRemoveCliquesImplicsVbs(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool irrelevantvar, SCIP_Bool onlyredundant, SCIP_Bool removefromvar)
static void varSetProbindex(SCIP_VAR *var, int probindex)
static SCIP_RETCODE varAddTransitiveBinaryClosureImplic(SCIP_VAR *var, 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_CLIQUETABLE *cliquetable, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing, SCIP_Bool *infeasible, int *nbdchgs)
internal methods for problem variables