77#define MAXIMPLSCLOSURE 100
79#define MAXABSVBCOEF 1e+5
94#ifdef DEBUGUSES_VARNAME
102void print_backtrace(
void)
109 size = backtrace(array, 10);
110 strings = backtrace_symbols(array, size);
111 if( strings ==
NULL )
115 for(
i = 1;
i < size; ++
i )
124 char* closepar =
NULL;
125#ifndef DEBUGUSES_NOADDR2LINE
126 openpar = strchr(strings[
i],
'(');
127 if( openpar !=
NULL && openpar[1] ==
'+' )
128 closepar = strchr(openpar+2,
')');
130 if( closepar !=
NULL )
133 (void)
SCIPsnprintf(cmd,
SCIP_MAXSTRLEN,
"addr2line -f -p -e \"%.*s\" %.*s", openpar - strings[
i], strings[
i], closepar-openpar-1, openpar+1);
139 printf(
" %s\n", strings[
i]);
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;
211 while( source !=
NULL )
215 source = source->
next;
216 target = &(*target)->
next;
241 while( *insertpos !=
NULL && (*insertpos)->
hole.
left < left )
242 insertpos = &(*insertpos)->
next;
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;
278 SCIP_Real* lastrightptr;
292 while( *holelistptr !=
NULL )
294 if( (*holelistptr)->next !=
NULL )
297 lastleft = (*holelistptr)->hole.left;
300 holelistptr = &(*holelistptr)->
next;
308 lastrightptr = &dom->
lb;
309 lastnextptr = holelistptr;
311 while( *holelistptr !=
NULL )
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;
348 else if(
SCIPsetIsGT(
set, *lastrightptr, (*holelistptr)->hole.left) )
358 SCIPsetDebugMsg(
set,
"lower bound <%.15g> lays in current hole; store new lower bound and remove hole\n", dom->
lb);
359 *lastrightptr =
MAX(*lastrightptr, (*holelistptr)->hole.right);
362 dom->
lb = *lastrightptr;
365 *newlb = *lastrightptr;
369 SCIPsetDebugMsg(
set,
"current hole overlaps with the previous one (...,%.15g); merge to (...,%.15g)\n",
370 *lastrightptr,
MAX(*lastrightptr, (*holelistptr)->hole.right) );
371 *lastrightptr =
MAX(*lastrightptr, (*holelistptr)->hole.right);
373 nextholelist = (*holelistptr)->
next;
378 *lastnextptr = nextholelist;
381 *holelistptr = nextholelist;
386 lastrightptr = &(*holelistptr)->hole.right;
387 lastnextptr = &(*holelistptr)->
next;
390 holelistptr = &(*holelistptr)->
next;
402 while( *holelistptr !=
NULL )
409 lastright = (*holelistptr)->hole.right;
412 holelistptr = &(*holelistptr)->
next;
446 assert(num <= var->lbchginfossize);
472 assert(num <= var->ubchginfossize);
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, 1e-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 )
1268 assert(num <= domchg->domchgdyn.boundchgssize);
1293 assert(num <= domchg->domchgdyn.holechgssize);
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 )
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++;
1614 SCIP_Bool irrelevantvar,
1615 SCIP_Bool onlyredundant,
1616 SCIP_Bool removefromvar
1630 onlyredundant ?
"redundant" :
"all", irrelevantvar ?
"irrelevant " :
"",
SCIPvarGetName(
var), lb, ub);
1633 if(
var->
implics !=
NULL && (!onlyredundant || lb > 0.5 || ub < 0.5) )
1635 SCIP_Bool varfixing;
1651 for(
i = 0;
i < nimpls;
i++ )
1656 implvar = implvars[
i];
1657 impltype = impltypes[
i];
1690 varfixing = !varfixing;
1692 while( varfixing ==
TRUE );
1706 SCIP_Real* constants;
1721 for(
i = 0;
i < nvbds;
i++ )
1747 vars[newnvbds] = implvar;
1748 coefs[newnvbds] = coef;
1749 constants[newnvbds] = constants[
i];
1764 if( coef > 0.0 && implvar->
vubs !=
NULL )
1766 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1772 else if( coef < 0.0 && implvar->vlbs !=
NULL )
1774 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1800 SCIP_Real* constants;
1815 for(
i = 0;
i < nvbds;
i++ )
1841 vars[newnvbds] = implvar;
1842 coefs[newnvbds] = coefs[
i];
1843 constants[newnvbds] = constants[
i];
1858 if( coef < 0.0 && implvar->vubs !=
NULL )
1860 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1866 else if( coef > 0.0 && implvar->
vlbs !=
NULL )
1868 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
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;
2007 (*var)->varcopy = varcopy;
2008 (*var)->vardelorig = vardelorig;
2009 (*var)->vartrans = vartrans;
2010 (*var)->vardeltrans = vardeltrans;
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,
2099 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
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,
2141 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2214 (*var)->donotaggr = sourcevar->
donotaggr;
2225 varmap, consmap, (*
var), &targetdata, &
result) );
2239 (*var)->varcopy = sourcevar->varcopy;
2240 (*var)->vardelorig = sourcevar->vardelorig;
2241 (*var)->vartrans = sourcevar->vartrans;
2242 (*var)->vardeltrans = sourcevar->vardeltrans;
2248 if(
set->history_allowtransfer )
2258 (*var)->varcopy = sourcevar->varcopy;
2259 (*var)->vardelorig = sourcevar->vardelorig;
2260 (*var)->vartrans = sourcevar->vartrans;
2261 (*var)->vardeltrans = sourcevar->vardeltrans;
2280 if( strncmp(str,
"+inf", 4) == 0 )
2283 (*endptr) = (
char*)str + 4;
2285 else if( strncmp(str,
"-inf", 4) == 0 )
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 ) )
2341 while ( **endptr !=
'\0' && (**endptr ==
']' || **endptr ==
',') )
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 )
2430 if ( *endptr ==
NULL )
2435 assert(strncmp(token,
"global", 6) == 0 || strncmp(token,
"original", 8) == 0);
2445 for(
i = 0;
i < 2 && *endptr !=
NULL && **endptr !=
'\0'; ++
i )
2454 if( *endptr ==
NULL )
2457 if( strncmp(token,
"local", 5) == 0 && local )
2462 else if( strncmp(token,
"lazy", 4) == 0 )
2470 if ( *endptr ==
NULL )
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,
2535 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
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,
2598 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2607 (*var)->lazylb = lazylb;
2608 (*var)->lazyub = lazyub;
2636 assert(num <= var->parentvarssize);
2685 for(
i = 0;
i < (*var)->nparentvars; ++
i )
2705#ifdef SCIP_DISABLED_CODE
2712 if( v < parentvar->data.multaggr.nvars-1 )
2723 assert((*var)->negatedvar == parentvar);
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
2858 if( strcmp(
var->
name, DEBUGUSES_VARNAME) == 0
2859#ifdef DEBUGUSES_PROBNAME
2865 printf(
"Captured variable " DEBUGUSES_VARNAME
" in SCIP %p, now %d uses; captured at\n", (
void*)
var->
scip,
var->
nuses);
2882 assert((*var)->nuses >= 1);
2886 SCIPsetDebugMsg(
set,
"release variable <%s> with nuses=%d\n", (*var)->name, (*var)->nuses);
2889#ifdef DEBUGUSES_VARNAME
2890 if( strcmp((*var)->name, DEBUGUSES_VARNAME) == 0
2891#ifdef DEBUGUSES_PROBNAME
2892 && (((*var)->scip->transprob !=
NULL && strcmp(
SCIPprobGetName((*var)->scip->transprob), DEBUGUSES_PROBNAME) == 0) ||
2893 strcmp(
SCIPprobGetName((*var)->scip->origprob), DEBUGUSES_PROBNAME) == 0)
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");
3185 if( addnlocksdown == 0 && addnlocksup == 0 )
3189 SCIPsetDebugMsg(
set,
"add rounding locks %d/%d to variable <%s> (locks=%d/%d, type=%u)\n",
3209 lockvar->
nlocksdown[locktype] += addnlocksdown;
3210 lockvar->
nlocksup[locktype] += addnlocksup;
3220 lockvar->
nlocksdown[locktype] += addnlocksdown;
3221 lockvar->
nlocksup[locktype] += addnlocksup;
3227 && lockvar->
nlocksup[locktype] <= 1 )
3238 int tmp = addnlocksup;
3240 addnlocksup = addnlocksdown;
3241 addnlocksdown = tmp;
3252 lockvar->
nlocksdown[locktype] += addnlocksdown;
3253 lockvar->
nlocksup[locktype] += addnlocksup;
3275 int tmp = addnlocksup;
3281 addnlocksup = addnlocksdown;
3282 addnlocksdown = tmp;
3496 origvar->vardelorig, origvar->vartrans, origvar->vardeltrans, origvar->varcopy,
NULL) );
3515 (*transvar)->nlocksup[
i] = origvar->
nlocksup[
i];
3516 assert((*transvar)->nlocksdown[
i] >= 0);
3517 assert((*transvar)->nlocksup[
i] >= 0);
3521 (*transvar)->donotaggr = origvar->
donotaggr;
3525 (*transvar)->lazylb = origvar->
lazylb;
3526 (*transvar)->lazyub = origvar->
lazyub;
3534 if( origvar->vartrans !=
NULL )
3539 (*transvar)->vardata = origvar->
vardata;
3542 SCIPsetDebugMsg(
set,
"transformed variable: <%s>[%p] -> <%s>[%p]\n", origvar->
name, (
void*)origvar, (*transvar)->
name, (
void*)*transvar);
3670 assert(0 <= fixeventtype && fixeventtype <= 2);
3683 switch( fixeventtype )
3765 SCIP_Bool* infeasible,
3770 SCIP_Real childfixedval;
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,
3909 branchcand, eventfilter, eventqueue, cliquetable,
var->
data.
negate.
constant - fixedval, infeasible, fixed) );
3935 SCIP_Real* constant,
3937 SCIP_Bool mergemultiples
3941 SCIP_Real* activescalars;
3943 SCIP_Real activeconstant;
3944 SCIP_Bool activeconstantinf;
3954 SCIP_Real* tmpscalars;
3955 SCIP_Real* multscalars;
3961 SCIP_Real multscalar;
3962 SCIP_Real multconstant;
3968 SCIP_Real* tmpscalars2;
3972 SCIP_Bool sortagain =
FALSE;
3997 activeconstant = 0.0;
3998 activeconstantinf =
FALSE;
3999 activevarssize = (*nvars) * 2;
4001 tmpvarssize = *
nvars;
4016 for( v = ntmpvars - 1; v >= 0; --v )
4019 scalar = tmpscalars[v];
4040 tmpscalars[v] = scalar;
4042 noldtmpvars = ntmpvars;
4045 SCIPsortPtrReal((
void**)tmpvars, tmpscalars, SCIPvarComp, noldtmpvars);
4047 for( v = 1; v < noldtmpvars; ++v )
4052 tmpscalars[ntmpvars] += tmpscalars[v];
4059 tmpscalars[ntmpvars] = tmpscalars[v];
4060 tmpvars[ntmpvars] = tmpvars[v];
4066#ifdef SCIP_MORE_DEBUG
4067 for( v = 1; v < ntmpvars; ++v )
4072 while( ntmpvars >= 1 )
4076 var = tmpvars[ntmpvars];
4077 scalar = tmpscalars[ntmpvars];
4095 if( nactivevars >= activevarssize )
4097 activevarssize *= 2;
4100 assert(nactivevars < activevarssize);
4102 activevars[nactivevars] =
var;
4103 activescalars[nactivevars] = scalar;
4114 if( nmultvars + ntmpvars > tmpvarssize )
4116 while( nmultvars + ntmpvars > tmpvarssize )
4120 assert(nmultvars + ntmpvars <= tmpvarssize);
4123 if( nmultvars > tmpvarssize2 )
4125 while( nmultvars > tmpvarssize2 )
4129 assert(nmultvars <= tmpvarssize2);
4134 for( ; nmultvars >= 0; --nmultvars )
4136 multvar = multvars[nmultvars];
4137 multscalar = multscalars[nmultvars];
4149 if( !activeconstantinf )
4156 if( scalar * multconstant > 0.0 )
4159 activeconstantinf =
TRUE;
4164 activeconstantinf =
TRUE;
4168 activeconstant += scalar * multconstant;
4183 tmpscalars[pos] += scalar * multscalar;
4187 tmpvars2[ntmpvars2] = multvar;
4188 tmpscalars2[ntmpvars2] = scalar * multscalar;
4190 assert(ntmpvars2 <= tmpvarssize2);
4197 SCIPsortPtrReal((
void**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);
4199 for( v = 1; v < ntmpvars2; ++v )
4204 tmpscalars2[pos] += tmpscalars2[v];
4211 tmpscalars2[pos] = tmpscalars2[v];
4212 tmpvars2[pos] = tmpvars2[v];
4216 ntmpvars2 = pos + 1;
4217#ifdef SCIP_MORE_DEBUG
4218 for( v = 1; v < ntmpvars2; ++v )
4222 for( v = 1; v < ntmpvars; ++v )
4229 pos = ntmpvars + ntmpvars2 - 1;
4230 ntmpvars += ntmpvars2;
4232 while( v >= 0 && k >= 0 )
4238 tmpvars[pos] = tmpvars[v];
4239 tmpscalars[pos] = tmpscalars[v];
4244 tmpvars[pos] = tmpvars2[k];
4245 tmpscalars[pos] = tmpscalars2[k];
4254 tmpvars[pos] = tmpvars[v];
4255 tmpscalars[pos] = tmpscalars[v];
4262 tmpvars[pos] = tmpvars2[k];
4263 tmpscalars[pos] = tmpscalars2[k];
4268#ifdef SCIP_MORE_DEBUG
4269 for( v = 1; v < ntmpvars; ++v )
4275 if( !activeconstantinf )
4284 if( scalar * multconstant > 0.0 )
4287 activeconstantinf =
TRUE;
4292 activeconstantinf =
TRUE;
4296 activeconstant += scalar * multconstant;
4323 if( mergemultiples )
4328 SCIPsortPtrReal((
void**)activevars, activescalars, SCIPvarComp, nactivevars);
4331 v = nactivevars - 1;
4337 if( activescalars[v - 1] + activescalars[v] != 0.0 )
4339 activescalars[v - 1] += activescalars[v];
4341 activevars[v] = activevars[nactivevars];
4342 activescalars[v] = activescalars[nactivevars];
4347 activevars[v] = activevars[nactivevars];
4348 activescalars[v] = activescalars[nactivevars];
4351 activevars[v] = activevars[nactivevars];
4352 activescalars[v] = activescalars[nactivevars];
4364 SCIP_Real tmpscalar;
4366 for( v = 0; v < nactivevars / 2; ++v )
4368 tmpvar = activevars[v];
4369 tmpscalar = activescalars[v];
4370 activevars[v] = activevars[nactivevars - 1 - v];
4371 activescalars[v] = activescalars[nactivevars - 1 - v];
4372 activevars[nactivevars - 1 - v] = tmpvar;
4373 activescalars[nactivevars - 1 - v] = tmpscalar;
4377 *requiredsize = nactivevars;
4379 if( varssize >= *requiredsize )
4383 *
nvars = *requiredsize;
4388 if( activeconstantinf )
4389 (*constant) = activeconstant;
4391 (*constant) += activeconstant;
4402 for( v = 0; v < *
nvars; ++v )
4404 vars[v] = activevars[v];
4405 scalars[v] = activescalars[v];
4433 SCIP_Real multconstant;
4436 int multrequiredsize;
4477 if( multrequiredsize > multvarssize )
4481 multvarssize = multrequiredsize;
4483 assert( multrequiredsize <= multvarssize );
4568 SCIP_Bool* infeasible,
4576 SCIP_Bool aggvarbdschanged;
4585 *infeasible =
FALSE;
4595 aggvarbdschanged =
FALSE;
4603 varlb = aggvar->
glbdom.
lb * scalar + constant;
4607 varub = aggvar->
glbdom.
ub * scalar + constant;
4614 varub = aggvar->
glbdom.
lb * scalar + constant;
4618 varlb = aggvar->
glbdom.
ub * scalar + constant;
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) );
4643 assert(*fixed == 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) );
4708 assert(*fixed == varfixed);
4732 while( aggvarbdschanged );
4759 SCIP_Bool* infeasible,
4760 SCIP_Bool* aggregated
4765 SCIP_Real* constants;
4767 SCIP_Real branchfactor;
4786 *infeasible =
FALSE;
4787 *aggregated =
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 )
4842 *aggregated = 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 )
4952 SCIP_Real* implbounds;
4960 for( j = 0; j < nimpls && !(*infeasible); ++j )
4965 SCIP_CALL(
SCIPvarAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
4966 branchcand, eventqueue, (SCIP_Bool)
i, implvars[j], impltypes[j], implbounds[j],
FALSE, infeasible,
5032 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5041 if( *infeasible || *aggregated )
5073 SCIP_Bool* infeasible,
5074 SCIP_Bool* aggregated
5079 SCIP_Longint scalarxn = 0;
5080 SCIP_Longint scalarxd = 0;
5081 SCIP_Longint scalaryn = 0;
5082 SCIP_Longint scalaryd = 0;
5088 SCIP_Longint currentclass;
5089 SCIP_Longint classstep;
5095#define MAXDNOM 1000000LL
5120 *infeasible =
FALSE;
5121 *aggregated =
FALSE;
5141 a = (scm/scalarxd)*scalarxn;
5142 b = (scm/scalaryd)*scalaryn;
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) );
5215 currentclass =
c %
a;
5216 if( currentclass < 0 )
5218 assert(0 <= currentclass && currentclass <
a);
5220 classstep = (-
b) %
a;
5224 assert(0 <= classstep && classstep <
a);
5226 while( currentclass != 0 )
5228 assert(0 <= currentclass && currentclass <
a);
5229 currentclass += classstep;
5230 if( currentclass >=
a )
5237 xsol = (
c -
b*ysol)/
a;
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) );
5264 assert(*aggregated || *infeasible);
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) );
5270 assert(*aggregated || *infeasible);
5311 SCIP_Bool* infeasible,
5312 SCIP_Bool* aggregated
5338 *infeasible =
FALSE;
5339 *aggregated =
FALSE;
5409 scalar = -scalary/scalarx;
5410 constant = rhs/scalarx;
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,
5439 branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
5465 SCIP_Bool* infeasible,
5466 SCIP_Bool* aggregated
5470 SCIP_Real* tmpscalars;
5472 SCIP_Real branchfactor;
5478 SCIP_Real tmpconstant;
5479 SCIP_Real tmpscalar;
5482 int tmprequiredsize;
5496 *infeasible =
FALSE;
5497 *aggregated =
FALSE;
5504 SCIPerrorMessage(
"cannot multi-aggregate an untransformed original variable\n");
5508 reopt, lp, cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars, constant, infeasible, aggregated) );
5515 ntmpvars = naggvars;
5516 tmpvarssize = naggvars;
5517 tmpconstant = constant;
5523 if( tmprequiredsize > tmpvarssize )
5527 tmpvarssize = tmprequiredsize;
5529 assert( tmprequiredsize <= tmpvarssize );
5537 for( v = ntmpvars - 1; v >= 0; --v )
5542 if( tmpvars[v]->index ==
var->
index )
5544 tmpscalar += tmpscalars[v];
5545 tmpvars[v] = tmpvars[ntmpvars - 1];
5546 tmpscalars[v] = tmpscalars[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");
5568 else if( ntmpvars == 1 )
5570 assert(tmpscalars[0] != 0.0);
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) );
5578 else if( ntmpvars == 2 )
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],
5586 tmpscalars[1], -tmpconstant, infeasible, aggregated) );
5599 tmpscalar = 1 - tmpscalar;
5600 tmpconstant /= tmpscalar;
5601 for( v = ntmpvars - 1; v >= 0; --v )
5602 tmpscalars[v] /= tmpscalar;
5609 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5610 eventfilter, eventqueue, cliquetable, tmpconstant, infeasible, aggregated) );
5617 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5621 cliquetable, branchcand, eventfilter, eventqueue,
var, tmpvars[0], 1.0, -tmpscalars[0], tmpconstant,
5622 infeasible, aggregated) );
5693 for( v = 0; v < ntmpvars; ++v )
5697 branchfactor =
MAX(tmpvars[v]->branchfactor, branchfactor);
5698 branchpriority =
MAX(tmpvars[v]->branchpriority, branchpriority);
5703 for( v = 0; v < ntmpvars; ++v )
5709 if( tmpscalars[v] >= 0.0 )
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");
5770 for( v = 0; v < naggvars; ++v )
5774 SCIP_CALL(
SCIPvarMultiaggregate(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5775 cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars,
5779 for( v = 0; v < naggvars; ++v )
5789 if( *infeasible || *aggregated )
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;
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");
6373 reopt, lp, eventfilter, eventqueue, (SCIP_Real) transprob->
objsense * addobj/transprob->
objscale) );
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");
6961 SCIP_Real parentnewbound;
6971 parentnewbound = newbound;
6976 SCIP_Real parentnewbound;
6987 parentnewbound = -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");
7136 SCIP_Real parentnewbound;
7145 parentnewbound = newbound;
7150 SCIP_Real parentnewbound;
7160 parentnewbound = -newbound;
7240 cliquetable, newbound) );
7270 SCIP_Real childnewbound;
7279 childnewbound = newbound;
7285 SCIP_Real childnewbound;
7294 childnewbound = -newbound;
7306 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7413 SCIP_Real childnewbound;
7422 childnewbound = newbound;
7428 SCIP_Real childnewbound;
7437 childnewbound = -newbound;
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");
7730 SCIP_Real parentnewbound;
7744 if( parentnewbound > parentvar->
glbdom.
ub )
7748 parentnewbound = parentvar->
glbdom.
ub;
7752 parentnewbound = newbound;
7757 SCIP_Real parentnewbound;
7772 if( parentnewbound < parentvar->glbdom.lb )
7776 parentnewbound = parentvar->
glbdom.
lb;
7780 parentnewbound = -newbound;
7890 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7897 SCIP_Real parentnewbound;
7910 if( parentnewbound < parentvar->glbdom.lb )
7914 parentnewbound = parentvar->
glbdom.
lb;
7918 parentnewbound = newbound;
7923 SCIP_Real parentnewbound;
7937 if( parentnewbound > parentvar->
glbdom.
ub )
7941 parentnewbound = parentvar->
glbdom.
ub;
7945 parentnewbound = -newbound;
8039 SCIP_Real childnewbound;
8048 childnewbound = newbound;
8054 SCIP_Real childnewbound;
8063 childnewbound = -newbound;
8075 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8165 SCIP_Real childnewbound;
8174 childnewbound = newbound;
8180 SCIP_Real childnewbound;
8189 childnewbound = -newbound;
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");
8292 SCIP_Real childnewbound;
8298 childnewbound = newbound;
8303 SCIP_Real childnewbound;
8309 childnewbound = -newbound;
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");
8382 SCIP_Real childnewbound;
8388 childnewbound = newbound;
8393 SCIP_Real childnewbound;
8399 childnewbound = -newbound;
8410 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8806 SCIP_Real parentnewleft;
8807 SCIP_Real parentnewright;
8808 SCIP_Bool localadded;
8816 parentnewleft = left;
8817 parentnewright = right;
8824 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8866 parentnewleft, parentnewright, &localadded) );
8885 SCIP_Real childnewleft;
8886 SCIP_Real childnewright;
8913 left, right, added) );
8922 SCIP_Bool localadded;
8934 SCIP_Bool localadded;
8964 childnewleft, childnewright, added) );
8980 childnewleft, childnewright, added) );
9042#ifdef SCIP_DISABLED_CODE
9053 SCIP_Real parentnewleft;
9054 SCIP_Real parentnewright;
9055 SCIP_Bool localadded;
9063 parentnewleft = left;
9064 parentnewright = right;
9071 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
9113 parentnewleft, parentnewright, &localadded) );
9132 SCIP_Real childnewleft;
9133 SCIP_Real childnewright;
9163 left, right, added) );
9203 childnewleft, childnewright, added) );
9207 SCIPerrorMessage(
"cannot add domain hole to a multi-aggregated variable.\n");
9291 SCIP_Real vbconstant
9385 SCIP_Real implbound,
9386 SCIP_Bool* redundant,
9387 SCIP_Bool* infeasible
9426 SCIP_Real implbound,
9427 SCIP_Bool* infeasible,
9436 *infeasible =
FALSE;
9466 if( nbdchgs !=
NULL )
9496 if( nbdchgs !=
NULL )
9524 SCIP_Bool varfixing,
9527 SCIP_Real implbound,
9528 SCIP_Bool isshortcut,
9529 SCIP_Bool* infeasible,
9534 SCIP_Bool redundant;
9548 *infeasible =
FALSE;
9552 checkImplic(
set, implvar, impltype, implbound, &redundant, &conflict);
9553 assert(!redundant || !conflict);
9557 if(
var == implvar )
9582 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
9583 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
9605 vals[0] = varfixing;
9609 SCIP_CALL(
SCIPcliquetableAdd(cliquetable, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
9610 eventqueue,
vars, vals, 2,
FALSE, &conflict, nbdchgs) );
9622 isshortcut, &conflict, added) );
9625 assert(!conflict || !(*added));
9663 if( nbdchgs !=
NULL )
9701 varfixing ? implbound - ub : ub - implbound, varfixing ? ub : implbound) );
9709 varfixing ? implbound - lb : lb - implbound, varfixing ? lb : implbound) );
9732 SCIP_Bool varfixing,
9734 SCIP_Bool implvarfixing,
9735 SCIP_Bool* infeasible,
9741 SCIP_Real* implbounds;
9745 *infeasible =
FALSE;
9762 while (
i >= 0 && !(*infeasible) )
9766 assert(implvars[
i] != implvar);
9773 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9774 eventqueue, varfixing, implvars[
i], impltypes[
i], implbounds[
i],
TRUE, infeasible, nbdchgs, &added) );
9805 SCIP_Bool varfixing,
9808 SCIP_Real implbound,
9809 SCIP_Bool transitive,
9810 SCIP_Bool* infeasible,
9824 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9825 eventqueue, varfixing, implvar, impltype, implbound,
FALSE, infeasible, nbdchgs, &added) );
9827 if( *infeasible ||
var == implvar || !transitive || !added )
9835 SCIP_Bool implvarfixing;
9841 cliquetable, branchcand, eventqueue, varfixing, implvar, implvarfixing, infeasible, nbdchgs) );
9844 if( !(*infeasible) )
9847 cliquetable, branchcand, eventqueue, !implvarfixing,
var, !varfixing, infeasible, nbdchgs) );
9856 SCIP_Real* vlbcoefs;
9857 SCIP_Real* vlbconstants;
9873 while (
i >= 0 && !(*infeasible) )
9875 assert(vlbvars[
i] != implvar);
9898 SCIP_Real vbimplbound;
9900 vbimplbound = (implbound - vlbconstants[
i])/vlbcoefs[
i];
9901 if( vlbcoefs[
i] >= 0.0 )
9904 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9906 infeasible, nbdchgs, &added) );
9911 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9913 infeasible, nbdchgs, &added) );
9916 i =
MIN(
i, nvlbvars);
9926 SCIP_Real* vubcoefs;
9927 SCIP_Real* vubconstants;
9943 while (
i >= 0 && !(*infeasible) )
9945 assert(vubvars[
i] != implvar);
9968 SCIP_Real vbimplbound;
9970 vbimplbound = (implbound - vubconstants[
i])/vubcoefs[
i];
9971 if( vubcoefs[
i] >= 0.0 )
9974 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9976 infeasible, nbdchgs, &added) );
9981 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9983 infeasible, nbdchgs, &added) );
9986 i =
MIN(
i, nvubvars);
10015 SCIP_Real vlbconstant,
10016 SCIP_Bool transitive,
10017 SCIP_Bool* infeasible,
10029 *infeasible =
FALSE;
10030 if( nbdchgs !=
NULL )
10038 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef, vlbconstant, transitive, infeasible, nbdchgs) );
10052 *infeasible =
TRUE;
10072 if( nbdchgs !=
NULL )
10076 else if(
var == vlbvar )
10082 *infeasible =
TRUE;
10093 SCIP_Real newub = vlbconstant / (1.0 - vlbcoef);
10097 *infeasible =
TRUE;
10122 if( nbdchgs !=
NULL )
10133 newlb = vlbconstant / (1.0 - vlbcoef);
10137 *infeasible =
TRUE;
10162 if( nbdchgs !=
NULL )
10189 if( vlbcoef >= 0.0 )
10196 newzub = (xub - vlbconstant)/vlbcoef;
10204 *infeasible =
TRUE;
10230 if( nbdchgs !=
NULL )
10233 maxvlb = vlbcoef * zub + vlbconstant;
10235 minvlb = vlbcoef * zlb + vlbconstant;
10240 maxvlb = vlbcoef * zub + vlbconstant;
10242 minvlb = vlbcoef * zlb + vlbconstant;
10252 newzlb = (xub - vlbconstant)/vlbcoef;
10260 *infeasible =
TRUE;
10286 if( nbdchgs !=
NULL )
10289 maxvlb = vlbcoef * zlb + vlbconstant;
10291 minvlb = vlbcoef * zub + vlbconstant;
10296 maxvlb = vlbcoef * zlb + vlbconstant;
10298 minvlb = vlbcoef * zub + vlbconstant;
10301 if( maxvlb < minvlb )
10311 *infeasible =
TRUE;
10338 if( nbdchgs !=
NULL )
10352 if( vlbcoef >= 0.0 )
10354 vlbcoef = maxvlb - minvlb;
10355 vlbconstant = minvlb;
10359 vlbcoef = minvlb - maxvlb;
10360 vlbconstant = maxvlb;
10381 infeasible, nbdchgs) );
10389 SCIP_Real implbound;
10390 implbound = -vlbconstant/vlbcoef;
10402 implbound, transitive, infeasible, nbdchgs) );
10447 SCIP_CALL(
SCIPvarAddVub(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10448 branchcand, eventqueue, vlbvar, -vlbcoef,
var->
data.
negate.
constant - vlbconstant, transitive, infeasible,
10479 SCIP_Real vubconstant,
10480 SCIP_Bool transitive,
10481 SCIP_Bool* infeasible,
10493 *infeasible =
FALSE;
10494 if( nbdchgs !=
NULL )
10502 cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );
10510 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10517 *infeasible =
TRUE;
10537 if( nbdchgs !=
NULL )
10541 else if(
var == vubvar )
10547 *infeasible =
TRUE;
10558 SCIP_Real newlb = vubconstant / (1.0 - vubcoef);
10562 *infeasible =
TRUE;
10587 if( nbdchgs !=
NULL )
10598 newub = vubconstant / (1.0 - vubcoef);
10602 *infeasible =
TRUE;
10627 if( nbdchgs !=
NULL )
10654 if( vubcoef >= 0.0 )
10661 newzlb = (xlb - vubconstant)/vubcoef;
10664 *infeasible =
TRUE;
10690 if( nbdchgs !=
NULL )
10693 minvub = vubcoef * zlb + vubconstant;
10695 maxvub = vubcoef * zub + vubconstant;
10700 maxvub = vubcoef * zub + vubconstant;
10702 minvub = vubcoef * zlb + vubconstant;
10712 newzub = (xlb - vubconstant)/vubcoef;
10715 *infeasible =
TRUE;
10741 if( nbdchgs !=
NULL )
10744 minvub = vubcoef * zub + vubconstant;
10746 maxvub = vubcoef * zlb + vubconstant;
10751 minvub = vubcoef * zub + vubconstant;
10753 maxvub = vubcoef * zlb + vubconstant;
10756 if( minvub > maxvub )
10766 *infeasible =
TRUE;
10794 if( nbdchgs !=
NULL )
10808 if( vubcoef >= 0.0 )
10810 vubcoef = maxvub - minvub;
10811 vubconstant = minvub;
10815 vubcoef = minvub - maxvub;
10816 vubconstant = maxvub;
10837 infeasible, nbdchgs) );
10847 (1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );
10892 SCIP_CALL(
SCIPvarAddVlb(
var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10893 branchcand, eventqueue, vubvar, -vubcoef,
var->
data.
negate.
constant - vubconstant, transitive, infeasible,
10924 SCIP_Bool varfixing,
10927 SCIP_Real implbound,
10928 SCIP_Bool transitive,
10929 SCIP_Bool* infeasible,
10939 *infeasible =
FALSE;
10940 if( nbdchgs !=
NULL )
10948 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10962 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10963 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
10972 SCIP_CALL(
varAddTransitiveImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10973 branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
10982 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10983 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
11006 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
11012 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,
11036 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11044 SCIP_CALL(
SCIPvarAddImplic(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11047 infeasible, nbdchgs) );
11062 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? 1.0 : -1.0,
11071 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? -1.0 : 1.0,
11081 SCIP_CALL(
SCIPvarAddVub(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11082 branchcand, eventqueue,
var->
negatedvar, (varfixing) ? 1.0 : -1.0,
11083 (varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );
11090 SCIP_CALL(
SCIPvarAddVlb(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11091 branchcand, eventqueue,
var->
negatedvar, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,
11092 transitive, infeasible, nbdchgs) );
11112 SCIP_Bool varfixing,
11132 SCIP_Bool varfixing,
11134 SCIP_Bool implvarfixing
11147 SCIP_Bool varfixing,
11169 if( bounds ==
NULL )
11172 if( lowerpos >= 0 )
11173 *lb = bounds[lowerpos];
11175 if( upperpos >= 0 )
11176 *ub = bounds[upperpos];
11195 SCIP_Bool* infeasible,
11204 *infeasible =
FALSE;
11206 if( value ==
FALSE )
11209 *infeasible =
TRUE;
11229 if( nbdchgs !=
NULL )
11236 *infeasible =
TRUE;
11256 if( nbdchgs !=
NULL )
11284 SCIP_Bool* infeasible,
11294 *infeasible =
FALSE;
11307 SCIP_Bool doubleentry;
11308 SCIP_Bool oppositeentry;
11322 SCIP_CALL(
SCIPvarFixBinary(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11323 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
11329 if( oppositeentry )
11339 for(
i = 0;
i <
nvars && !(*infeasible); ++
i )
11344 SCIP_CALL(
SCIPvarFixBinary(
vars[
i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11345 eventqueue, cliquetable, !values[
i], infeasible, nbdchgs) );
11373 for( v =
nvars - 1; v >= 0; --v )
11479 SCIP_Bool regardimplics
11498 SCIP_Real branchfactor
11511 branchfactor =
MAX(branchfactor,
eps);
11537 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11562 SCIP_Real branchfactor
11570 assert(branchfactor >= 0.0);
11640 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11665 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11760 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11785 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11977 else if( obj1 > obj2 )
12019 int activevarssize;
12043 activevarssize = *
nvars;
12045 tmpvarssize = *
nvars;
12052 noldtmpvars = ntmpvars;
12055 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12056 for( v = ntmpvars - 1; v > 0; --v )
12062 tmpvars[v] = tmpvars[ntmpvars];
12066 if( noldtmpvars > ntmpvars )
12067 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12070 while( ntmpvars >= 1 )
12073 var = tmpvars[ntmpvars];
12081 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12102 if( nactivevars >= activevarssize )
12104 activevarssize *= 2;
12106 assert(nactivevars < activevarssize);
12108 activevars[nactivevars] =
var;
12118 if( nmultvars + ntmpvars > tmpvarssize )
12120 while( nmultvars + ntmpvars > tmpvarssize )
12123 assert(nmultvars + ntmpvars <= tmpvarssize);
12132 ntmpvars += nmultvars;
12133 noldtmpvars = ntmpvars;
12136 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12137 for( v = ntmpvars - 1; v > 0; --v )
12143 tmpvars[v] = tmpvars[ntmpvars];
12147 if( noldtmpvars > ntmpvars )
12148 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12164 SCIPsortPtr((
void**)activevars, SCIPvarComp, nactivevars);
12167 v = nactivevars - 1;
12174 activevars[v] = activevars[nactivevars];
12178 *requiredsize = nactivevars;
12180 if( varssize >= *requiredsize )
12184 *
nvars = *requiredsize;
12206 for( v =
nvars - 1; v >= 0; --v )
12238 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12279 SCIP_Bool** negatedarr,
12284 SCIP_Bool* negated;
12292 for( v =
nvars - 1; v >= 0; --v )
12294 var = &((*vars)[v]);
12295 negated = &((*negatedarr)[v]);
12316 SCIP_Real constant = 0.0;
12317 SCIP_Bool orignegated;
12326 orignegated = *negated;
12334 if( (*var)->data.original.transvar ==
NULL )
12347 if ( (*var)->data.multaggr.nvars == 1 )
12349 assert( (*var)->data.multaggr.vars !=
NULL );
12350 assert( (*var)->data.multaggr.scalars !=
NULL );
12352 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1e-06));
12362 if(
EPSEQ((*var)->data.multaggr.constant, -1.0, 1e-06) || (
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) &&
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06)) )
12364 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12373 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )
12383 assert(
EPSZ((*var)->data.multaggr.constant, 1e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06)
12384 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)
12385 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12387 if( !
EPSZ((*var)->data.multaggr.constant, 1e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) )
12393 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12395 if(
EPSZ((*var)->data.multaggr.constant, 1e-06) )
12401 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?
12407 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12409 constant += (*negated) != orignegated ? -1.0 : 1.0;
12412 *negated = !(*negated);
12423 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1e-06));
12424 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));
12426 constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
12429 *negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);
12436 constant += (*negated) != orignegated ? -1.0 : 1.0;
12439 *negated = !(*negated);
12454 assert(
EPSZ(constant, 1e-06) == ((*negated) == orignegated));
12479 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
12484 if( (*var)->data.original.transvar ==
NULL )
12486 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12500 if ( (*var)->data.multaggr.nvars == 1 )
12502 assert( (*var)->data.multaggr.vars !=
NULL );
12503 assert( (*var)->data.multaggr.scalars !=
NULL );
12504 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
12506 (*bound) /= (*var)->data.multaggr.scalars[0];
12507 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
12508 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
12522 assert((*var)->data.aggregate.scalar != 0.0);
12524 (*bound) /= (*var)->data.aggregate.scalar;
12525 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12526 if( (*var)->data.aggregate.scalar < 0.0 )
12540 assert((*var)->negatedvar->negatedvar == *
var);
12541 (*bound) = (*var)->data.negate.constant - *
bound;
12572 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
12577 if( (*var)->data.original.transvar ==
NULL )
12579 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12594 assert((*var)->data.aggregate.scalar != 0.0);
12597 (*left) /= (*var)->data.aggregate.scalar;
12598 (*right) /= (*var)->data.aggregate.scalar;
12601 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12602 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12607 if( (*var)->data.aggregate.scalar < 0.0 )
12620 assert((*var)->negatedvar->negatedvar == *
var);
12623 (*left) = (*var)->data.negate.constant - (*left);
12624 (*right) = (*var)->data.negate.constant - (*right);
12650 SCIP_Real* constant
12662 if( (*var)->data.original.transvar ==
NULL )
12664 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12680 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12686 (*constant) += *scalar * (*var)->glbdom.lb;
12702 if ( (*var)->data.multaggr.nvars == 1 )
12705 assert((*var)->data.multaggr.scalars !=
NULL);
12706 assert((*var)->data.multaggr.vars[0] !=
NULL);
12716 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12729 (*constant) += *scalar * (*var)->data.multaggr.constant;
12731 (*scalar) *= (*var)->data.multaggr.scalars[0];
12742 (*constant) += *scalar * (*var)->data.aggregate.constant;
12743 (*scalar) *= (*var)->data.aggregate.scalar;
12750 assert((*var)->negatedvar->negatedvar == *
var);
12754 (*constant) += *scalar * (*var)->data.negate.constant;
12776 SCIP_Real* constant
12791 if( (*var)->nparentvars == 0 )
12797 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *
var) )
12800 *constant -= (*var)->data.negate.constant * (*scalar);
12829 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12911 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12981 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
13050 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
13094 SCIP_Real lpsolval;
13193 SCIP_Real pseudosol;
13215 SCIP_Real pseudosolval;
13270 SCIP_Bool roothaslp
13283 SCIP_Real rootredcost,
13284 SCIP_Real rootlpobjval
13298 SCIP_Real currcutoffbound;
13299 SCIP_Real cutoffbound;
13315 if( rootredcost > 0.0 )
13320 cutoffbound = (
bound -
rootsol) * rootredcost + rootlpobjval;
13323 if( cutoffbound > currcutoffbound )
13417 SCIP_Bool varfixing,
13427 SCIP_Bool lpissolbasic;
13463#define MAX_CLIQUELENGTH 50
13470 SCIP_Bool varfixing,
13476 SCIP_Real implredcost;
13486#ifdef SCIP_MORE_DEBUG
13500 SCIP_Bool* clqvalues;
13504 SCIP_Bool cleanedup;
13524 for(
c = ncliques - 1;
c >= 0; --
c )
13526 clique = cliques[
c];
13541 for( v = nclqvars - 1; v >= 0; --v )
13543 clqvar = clqvars[v];
13551 assert(0 < probindex && probindex < nentries);
13553#ifdef SCIP_DISABLED_CODE
13557 assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));
13559 if( entries[probindex] == 0 )
13561 ids[nids] = probindex;
13565 entries[probindex] = (clqvalues[v] ? probindex : -probindex);
13575 for( v = nids - 1; v >= 0; --v )
13578 assert(0 <
id &&
id < nentries);
13579 assert(entries[
id] != 0);
13585 if( (entries[
id] > 0) != varfixing )
13591 implredcost += redcost;
13601#ifdef SCIP_MORE_DEBUG
13619 SCIP_Bool lpissolbasic;
13627 for( v =
nvars - 1; v >= 0; --v )
13655 redcost *= (lb - bounds[v]);
13657 redcost *= (bounds[v] - lb);
13665 redcost *= (bounds[v] - ub);
13667 redcost *= (ub - bounds[v]);
13681 redcost *= (lb - bounds[v]);
13683 redcost *= (bounds[v] - lb);
13691 redcost *= (bounds[v] - ub);
13693 redcost *= (ub - bounds[v]);
13699 implredcost += redcost;
13703#ifdef SCIP_MORE_DEBUG
13704 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13708 return implredcost;
13849 SCIP_Real rootredcost,
13850 SCIP_Real rootlpobjval
13866 SCIP_Bool updateobj
13891 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13903 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13927 SCIP_Real solvalsum;
14030 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
14043 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14127 SCIP_Real* closestvlb,
14140 *closestvlbidx = -1;
14147 SCIP_Real* vlbcoefs;
14148 SCIP_Real* vlbconsts;
14161 *closestvlbidx =
i;
14167 for(
i = 0;
i < nvlbs;
i++ )
14174 if( vlbsol > *closestvlb )
14176 *closestvlb = vlbsol;
14177 *closestvlbidx =
i;
14202 SCIP_Real* closestvub,
14214 *closestvubidx = -1;
14221 SCIP_Real* vubcoefs;
14222 SCIP_Real* vubconsts;
14235 *closestvubidx =
i;
14241 for(
i = 0;
i < nvubs;
i++ )
14248 if( vubsol < *closestvub )
14250 *closestvub = vubsol;
14251 *closestvubidx =
i;
14369#ifdef SCIP_HISTORYTOFILE
14370SCIP_Longint counter = 0l;
14371const char* historypath=
".";
14382 SCIP_Real solvaldelta,
14383 SCIP_Real objdelta,
14387 SCIP_Real oldrootpseudocosts;
14402 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
14423#ifdef SCIP_HISTORYTOFILE
14426 char filename[256];
14433 f = fopen(filename,
"a");
14436 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
14452 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
14462 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
14479 SCIP_Real solvaldelta
14528 SCIP_Real solvaldelta
14668 SCIP_Real downscore;
14669 SCIP_Real solvaldeltaup;
14670 SCIP_Real solvaldeltadown;
14687 return MIN(upscore, downscore);
14694 SCIP_Bool onlycurrentrun
14710 if( onlycurrentrun )
14749 SCIP_Bool onlycurrentrun,
14753 SCIP_Real confidencebound;
14760 if( onlycurrentrun )
14767 confidencebound /= count;
14768 confidencebound = sqrt(confidencebound);
14775 confidencebound = 0.0;
14777 return confidencebound;
14787 SCIP_Real threshold,
14791 SCIP_Real downsize;
14794 SCIP_Real relerrorup;
14795 SCIP_Real relerrordown;
14796 SCIP_Real relerror;
14801 size =
MIN(downsize, upsize);
14811 if( downsize >= 1.9 )
14817 normval =
MAX(1.0, normval);
14819 relerrordown /= normval;
14822 relerrordown = 0.0;
14824 if( upsize >= 1.9 )
14830 normval =
MAX(1.0, normval);
14831 relerrorup /= normval;
14837 relerror =
MAX(relerrorup, relerrordown);
14839 return (relerror <= threshold);
14874 SCIP_Real variancex;
14875 SCIP_Real variancey;
14879 SCIP_Real realdirection;
14888 if( countx <= 1.9 || county <= 1.9 )
14931 SCIP_Real threshold,
14937 SCIP_Real variance;
14939 SCIP_Real realdirection;
14940 SCIP_Real probability;
14941 SCIP_Real problimit;
14985 SCIPerrorMessage(
"Confidence level set to unknown value <%d>", (
int)clevel);
14990 return (probability >= problimit);
15035 if( !
set->history_valuebased )
15075 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15124 value = 1.0 - value;
15148 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15208 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
15251 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
15255 value = 1.0 - value;
15469 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
15496 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
15514 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
15518 value = 1.0 - value;
15553 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
15580 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15598 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15602 value = 1.0 - value;
15637 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15682 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15686 value = 1.0 - value;
15939 SCIPerrorMessage(
"invalid branching direction %d when asking for VSIDS value\n", dir);
16537 SCIP_Real oldbound,
16544 (*bdchginfo)->oldbound = oldbound;
16545 (*bdchginfo)->newbound = newbound;
16546 (*bdchginfo)->var =
var;
16547 (*bdchginfo)->inferencedata.var =
var;
16548 (*bdchginfo)->inferencedata.reason.prop =
NULL;
16549 (*bdchginfo)->inferencedata.info = 0;
16550 (*bdchginfo)->bdchgidx.depth = INT_MAX;
16551 (*bdchginfo)->bdchgidx.pos = -1;
16552 (*bdchginfo)->pos = 0;
16554 (*bdchginfo)->boundtype = boundtype;
16555 (*bdchginfo)->inferboundtype = boundtype;
16556 (*bdchginfo)->redundant =
FALSE;
16721 switch( varstatus )
16729 if( bdchgidx ==
NULL )
16736 if( bdchginfo !=
NULL )
16807 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16840 switch( varstatus )
16848 if( bdchgidx ==
NULL )
16855 if( bdchginfo !=
NULL )
16927 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
17038 return bdchgidx->
depth;
17197#undef SCIPboundchgGetNewbound
17198#undef SCIPboundchgGetVar
17199#undef SCIPboundchgGetBoundchgtype
17200#undef SCIPboundchgGetBoundtype
17201#undef SCIPboundchgIsRedundant
17202#undef SCIPdomchgGetNBoundchgs
17203#undef SCIPdomchgGetBoundchg
17204#undef SCIPholelistGetLeft
17205#undef SCIPholelistGetRight
17206#undef SCIPholelistGetNext
17207#undef SCIPvarGetName
17208#undef SCIPvarGetNUses
17209#undef SCIPvarGetData
17210#undef SCIPvarSetData
17211#undef SCIPvarSetDelorigData
17212#undef SCIPvarSetTransData
17213#undef SCIPvarSetDeltransData
17214#undef SCIPvarGetStatus
17215#undef SCIPvarIsOriginal
17216#undef SCIPvarIsTransformed
17217#undef SCIPvarIsNegated
17218#undef SCIPvarGetType
17219#undef SCIPvarIsBinary
17220#undef SCIPvarIsIntegral
17221#undef SCIPvarIsInitial
17222#undef SCIPvarIsRemovable
17223#undef SCIPvarIsDeleted
17224#undef SCIPvarIsDeletable
17225#undef SCIPvarMarkDeletable
17226#undef SCIPvarMarkNotDeletable
17227#undef SCIPvarIsActive
17228#undef SCIPvarGetIndex
17229#undef SCIPvarGetProbindex
17230#undef SCIPvarGetTransVar
17231#undef SCIPvarGetCol
17232#undef SCIPvarIsInLP
17233#undef SCIPvarGetAggrVar
17234#undef SCIPvarGetAggrScalar
17235#undef SCIPvarGetAggrConstant
17236#undef SCIPvarGetMultaggrNVars
17237#undef SCIPvarGetMultaggrVars
17238#undef SCIPvarGetMultaggrScalars
17239#undef SCIPvarGetMultaggrConstant
17240#undef SCIPvarGetNegatedVar
17241#undef SCIPvarGetNegationVar
17242#undef SCIPvarGetNegationConstant
17243#undef SCIPvarGetObj
17244#undef SCIPvarGetLbOriginal
17245#undef SCIPvarGetUbOriginal
17246#undef SCIPvarGetHolelistOriginal
17247#undef SCIPvarGetLbGlobal
17248#undef SCIPvarGetUbGlobal
17249#undef SCIPvarGetHolelistGlobal
17250#undef SCIPvarGetBestBoundGlobal
17251#undef SCIPvarGetWorstBoundGlobal
17252#undef SCIPvarGetLbLocal
17253#undef SCIPvarGetUbLocal
17254#undef SCIPvarGetHolelistLocal
17255#undef SCIPvarGetBestBoundLocal
17256#undef SCIPvarGetWorstBoundLocal
17257#undef SCIPvarGetBestBoundType
17258#undef SCIPvarGetWorstBoundType
17259#undef SCIPvarGetLbLazy
17260#undef SCIPvarGetUbLazy
17261#undef SCIPvarGetBranchFactor
17262#undef SCIPvarGetBranchPriority
17263#undef SCIPvarGetBranchDirection
17264#undef SCIPvarGetNVlbs
17265#undef SCIPvarGetVlbVars
17266#undef SCIPvarGetVlbCoefs
17267#undef SCIPvarGetVlbConstants
17268#undef SCIPvarGetNVubs
17269#undef SCIPvarGetVubVars
17270#undef SCIPvarGetVubCoefs
17271#undef SCIPvarGetVubConstants
17272#undef SCIPvarGetNImpls
17273#undef SCIPvarGetImplVars
17274#undef SCIPvarGetImplTypes
17275#undef SCIPvarGetImplBounds
17276#undef SCIPvarGetImplIds
17277#undef SCIPvarGetNCliques
17278#undef SCIPvarGetCliques
17279#undef SCIPvarGetLPSol
17280#undef SCIPvarGetNLPSol
17281#undef SCIPvarGetBdchgInfoLb
17282#undef SCIPvarGetNBdchgInfosLb
17283#undef SCIPvarGetBdchgInfoUb
17284#undef SCIPvarGetNBdchgInfosUb
17285#undef SCIPvarGetValuehistory
17286#undef SCIPvarGetPseudoSol
17287#undef SCIPvarCatchEvent
17288#undef SCIPvarDropEvent
17289#undef SCIPvarGetVSIDS
17290#undef SCIPvarGetCliqueComponentIdx
17291#undef SCIPvarIsRelaxationOnly
17292#undef SCIPvarMarkRelaxationOnly
17293#undef SCIPbdchgidxGetPos
17294#undef SCIPbdchgidxIsEarlierNonNull
17295#undef SCIPbdchgidxIsEarlier
17296#undef SCIPbdchginfoGetOldbound
17297#undef SCIPbdchginfoGetNewbound
17298#undef SCIPbdchginfoGetVar
17299#undef SCIPbdchginfoGetChgtype
17300#undef SCIPbdchginfoGetBoundtype
17301#undef SCIPbdchginfoGetDepth
17302#undef SCIPbdchginfoGetPos
17303#undef SCIPbdchginfoGetIdx
17304#undef SCIPbdchginfoGetInferVar
17305#undef SCIPbdchginfoGetInferCons
17306#undef SCIPbdchginfoGetInferProp
17307#undef SCIPbdchginfoGetInferInfo
17308#undef SCIPbdchginfoGetInferBoundtype
17309#undef SCIPbdchginfoIsRedundant
17310#undef SCIPbdchginfoHasInferenceReason
17311#undef SCIPbdchginfoIsTighter
17331 return boundchg->
var;
17411 return holelist->
next;
17467 var->vardelorig = vardelorig;
17479 var->vartrans = vartrans;
17490 var->vardeltrans = vardeltrans;
17501 var->varcopy = varcopy;
17523 SCIP_Bool removable
17953 SCIP_Real mult = 1.0;
17958 while( probvar !=
NULL )
18357 SCIP_Bool varfixing
18374 SCIP_Bool varfixing
18389 SCIP_Bool varfixing
18403 SCIP_Bool varfixing
18419 SCIP_Bool varfixing
18431 SCIP_Bool varfixing
18442 SCIP_Bool varfixing
18483 assert(pos < var->nlbchginfos);
18503 assert(pos < var->nubchginfos);
18576 eventtype,
var->
name, (
void*)eventhdlr, (
void*)eventdata);
18615 return bdchgidx->
pos;
18631 return (bdchgidx1->
depth < bdchgidx2->
depth)
18632 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18649 if( bdchgidx1 ==
NULL )
18651 else if( bdchgidx2 ==
NULL )
18654 return (bdchgidx1->
depth < bdchgidx2->
depth)
18655 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18685 return bdchginfo->
var;
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 SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPeventCreateImplAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)
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
union SCIP_BoundChg::@126301315365336333353356203157377037022074222233 data
SCIP_INFERENCEDATA inferencedata
SCIP_BRANCHINGDATA branchingdata
unsigned int inferboundtype
unsigned int boundchgtype
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_Real conflictrelaxedub
SCIP_BDCHGINFO * ubchginfos
SCIP_Real bestrootredcost
union SCIP_Var::@062351145146014100220174313010263165251013276204 data
SCIP_Real conflictrelaxedlb
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
#define SCIP_EVENTTYPE_LHOLEADDED
@ 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