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;
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;
438 if( num >
var->lbchginfossize )
444 var->lbchginfossize = newsize;
446 assert(num <= var->lbchginfossize);
464 if( num >
var->ubchginfossize )
470 var->ubchginfossize = newsize;
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",
511 var->lbchginfos[
var->nlbchginfos].oldbound = oldbound;
512 var->lbchginfos[
var->nlbchginfos].newbound = newbound;
513 var->lbchginfos[
var->nlbchginfos].var =
var;
514 var->lbchginfos[
var->nlbchginfos].bdchgidx.depth =
depth;
515 var->lbchginfos[
var->nlbchginfos].bdchgidx.pos = pos;
516 var->lbchginfos[
var->nlbchginfos].pos =
var->nlbchginfos;
517 var->lbchginfos[
var->nlbchginfos].boundchgtype = boundchgtype;
519 var->lbchginfos[
var->nlbchginfos].redundant =
FALSE;
520 var->lbchginfos[
var->nlbchginfos].inferboundtype = inferboundtype;
521 var->lbchginfos[
var->nlbchginfos].inferencedata.var = infervar;
522 var->lbchginfos[
var->nlbchginfos].inferencedata.info = inferinfo;
527 switch( boundchgtype )
533 var->lbchginfos[
var->nlbchginfos].inferencedata.reason.cons = infercons;
536 var->lbchginfos[
var->nlbchginfos].inferencedata.reason.prop = inferprop;
547 &
var->lbchginfos[
var->nlbchginfos-1].bdchgidx));
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",
586 var->ubchginfos[
var->nubchginfos].oldbound = oldbound;
587 var->ubchginfos[
var->nubchginfos].newbound = newbound;
588 var->ubchginfos[
var->nubchginfos].var =
var;
589 var->ubchginfos[
var->nubchginfos].bdchgidx.depth =
depth;
590 var->ubchginfos[
var->nubchginfos].bdchgidx.pos = pos;
591 var->ubchginfos[
var->nubchginfos].pos =
var->nubchginfos;
592 var->ubchginfos[
var->nubchginfos].boundchgtype = boundchgtype;
594 var->ubchginfos[
var->nubchginfos].redundant =
FALSE;
595 var->ubchginfos[
var->nubchginfos].inferboundtype = inferboundtype;
596 var->ubchginfos[
var->nubchginfos].inferencedata.var = infervar;
597 var->ubchginfos[
var->nubchginfos].inferencedata.info = inferinfo;
602 switch( boundchgtype )
608 var->ubchginfos[
var->nubchginfos].inferencedata.reason.cons = infercons;
611 var->ubchginfos[
var->nubchginfos].inferencedata.reason.prop = inferprop;
622 &
var->ubchginfos[
var->nubchginfos-1].bdchgidx));
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",
860 var->lbchginfos[
var->nlbchginfos].bdchgidx.depth,
var->lbchginfos[
var->nlbchginfos].bdchgidx.pos,
861 var->lbchginfos[
var->nlbchginfos].oldbound,
var->lbchginfos[
var->nlbchginfos].newbound);
865 var->lbchginfos[
var->nlbchginfos].oldbound) );
879 SCIPsetDebugMsg(
set,
"removed upper bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
881 var->ubchginfos[
var->nubchginfos].bdchgidx.depth,
var->ubchginfos[
var->nubchginfos].bdchgidx.pos,
882 var->ubchginfos[
var->nubchginfos].oldbound,
var->ubchginfos[
var->nubchginfos].newbound);
886 var->ubchginfos[
var->nubchginfos].oldbound) );
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++;
1630 onlyredundant ?
"redundant" :
"all", irrelevantvar ?
"irrelevant " :
"",
SCIPvarGetName(
var), lb, ub);
1633 if(
var->implics !=
NULL && (!onlyredundant || lb > 0.5 || ub < 0.5) )
1651 for(
i = 0;
i < nimpls;
i++ )
1656 implvar = implvars[
i];
1657 impltype = impltypes[
i];
1674 var->closestvblpcount = -1;
1686 var->closestvblpcount = -1;
1690 varfixing = !varfixing;
1692 while( varfixing ==
TRUE );
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",
1770 var->closestvblpcount = -1;
1772 else if( coef < 0.0 && implvar->vlbs !=
NULL )
1774 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1778 var->closestvblpcount = -1;
1786 var->closestvblpcount = -1;
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",
1864 var->closestvblpcount = -1;
1866 else if( coef > 0.0 && implvar->
vlbs !=
NULL )
1868 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1872 var->closestvblpcount = -1;
1880 var->closestvblpcount = -1;
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;
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;
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);
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;
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;
2628 if( num >
var->parentvarssize )
2634 var->parentvarssize = newsize;
2636 assert(num <= var->parentvarssize);
2657 parentvar->
name, (
void*)parentvar,
var->name, (
void*)
var,
var->nparentvars);
2661 var->parentvars[
var->nparentvars] = parentvar;
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);
2725 (*var)->negatedvar =
NULL;
2729 SCIPerrorMessage(
"parent variable is neither ORIGINAL, AGGREGATED nor NEGATED\n");
2755 assert((*var)->nuses == 0);
2756 assert((*var)->probindex == -1);
2765 assert((*var)->data.original.transvar ==
NULL);
2766 holelistFree(&(*var)->data.original.origdom.holelist, blkmem);
2767 assert((*var)->data.original.origdom.holelist ==
NULL);
2794 if( (*var)->vardelorig !=
NULL )
2801 if( (*var)->vardeltrans !=
NULL )
2808 if( (*var)->eventfilter !=
NULL )
2857#ifdef DEBUGUSES_VARNAME
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 )
2938 var->conflictlbcount = 0;
2939 var->conflictubcount = 0;
2982 if( holelist ==
NULL )
2992 while(holelist !=
NULL )
3065 printHolelist(messagehdlr, file, holelist,
"original holes");
3125 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
3185 if( addnlocksdown == 0 && addnlocksup == 0 )
3189 SCIPsetDebugMsg(
set,
"add rounding locks %d/%d to variable <%s> (locks=%d/%d, type=%u)\n",
3190 addnlocksdown, addnlocksup,
var->name,
var->nlocksdown[locktype],
var->nlocksup[locktype], locktype);
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;
3310 if(
var->data.original.transvar !=
NULL )
3313 return var->nlocksdown[locktype];
3318 return var->nlocksdown[locktype];
3322 if(
var->data.aggregate.scalar > 0.0 )
3330 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
3332 if(
var->data.multaggr.scalars[
i] > 0.0 )
3368 if(
var->data.original.transvar !=
NULL )
3371 return var->nlocksup[locktype];
3376 return var->nlocksup[locktype];
3380 if(
var->data.aggregate.scalar > 0.0 )
3388 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
3390 if(
var->data.multaggr.scalars[
i] > 0.0 )
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);
3600 if(
var->probindex != -1 )
3637 if(
var->probindex != -1 )
3670 assert(0 <= fixeventtype && fixeventtype <= 2);
3677 for(
i =
var->nparentvars -1;
i >= 0; --
i )
3683 switch( fixeventtype )
3687 for(
i =
var->nparentvars - 1;
i >= 0; --
i )
3704 for(
i =
var->nparentvars - 1;
i >= 0; --
i )
3727 for(
i =
var->nparentvars - 1;
i >= 0; --
i )
3781 *infeasible =
FALSE;
3787 SCIPsetDebugMsg(
set,
" -> variable already fixed to %g (fixedval=%g): infeasible=%u\n",
var->locdom.lb, fixedval, *infeasible);
3794 SCIPsetDebugMsg(
set,
" -> fixing infeasible: locdom=[%g,%g], fixedval=%g\n",
var->locdom.lb,
var->locdom.ub, fixedval);
3802 if(
var->data.original.transvar ==
NULL )
3808 lp, branchcand, eventfilter, eventqueue, cliquetable, fixedval, infeasible, fixed) );
3838 var->glbdom.lb = fixedval;
3839 var->glbdom.ub = fixedval;
3842 var->locdom.lb = fixedval;
3843 var->locdom.ub = fixedval;
3859 if(
var->probindex != -1 )
3865 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
3887 childfixedval = (
var->data.aggregate.scalar < 0.0 ? -fixedval : fixedval);
3889 childfixedval = (fixedval -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
3890 SCIP_CALL(
SCIPvarFix(
var->data.aggregate.var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3891 branchcand, eventfilter, eventqueue, cliquetable, childfixedval, infeasible, fixed) );
3905 SCIP_CALL(
SCIPvarFix(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3906 branchcand, eventfilter, eventqueue, cliquetable,
var->data.negate.constant - fixedval, infeasible, fixed) );
3994 activeconstant = 0.0;
3995 activeconstantinf =
FALSE;
3996 activevarssize = (*nvars) * 2;
3998 tmpvarssize = *
nvars;
4013 for( v = ntmpvars - 1; v >= 0; --v )
4016 scalar = tmpscalars[v];
4037 tmpscalars[v] = scalar;
4039 noldtmpvars = ntmpvars;
4042 SCIPsortPtrReal((
void**)tmpvars, tmpscalars, SCIPvarComp, noldtmpvars);
4044 for( v = 1; v < noldtmpvars; ++v )
4049 tmpscalars[ntmpvars] += tmpscalars[v];
4056 tmpscalars[ntmpvars] = tmpscalars[v];
4057 tmpvars[ntmpvars] = tmpvars[v];
4063#ifdef SCIP_MORE_DEBUG
4064 for( v = 1; v < ntmpvars; ++v )
4069 while( ntmpvars >= 1 )
4073 var = tmpvars[ntmpvars];
4074 scalar = tmpscalars[ntmpvars];
4092 if( nactivevars >= activevarssize )
4094 activevarssize *= 2;
4097 assert(nactivevars < activevarssize);
4099 activevars[nactivevars] =
var;
4100 activescalars[nactivevars] = scalar;
4106 nmultvars =
var->data.multaggr.nvars;
4107 multvars =
var->data.multaggr.vars;
4108 multscalars =
var->data.multaggr.scalars;
4111 if( nmultvars + ntmpvars > tmpvarssize )
4113 while( nmultvars + ntmpvars > tmpvarssize )
4117 assert(nmultvars + ntmpvars <= tmpvarssize);
4120 if( nmultvars > tmpvarssize2 )
4122 while( nmultvars > tmpvarssize2 )
4126 assert(nmultvars <= tmpvarssize2);
4131 for( ; nmultvars >= 0; --nmultvars )
4133 multvar = multvars[nmultvars];
4134 multscalar = multscalars[nmultvars];
4146 if( !activeconstantinf )
4153 if( scalar * multconstant > 0.0 )
4156 activeconstantinf =
TRUE;
4161 activeconstantinf =
TRUE;
4165 activeconstant += scalar * multconstant;
4180 tmpscalars[pos] += scalar * multscalar;
4184 tmpvars2[ntmpvars2] = multvar;
4185 tmpscalars2[ntmpvars2] = scalar * multscalar;
4187 assert(ntmpvars2 <= tmpvarssize2);
4194 SCIPsortPtrReal((
void**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);
4196 for( v = 1; v < ntmpvars2; ++v )
4201 tmpscalars2[pos] += tmpscalars2[v];
4208 tmpscalars2[pos] = tmpscalars2[v];
4209 tmpvars2[pos] = tmpvars2[v];
4213 ntmpvars2 = pos + 1;
4214#ifdef SCIP_MORE_DEBUG
4215 for( v = 1; v < ntmpvars2; ++v )
4219 for( v = 1; v < ntmpvars; ++v )
4226 pos = ntmpvars + ntmpvars2 - 1;
4227 ntmpvars += ntmpvars2;
4229 while( v >= 0 && k >= 0 )
4235 tmpvars[pos] = tmpvars[v];
4236 tmpscalars[pos] = tmpscalars[v];
4241 tmpvars[pos] = tmpvars2[k];
4242 tmpscalars[pos] = tmpscalars2[k];
4251 tmpvars[pos] = tmpvars[v];
4252 tmpscalars[pos] = tmpscalars[v];
4259 tmpvars[pos] = tmpvars2[k];
4260 tmpscalars[pos] = tmpscalars2[k];
4265#ifdef SCIP_MORE_DEBUG
4266 for( v = 1; v < ntmpvars; ++v )
4272 if( !activeconstantinf )
4281 if( scalar * multconstant > 0.0 )
4284 activeconstantinf =
TRUE;
4289 activeconstantinf =
TRUE;
4293 activeconstant += scalar * multconstant;
4320 if( mergemultiples )
4325 SCIPsortPtrReal((
void**)activevars, activescalars, SCIPvarComp, nactivevars);
4328 v = nactivevars - 1;
4334 if( activescalars[v - 1] + activescalars[v] != 0.0 )
4336 activescalars[v - 1] += activescalars[v];
4338 activevars[v] = activevars[nactivevars];
4339 activescalars[v] = activescalars[nactivevars];
4344 activevars[v] = activevars[nactivevars];
4345 activescalars[v] = activescalars[nactivevars];
4348 activevars[v] = activevars[nactivevars];
4349 activescalars[v] = activescalars[nactivevars];
4363 for( v = 0; v < nactivevars / 2; ++v )
4365 tmpvar = activevars[v];
4366 tmpscalar = activescalars[v];
4367 activevars[v] = activevars[nactivevars - 1 - v];
4368 activescalars[v] = activescalars[nactivevars - 1 - v];
4369 activevars[nactivevars - 1 - v] = tmpvar;
4370 activescalars[nactivevars - 1 - v] = tmpscalar;
4374 *requiredsize = nactivevars;
4376 if( varssize >= *requiredsize )
4380 *
nvars = *requiredsize;
4385 if( activeconstantinf )
4386 (*constant) = activeconstant;
4388 (*constant) += activeconstant;
4399 for( v = 0; v < *
nvars; ++v )
4401 vars[v] = activevars[v];
4402 scalars[v] = activescalars[v];
4433 int multrequiredsize;
4462 nlocksup[
i] =
var->nlocksup[
i];
4463 nlocksdown[
i] =
var->nlocksdown[
i];
4468 multconstant =
var->data.multaggr.constant;
4469 nmultvars =
var->data.multaggr.nvars;
4470 multvarssize =
var->data.multaggr.varssize;
4474 if( multrequiredsize > multvarssize )
4478 multvarssize = multrequiredsize;
4480 assert( multrequiredsize <= multvarssize );
4496 var->data.multaggr.constant = multconstant;
4497 var->data.multaggr.nvars = nmultvars;
4498 var->data.multaggr.varssize = multvarssize;
4582 *infeasible =
FALSE;
4585 SCIPsetDebugMsg(
set,
"updating bounds of variables in aggregation <%s> == %g*<%s> %+g\n",
var->name, scalar, aggvar->
name, constant);
4592 aggvarbdschanged =
FALSE;
4600 varlb = aggvar->
glbdom.
lb * scalar + constant;
4604 varub = aggvar->
glbdom.
ub * scalar + constant;
4611 varub = aggvar->
glbdom.
lb * scalar + constant;
4615 varlb = aggvar->
glbdom.
ub * scalar + constant;
4617 varlb =
MAX(varlb,
var->glbdom.lb);
4618 varub =
MIN(varub,
var->glbdom.ub);
4632 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4633 eventfilter, eventqueue, cliquetable, varlb, infeasible, fixed) );
4634 if( !(*infeasible) )
4638 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4639 eventfilter, eventqueue, cliquetable, (varlb-constant)/scalar, infeasible, &aggfixed) );
4640 assert(*fixed == aggfixed);
4665 aggvarlb = (
var->glbdom.lb - constant) / scalar;
4669 aggvarub = (
var->glbdom.ub - constant) / scalar;
4676 aggvarub = (
var->glbdom.lb - constant) / scalar;
4680 aggvarlb = (
var->glbdom.ub - constant) / scalar;
4697 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4698 eventfilter, eventqueue, cliquetable, aggvarlb, infeasible, fixed) );
4699 if( !(*infeasible) )
4703 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4704 eventfilter, eventqueue, cliquetable, aggvarlb * scalar + constant, infeasible, &varfixed) );
4705 assert(*fixed == varfixed);
4729 while( aggvarbdschanged );
4783 *infeasible =
FALSE;
4784 *aggregated =
FALSE;
4792 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventfilter,
4793 eventqueue, cliquetable, constant, infeasible, aggregated) );
4828 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4829 eventfilter, eventqueue, cliquetable, constant/(1.0-scalar), infeasible, aggregated) );
4835 SCIP_CALL(
varUpdateAggregationBounds(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
4836 branchcand, eventfilter, eventqueue, cliquetable, aggvar, scalar, constant, infeasible, &fixed) );
4837 if( *infeasible || fixed )
4839 *aggregated = fixed;
4855 nlocksdown[
i] =
var->nlocksdown[
i];
4856 nlocksup[
i] =
var->nlocksup[
i];
4858 var->nlocksdown[
i] = 0;
4859 var->nlocksup[
i] = 0;
4869 var->data.negate.constant = 1.0;
4870 var->negatedvar = aggvar;
4885 var->data.aggregate.var = aggvar;
4886 var->data.aggregate.scalar = scalar;
4887 var->data.aggregate.constant = constant;
4917 for(
i = 0;
i < nvbds && !(*infeasible); ++
i )
4919 SCIP_CALL(
SCIPvarAddVlb(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4929 for(
i = 0;
i < nvbds && !(*infeasible); ++
i )
4931 SCIP_CALL(
SCIPvarAddVub(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4945 for(
i = 0;
i < 2; ++
i )
4957 for( j = 0; j < nimpls && !(*infeasible); ++j )
4962 SCIP_CALL(
SCIPvarAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
4963 branchcand, eventqueue, (
SCIP_Bool)
i, implvars[j], impltypes[j], implbounds[j],
FALSE, infeasible,
5020 if(
var->probindex != -1 )
5029 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5038 if( *infeasible || *aggregated )
5092#define MAXDNOM 1000000LL
5117 *infeasible =
FALSE;
5118 *aggregated =
FALSE;
5138 a = (scm/scalarxd)*scalarxn;
5139 b = (scm/scalaryd)*scalaryn;
5171 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5172 branchcand, eventfilter, eventqueue, vary, (
SCIP_Real)(-
b/
a), (
SCIP_Real)(
c/
a), infeasible, aggregated) );
5180 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5181 branchcand, eventfilter, eventqueue, varx, (
SCIP_Real)(-
a/
b), (
SCIP_Real)(
c/
b), infeasible, aggregated) );
5212 currentclass =
c %
a;
5213 if( currentclass < 0 )
5215 assert(0 <= currentclass && currentclass <
a);
5217 classstep = (-
b) %
a;
5221 assert(0 <= classstep && classstep <
a);
5223 while( currentclass != 0 )
5225 assert(0 <= currentclass && currentclass <
a);
5226 currentclass += classstep;
5227 if( currentclass >=
a )
5234 xsol = (
c -
b*ysol)/
a;
5259 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5260 branchcand, eventfilter, eventqueue, aggvar, (
SCIP_Real)(-
b), (
SCIP_Real)xsol, infeasible, aggregated) );
5261 assert(*aggregated || *infeasible);
5263 if( !(*infeasible) )
5265 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5266 branchcand, eventfilter, eventqueue, aggvar, (
SCIP_Real)
a, (
SCIP_Real)ysol, infeasible, aggregated) );
5267 assert(*aggregated || *infeasible);
5335 *infeasible =
FALSE;
5336 *aggregated =
FALSE;
5406 scalar = -scalary/scalarx;
5407 constant = rhs/scalarx;
5427 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5428 branchcand, eventfilter, eventqueue, vary, scalar, constant, infeasible, aggregated) );
5435 SCIP_CALL(
tryAggregateIntVars(
set, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5436 branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
5479 int tmprequiredsize;
5491 SCIPsetDebugMsg(
set,
"trying multi-aggregating variable <%s> == ...%d vars... %+g\n",
var->name, naggvars, constant);
5493 *infeasible =
FALSE;
5494 *aggregated =
FALSE;
5499 if(
var->data.original.transvar ==
NULL )
5501 SCIPerrorMessage(
"cannot multi-aggregate an untransformed original variable\n");
5505 reopt, lp, cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars, constant, infeasible, aggregated) );
5512 ntmpvars = naggvars;
5513 tmpvarssize = naggvars;
5514 tmpconstant = constant;
5520 if( tmprequiredsize > tmpvarssize )
5524 tmpvarssize = tmprequiredsize;
5526 assert( tmprequiredsize <= tmpvarssize );
5534 for( v = ntmpvars - 1; v >= 0; --v )
5539 if( tmpvars[v]->index ==
var->index )
5541 tmpscalar += tmpscalars[v];
5542 tmpvars[v] = tmpvars[ntmpvars - 1];
5543 tmpscalars[v] = tmpscalars[ntmpvars - 1];
5555 SCIPsetDebugMsg(
set,
"Possible multi-aggregation was completely resolved and detected to be redundant.\n");
5560 SCIPsetDebugMsg(
set,
"Multi-aggregation was completely resolved and led to infeasibility.\n");
5565 else if( ntmpvars == 1 )
5567 assert(tmpscalars[0] != 0.0);
5571 SCIP_CALL(
SCIPvarFix(tmpvars[0], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5572 branchcand, eventfilter, eventqueue, cliquetable, -constant/tmpscalars[0], infeasible, aggregated) );
5575 else if( ntmpvars == 2 )
5578 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5582 cliquetable, branchcand, eventfilter, eventqueue, tmpvars[0], tmpvars[1], tmpscalars[0],
5583 tmpscalars[1], -tmpconstant, infeasible, aggregated) );
5596 tmpscalar = 1 - tmpscalar;
5597 tmpconstant /= tmpscalar;
5598 for( v = ntmpvars - 1; v >= 0; --v )
5599 tmpscalars[v] /= tmpscalar;
5606 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5607 eventfilter, eventqueue, cliquetable, tmpconstant, infeasible, aggregated) );
5614 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5618 cliquetable, branchcand, eventfilter, eventqueue,
var, tmpvars[0], 1.0, -tmpscalars[0], tmpconstant,
5619 infeasible, aggregated) );
5659 nlocksdown[
i] =
var->nlocksdown[
i];
5660 nlocksup[
i] =
var->nlocksup[
i];
5662 var->nlocksdown[
i] = 0;
5663 var->nlocksup[
i] = 0;
5670 var->data.multaggr.constant = tmpconstant;
5671 var->data.multaggr.nvars = ntmpvars;
5672 var->data.multaggr.varssize = ntmpvars;
5686 branchfactor =
var->branchfactor;
5687 branchpriority =
var->branchpriority;
5690 for( v = 0; v < ntmpvars; ++v )
5694 branchfactor =
MAX(tmpvars[v]->branchfactor, branchfactor);
5695 branchpriority =
MAX(tmpvars[v]->branchpriority, branchpriority);
5700 for( v = 0; v < ntmpvars; ++v )
5706 if( tmpscalars[v] >= 0.0 )
5719 if(
var->probindex != -1 )
5731 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5754 SCIPerrorMessage(
"cannot multi-aggregate a multiple aggregated variable again\n");
5767 for( v = 0; v < naggvars; ++v )
5771 SCIP_CALL(
SCIPvarMultiaggregate(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5772 cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars,
5773 var->data.negate.constant - constant, infeasible, aggregated) );
5776 for( v = 0; v < naggvars; ++v )
5786 if( *infeasible || *aggregated )
5949 (*negvar)->data.negate.constant = 1.0;
5951 (*negvar)->data.negate.constant =
var->glbdom.lb +
var->glbdom.ub;
5960 (*negvar)->glbdom.lb = (*negvar)->data.negate.constant -
var->glbdom.ub;
5961 (*negvar)->glbdom.ub = (*negvar)->data.negate.constant -
var->glbdom.lb;
5962 (*negvar)->locdom.lb = (*negvar)->data.negate.constant -
var->locdom.ub;
5963 (*negvar)->locdom.ub = (*negvar)->data.negate.constant -
var->locdom.lb;
5967 var->negatedvar = *negvar;
5975 (*negvar)->branchfactor =
var->branchfactor;
5976 (*negvar)->branchpriority =
var->branchpriority;
5980 (*negvar)->donotaggr =
var->donotaggr;
5981 (*negvar)->donotmultaggr =
var->donotmultaggr;
5984 (*negvar)->lazylb = (*negvar)->data.negate.constant -
var->lazyub;
5985 (*negvar)->lazyub = (*negvar)->data.negate.constant -
var->lazylb;
5989 assert((*negvar)->nuses == 1);
5994 *negvar =
var->negatedvar;
6014 var->probindex = probindex;
6018 var->data.col->var_probindex = probindex;
6046 var->name = (
char*)name;
6124 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be aggregated.\n");
6160 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be multi-aggregated.\n");
6192 if(
var->probindex >= 0 )
6194 SCIPerrorMessage(
"cannot change type of variable already in the problem\n");
6199 var->vartype = vartype;
6212 var->negatedvar->vartype = vartype;
6285 if(
var->data.original.transvar !=
NULL )
6323 SCIPerrorMessage(
"cannot change objective value of a fixed, aggregated, multi-aggregated, or negated variable\n");
6367 if(
var->data.original.transvar !=
NULL )
6376 var->unchangedobj += addobj;
6389 var->unchangedobj += addobj;
6406 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6413 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6415 lp, eventfilter, eventqueue,
var->data.aggregate.scalar * addobj) );
6422 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6423 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
6426 reopt, lp, eventfilter, eventqueue,
var->data.multaggr.scalars[
i] * addobj) );
6436 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6437 SCIP_CALL(
SCIPvarAddObj(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
6438 eventfilter, eventqueue, -addobj) );
6494 SCIPerrorMessage(
"cannot change diving objective value of a multi-aggregated variable\n");
6591 var->name,
var->data.original.origdom.lb, newbound);
6597 var->data.original.origdom.lb = newbound;
6606 for(
i = 0;
i <
var->nparentvars; ++
i )
6610 parentvar =
var->parentvars[
i];
6650 var->name,
var->data.original.origdom.ub, newbound);
6656 var->data.original.origdom.ub = newbound;
6665 for(
i = 0;
i <
var->nparentvars; ++
i )
6669 parentvar =
var->parentvars[
i];
6697 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6710 SCIPsetDebugMsg(
set,
"issue GLBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
6735 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6748 SCIPsetDebugMsg(
set,
"issue GUBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
6780 SCIPsetDebugMsg(
set,
"issue GHOLEADDED event for variable <%s>: (%.15g,%.15g)\n",
var->name, left, right);
6865 newbound =
var->glbdom.ub;
6871 SCIPsetDebugMsg(
set,
"process changing global lower bound of <%s> from %f to %f\n",
var->name,
var->glbdom.lb, newbound);
6873 if(
SCIPsetIsEQ(
set, newbound,
var->glbdom.lb) && !(newbound !=
var->glbdom.lb && newbound *
var->glbdom.lb <= 0.0) )
6880 oldbound =
var->glbdom.lb;
6882 var->glbdom.lb = newbound;
6898 for(
i = 0;
i <
var->nlbchginfos; ++
i )
6902 if(
var->lbchginfos[
i].oldbound <
var->glbdom.lb )
6904 SCIPsetDebugMsg(
set,
" -> adjust lower bound change <%s>: %g -> %g due to new global lower bound %g\n",
6906 var->lbchginfos[
i].oldbound =
var->glbdom.lb;
6910 var->lbchginfos[
i].newbound =
var->glbdom.lb;
6912 var->lbchginfos[
i].redundant =
TRUE;
6936 for(
i = 0;
i <
var->nparentvars; ++
i )
6938 parentvar =
var->parentvars[
i];
6951 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
6968 parentnewbound = newbound;
6984 parentnewbound = -newbound;
7041 newbound =
var->glbdom.lb;
7047 SCIPsetDebugMsg(
set,
"process changing global upper bound of <%s> from %f to %f\n",
var->name,
var->glbdom.ub, newbound);
7049 if(
SCIPsetIsEQ(
set, newbound,
var->glbdom.ub) && !(newbound !=
var->glbdom.ub && newbound *
var->glbdom.ub <= 0.0) )
7056 oldbound =
var->glbdom.ub;
7058 var->glbdom.ub = newbound;
7074 for(
i = 0;
i <
var->nubchginfos; ++
i )
7077 if(
var->ubchginfos[
i].oldbound >
var->glbdom.ub )
7079 SCIPsetDebugMsg(
set,
" -> adjust upper bound change <%s>: %g -> %g due to new global upper bound %g\n",
7081 var->ubchginfos[
i].oldbound =
var->glbdom.ub;
7085 var->ubchginfos[
i].newbound =
var->glbdom.ub;
7087 var->ubchginfos[
i].redundant =
TRUE;
7111 for(
i = 0;
i <
var->nparentvars; ++
i )
7113 parentvar =
var->parentvars[
i];
7126 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7142 parentnewbound = newbound;
7157 parentnewbound = -newbound;
7216 newbound =
MIN(newbound,
var->glbdom.ub);
7227 if(
SCIPsetIsEQ(
set,
var->glbdom.lb, newbound) && !(newbound !=
var->glbdom.lb && newbound *
var->glbdom.lb <= 0.0) )
7234 if(
var->data.original.transvar !=
NULL )
7237 cliquetable, newbound) );
7277 var->data.aggregate.var->glbdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7279 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7281 childnewbound = newbound;
7292 var->data.aggregate.var->glbdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7294 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7296 childnewbound = -newbound;
7308 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7316 var->data.negate.constant - newbound) );
7364 newbound =
MAX(newbound,
var->glbdom.lb);
7375 if(
SCIPsetIsEQ(
set,
var->glbdom.ub, newbound) && !(newbound !=
var->glbdom.ub && newbound *
var->glbdom.ub <= 0.0) )
7382 if(
var->data.original.transvar !=
NULL )
7425 var->data.aggregate.var->glbdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7427 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7429 childnewbound = newbound;
7440 var->data.aggregate.var->glbdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7442 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7444 childnewbound = -newbound;
7456 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7464 var->data.negate.constant - newbound) );
7493 var->lazylb = lazylb;
7516 var->lazyub = lazyub;
7567 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || newbound ==
var->glbdom.lb || (newbound != oldbound && newbound * oldbound <= 0.0));
7580 SCIPsetDebugMsg(
set,
"issue LBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
7605 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || newbound ==
var->glbdom.ub || (newbound != oldbound && newbound * oldbound <= 0.0));
7618 SCIPsetDebugMsg(
set,
"issue UBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
7676 newbound =
MIN(newbound,
var->locdom.ub);
7679 newbound =
MAX(newbound,
var->glbdom.lb);
7686 newbound =
var->glbdom.lb;
7687 else if(
SCIPsetIsEQ(
set, newbound,
var->locdom.lb) && !(newbound !=
var->locdom.lb && newbound *
var->locdom.lb <= 0.0) )
7691 oldbound =
var->locdom.lb;
7693 var->locdom.lb = newbound;
7715 for(
i = 0;
i <
var->nparentvars; ++
i )
7717 parentvar =
var->parentvars[
i];
7730 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7751 if( parentnewbound > parentvar->
glbdom.
ub )
7755 parentnewbound = parentvar->
glbdom.
ub;
7759 parentnewbound = newbound;
7779 if( parentnewbound < parentvar->glbdom.lb )
7783 parentnewbound = parentvar->
glbdom.
lb;
7787 parentnewbound = -newbound;
7843 newbound =
MAX(newbound,
var->locdom.lb);
7846 newbound =
MIN(newbound,
var->glbdom.ub);
7853 newbound =
var->glbdom.ub;
7854 else if(
SCIPsetIsEQ(
set, newbound,
var->locdom.ub) && !(newbound !=
var->locdom.ub && newbound *
var->locdom.ub <= 0.0) )
7858 oldbound =
var->locdom.ub;
7860 var->locdom.ub = newbound;
7882 for(
i = 0;
i <
var->nparentvars; ++
i )
7884 parentvar =
var->parentvars[
i];
7897 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7917 if( parentnewbound < parentvar->glbdom.lb )
7921 parentnewbound = parentvar->
glbdom.
lb;
7925 parentnewbound = newbound;
7944 if( parentnewbound > parentvar->
glbdom.
ub )
7948 parentnewbound = parentvar->
glbdom.
ub;
7952 parentnewbound = -newbound;
8007 newbound =
MIN(newbound,
var->locdom.ub);
8014 && !(newbound !=
var->locdom.lb && newbound *
var->locdom.lb <= 0.0) )
8021 if(
var->data.original.transvar !=
NULL )
8051 var->data.aggregate.var->locdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8053 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8055 childnewbound = newbound;
8066 var->data.aggregate.var->locdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8068 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8070 childnewbound = -newbound;
8082 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8090 var->data.negate.constant - newbound) );
8134 newbound =
MAX(newbound,
var->locdom.lb);
8141 && !(newbound !=
var->locdom.ub && newbound *
var->locdom.ub <= 0.0) )
8148 if(
var->data.original.transvar !=
NULL )
8177 var->data.aggregate.var->locdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8179 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8181 childnewbound = newbound;
8192 var->data.aggregate.var->locdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8194 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8196 childnewbound = -newbound;
8208 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8216 var->data.negate.constant - newbound) );
8288 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8303 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8305 childnewbound = newbound;
8314 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8316 childnewbound = -newbound;
8327 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8378 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8393 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8395 childnewbound = newbound;
8404 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8406 childnewbound = -newbound;
8417 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8460 lb =
var->data.multaggr.constant;
8461 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8463 aggrvar =
var->data.multaggr.vars[
i];
8464 if(
var->data.multaggr.scalars[
i] > 0.0 )
8473 lb +=
var->data.multaggr.scalars[
i] * bnd;
8484 lb +=
var->data.multaggr.scalars[
i] * bnd;
8526 ub =
var->data.multaggr.constant;
8527 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8529 aggrvar =
var->data.multaggr.vars[
i];
8530 if(
var->data.multaggr.scalars[
i] > 0.0 )
8539 ub +=
var->data.multaggr.scalars[
i] * bnd;
8550 ub +=
var->data.multaggr.scalars[
i] * bnd;
8592 lb =
var->data.multaggr.constant;
8593 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8595 aggrvar =
var->data.multaggr.vars[
i];
8596 if(
var->data.multaggr.scalars[
i] > 0.0 )
8605 lb +=
var->data.multaggr.scalars[
i] * bnd;
8616 lb +=
var->data.multaggr.scalars[
i] * bnd;
8658 ub =
var->data.multaggr.constant;
8659 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8661 aggrvar =
var->data.multaggr.vars[
i];
8662 if(
var->data.multaggr.scalars[
i] > 0.0 )
8671 ub +=
var->data.multaggr.scalars[
i] * bnd;
8682 ub +=
var->data.multaggr.scalars[
i] * bnd;
8793 newlb =
var->glbdom.lb;
8794 newub =
var->glbdom.ub;
8805 if(
var->eventfilter !=
NULL )
8811 for(
i = 0;
i <
var->nparentvars; ++
i )
8817 parentvar =
var->parentvars[
i];
8823 parentnewleft = left;
8824 parentnewright = right;
8831 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8873 parentnewleft, parentnewright, &localadded) );
8917 if(
var->data.original.transvar !=
NULL )
8920 left, right, added) );
8957 childnewleft = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8958 childnewright = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8962 childnewright = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8963 childnewleft = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8971 childnewleft, childnewright, added) );
8983 childnewright = -left +
var->data.negate.constant;
8984 childnewleft = -right +
var->data.negate.constant;
8987 childnewleft, childnewright, added) );
9039 newlb =
var->locdom.lb;
9040 newub =
var->locdom.ub;
9049#ifdef SCIP_DISABLED_CODE
9058 for(
i = 0;
i <
var->nparentvars; ++
i )
9064 parentvar =
var->parentvars[
i];
9070 parentnewleft = left;
9071 parentnewright = right;
9078 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
9120 parentnewleft, parentnewright, &localadded) );
9167 if(
var->data.original.transvar !=
NULL )
9170 left, right, added) );
9196 childnewleft = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9197 childnewright = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9201 childnewright = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9202 childnewleft = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9210 childnewleft, childnewright, added) );
9214 SCIPerrorMessage(
"cannot add domain hole to a multi-aggregated variable.\n");
9222 childnewright = -left +
var->data.negate.constant;
9223 childnewleft = -right +
var->data.negate.constant;
9375 var->closestvblpcount = -1;
9443 *infeasible =
FALSE;
9473 if( nbdchgs !=
NULL )
9503 if( nbdchgs !=
NULL )
9555 *infeasible =
FALSE;
9559 checkImplic(
set, implvar, impltype, implbound, &redundant, &conflict);
9560 assert(!redundant || !conflict);
9564 if(
var == implvar )
9589 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
9590 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
9612 vals[0] = varfixing;
9616 SCIP_CALL(
SCIPcliquetableAdd(cliquetable, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
9617 eventqueue,
vars, vals, 2,
FALSE, &conflict, nbdchgs) );
9629 isshortcut, &conflict, added) );
9632 assert(!conflict || !(*added));
9670 if( nbdchgs !=
NULL )
9708 varfixing ? implbound - ub : ub - implbound, varfixing ? ub : implbound) );
9716 varfixing ? implbound - lb : lb - implbound, varfixing ? lb : implbound) );
9752 *infeasible =
FALSE;
9769 while (
i >= 0 && !(*infeasible) )
9773 assert(implvars[
i] != implvar);
9780 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9781 eventqueue, varfixing, implvars[
i], impltypes[
i], implbounds[
i],
TRUE, infeasible, nbdchgs, &added) );
9831 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9832 eventqueue, varfixing, implvar, impltype, implbound,
FALSE, infeasible, nbdchgs, &added) );
9834 if( *infeasible ||
var == implvar || !transitive || !added )
9848 cliquetable, branchcand, eventqueue, varfixing, implvar, implvarfixing, infeasible, nbdchgs) );
9851 if( !(*infeasible) )
9854 cliquetable, branchcand, eventqueue, !implvarfixing,
var, !varfixing, infeasible, nbdchgs) );
9880 while (
i >= 0 && !(*infeasible) )
9882 assert(vlbvars[
i] != implvar);
9907 vbimplbound = (implbound - vlbconstants[
i])/vlbcoefs[
i];
9908 if( vlbcoefs[
i] >= 0.0 )
9911 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9913 infeasible, nbdchgs, &added) );
9918 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9920 infeasible, nbdchgs, &added) );
9923 i =
MIN(
i, nvlbvars);
9950 while (
i >= 0 && !(*infeasible) )
9952 assert(vubvars[
i] != implvar);
9977 vbimplbound = (implbound - vubconstants[
i])/vubcoefs[
i];
9978 if( vubcoefs[
i] >= 0.0 )
9981 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9983 infeasible, nbdchgs, &added) );
9988 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9990 infeasible, nbdchgs, &added) );
9993 i =
MIN(
i, nvubvars);
10036 *infeasible =
FALSE;
10037 if( nbdchgs !=
NULL )
10045 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef, vlbconstant, transitive, infeasible, nbdchgs) );
10053 SCIPsetDebugMsg(
set,
" -> transformed to variable lower bound <%s> >= %g<%s> + %g\n",
10057 if(
var == vlbvar )
10063 *infeasible =
TRUE;
10073 SCIP_Real newub = vlbconstant / (1.0 - vlbcoef);
10077 *infeasible =
TRUE;
10102 if( nbdchgs !=
NULL )
10113 newlb = vlbconstant / (1.0 - vlbcoef);
10117 *infeasible =
TRUE;
10142 if( nbdchgs !=
NULL )
10152 *infeasible =
TRUE;
10172 if( nbdchgs !=
NULL )
10197 if( vlbcoef >= 0.0 )
10204 newzub = (xub - vlbconstant)/vlbcoef;
10212 *infeasible =
TRUE;
10238 if( nbdchgs !=
NULL )
10241 maxvlb = vlbcoef * zub + vlbconstant;
10243 minvlb = vlbcoef * zlb + vlbconstant;
10248 maxvlb = vlbcoef * zub + vlbconstant;
10250 minvlb = vlbcoef * zlb + vlbconstant;
10260 newzlb = (xub - vlbconstant)/vlbcoef;
10268 *infeasible =
TRUE;
10294 if( nbdchgs !=
NULL )
10297 maxvlb = vlbcoef * zlb + vlbconstant;
10299 minvlb = vlbcoef * zub + vlbconstant;
10304 maxvlb = vlbcoef * zlb + vlbconstant;
10306 minvlb = vlbcoef * zub + vlbconstant;
10309 if( maxvlb < minvlb )
10319 *infeasible =
TRUE;
10346 if( nbdchgs !=
NULL )
10360 if( vlbcoef >= 0.0 )
10362 vlbcoef = maxvlb - minvlb;
10363 vlbconstant = minvlb;
10367 vlbcoef = minvlb - maxvlb;
10368 vlbconstant = maxvlb;
10389 infeasible, nbdchgs) );
10398 implbound = -vlbconstant/vlbcoef;
10410 implbound, transitive, infeasible, nbdchgs) );
10430 if(
var->data.aggregate.var == vlbvar &&
SCIPsetIsEQ(
set,
var->data.aggregate.scalar, vlbcoef) )
10433 *infeasible =
TRUE;
10439 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10440 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10446 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10447 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10465 SCIP_CALL(
SCIPvarAddVub(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10466 branchcand, eventqueue, vlbvar, -vlbcoef,
var->data.negate.constant - vlbconstant, transitive, infeasible,
10511 *infeasible =
FALSE;
10512 if( nbdchgs !=
NULL )
10520 cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );
10528 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10532 if(
var == vubvar )
10538 *infeasible =
TRUE;
10548 SCIP_Real newlb = vubconstant / (1.0 - vubcoef);
10552 *infeasible =
TRUE;
10577 if( nbdchgs !=
NULL )
10588 newub = vubconstant / (1.0 - vubcoef);
10592 *infeasible =
TRUE;
10617 if( nbdchgs !=
NULL )
10627 *infeasible =
TRUE;
10647 if( nbdchgs !=
NULL )
10672 if( vubcoef >= 0.0 )
10679 newzlb = (xlb - vubconstant)/vubcoef;
10682 *infeasible =
TRUE;
10708 if( nbdchgs !=
NULL )
10711 minvub = vubcoef * zlb + vubconstant;
10713 maxvub = vubcoef * zub + vubconstant;
10718 maxvub = vubcoef * zub + vubconstant;
10720 minvub = vubcoef * zlb + vubconstant;
10730 newzub = (xlb - vubconstant)/vubcoef;
10733 *infeasible =
TRUE;
10759 if( nbdchgs !=
NULL )
10762 minvub = vubcoef * zub + vubconstant;
10764 maxvub = vubcoef * zlb + vubconstant;
10769 minvub = vubcoef * zub + vubconstant;
10771 maxvub = vubcoef * zlb + vubconstant;
10774 if( minvub > maxvub )
10784 *infeasible =
TRUE;
10812 if( nbdchgs !=
NULL )
10826 if( vubcoef >= 0.0 )
10828 vubcoef = maxvub - minvub;
10829 vubconstant = minvub;
10833 vubcoef = minvub - maxvub;
10834 vubconstant = maxvub;
10855 infeasible, nbdchgs) );
10865 (1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );
10885 if(
var->data.aggregate.var == vubvar &&
SCIPsetIsEQ(
set,
var->data.aggregate.scalar, vubcoef) )
10888 *infeasible =
TRUE;
10894 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10895 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10901 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10902 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10920 SCIP_CALL(
SCIPvarAddVlb(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10921 branchcand, eventqueue, vubvar, -vubcoef,
var->data.negate.constant - vubconstant, transitive, infeasible,
10967 *infeasible =
FALSE;
10968 if( nbdchgs !=
NULL )
10976 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10990 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10991 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
11000 SCIP_CALL(
varAddTransitiveImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11001 branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11010 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
11011 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
11031 if(
var->data.aggregate.scalar > 0 )
11034 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
11040 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,
11064 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11072 SCIP_CALL(
SCIPvarAddImplic(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11075 infeasible, nbdchgs) );
11090 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? 1.0 : -1.0,
11099 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? -1.0 : 1.0,
11109 SCIP_CALL(
SCIPvarAddVub(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11110 branchcand, eventqueue,
var->negatedvar, (varfixing) ? 1.0 : -1.0,
11111 (varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );
11118 SCIP_CALL(
SCIPvarAddVlb(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11119 branchcand, eventqueue,
var->negatedvar, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,
11120 transitive, infeasible, nbdchgs) );
11197 if( bounds ==
NULL )
11200 if( lowerpos >= 0 )
11201 *lb = bounds[lowerpos];
11203 if( upperpos >= 0 )
11204 *ub = bounds[upperpos];
11232 *infeasible =
FALSE;
11234 if( value ==
FALSE )
11236 if(
var->glbdom.lb > 0.5 )
11237 *infeasible =
TRUE;
11238 else if(
var->glbdom.ub > 0.5 )
11257 if( nbdchgs !=
NULL )
11263 if(
var->glbdom.ub < 0.5 )
11264 *infeasible =
TRUE;
11265 else if(
var->glbdom.lb < 0.5 )
11284 if( nbdchgs !=
NULL )
11322 *infeasible =
FALSE;
11350 SCIP_CALL(
SCIPvarFixBinary(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11351 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
11357 if( oppositeentry )
11367 for(
i = 0;
i <
nvars && !(*infeasible); ++
i )
11372 SCIP_CALL(
SCIPvarFixBinary(
vars[
i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11373 eventqueue, cliquetable, !values[
i], infeasible, nbdchgs) );
11401 for( v =
nvars - 1; v >= 0; --v )
11539 branchfactor =
MAX(branchfactor,
eps);
11541 SCIPsetDebugMsg(
set,
"process changing branch factor of <%s> from %f to %f\n",
var->name,
var->branchfactor, branchfactor);
11547 var->branchfactor = branchfactor;
11550 for(
i = 0;
i <
var->nparentvars; ++
i )
11552 parentvar =
var->parentvars[
i];
11565 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11598 assert(branchfactor >= 0.0);
11600 SCIPdebugMessage(
"changing branch factor of <%s> from %g to %g\n",
var->name,
var->branchfactor, branchfactor);
11609 if(
var->data.original.transvar !=
NULL )
11616 var->branchfactor = branchfactor;
11634 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11668 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11669 var->name,
var->branchpriority, branchpriority);
11671 if( branchpriority ==
var->branchpriority )
11675 var->branchpriority = branchpriority;
11678 for(
i = 0;
i <
var->nparentvars; ++
i )
11680 parentvar =
var->parentvars[
i];
11693 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11723 SCIPdebugMessage(
"changing branch priority of <%s> from %d to %d\n",
var->name,
var->branchpriority, branchpriority);
11725 if(
var->branchpriority == branchpriority )
11732 if(
var->data.original.transvar !=
NULL )
11737 var->branchpriority = branchpriority;
11754 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11788 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11789 var->name,
var->branchdirection, branchdirection);
11795 var->branchdirection = branchdirection;
11798 for(
i = 0;
i <
var->nparentvars; ++
i )
11800 parentvar =
var->parentvars[
i];
11813 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11854 SCIPdebugMessage(
"changing branch direction of <%s> from %u to %d\n",
var->name,
var->branchdirection, branchdirection);
11863 if(
var->data.original.transvar !=
NULL )
11868 var->branchdirection = branchdirection;
11880 if(
var->data.aggregate.scalar > 0.0 )
11892 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11898 if(
var->data.multaggr.scalars[v] > 0.0 )
12005 else if( obj1 > obj2 )
12047 int activevarssize;
12071 activevarssize = *
nvars;
12073 tmpvarssize = *
nvars;
12080 noldtmpvars = ntmpvars;
12083 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12084 for( v = ntmpvars - 1; v > 0; --v )
12090 tmpvars[v] = tmpvars[ntmpvars];
12094 if( noldtmpvars > ntmpvars )
12095 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12098 while( ntmpvars >= 1 )
12101 var = tmpvars[ntmpvars];
12107 if(
var->data.original.transvar ==
NULL )
12109 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12113 tmpvars[ntmpvars] =
var->data.original.transvar;
12118 tmpvars[ntmpvars] =
var->data.aggregate.var;
12123 tmpvars[ntmpvars] =
var->negatedvar;
12130 if( nactivevars >= activevarssize )
12132 activevarssize *= 2;
12134 assert(nactivevars < activevarssize);
12136 activevars[nactivevars] =
var;
12142 nmultvars =
var->data.multaggr.nvars;
12143 multvars =
var->data.multaggr.vars;
12146 if( nmultvars + ntmpvars > tmpvarssize )
12148 while( nmultvars + ntmpvars > tmpvarssize )
12151 assert(nmultvars + ntmpvars <= tmpvarssize);
12160 ntmpvars += nmultvars;
12161 noldtmpvars = ntmpvars;
12164 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12165 for( v = ntmpvars - 1; v > 0; --v )
12171 tmpvars[v] = tmpvars[ntmpvars];
12175 if( noldtmpvars > ntmpvars )
12176 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12192 SCIPsortPtr((
void**)activevars, SCIPvarComp, nactivevars);
12195 v = nactivevars - 1;
12202 activevars[v] = activevars[nactivevars];
12206 *requiredsize = nactivevars;
12208 if( varssize >= *requiredsize )
12212 *
nvars = *requiredsize;
12234 for( v =
nvars - 1; v >= 0; --v )
12266 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12320 for( v =
nvars - 1; v >= 0; --v )
12322 var = &((*vars)[v]);
12323 negated = &((*negatedarr)[v]);
12354 orignegated = *negated;
12362 if( (*var)->data.original.transvar ==
NULL )
12364 *
var = (*var)->data.original.transvar;
12375 if ( (*var)->data.multaggr.nvars == 1 )
12377 assert( (*var)->data.multaggr.vars !=
NULL );
12378 assert( (*var)->data.multaggr.scalars !=
NULL );
12380 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1e-06));
12390 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)) )
12392 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12401 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )
12411 assert(
EPSZ((*var)->data.multaggr.constant, 1e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06)
12412 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)
12413 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12415 if( !
EPSZ((*var)->data.multaggr.constant, 1e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) )
12421 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12423 if(
EPSZ((*var)->data.multaggr.constant, 1e-06) )
12429 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?
12435 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12437 constant += (*negated) != orignegated ? -1.0 : 1.0;
12440 *negated = !(*negated);
12442 *
var = (*var)->data.multaggr.vars[0];
12451 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1e-06));
12452 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));
12454 constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
12457 *negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);
12458 *
var = (*var)->data.aggregate.var;
12464 constant += (*negated) != orignegated ? -1.0 : 1.0;
12467 *negated = !(*negated);
12468 *
var = (*var)->negatedvar;
12482 assert(
EPSZ(constant, 1e-06) == ((*negated) == orignegated));
12507 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
12512 if( (*var)->data.original.transvar ==
NULL )
12514 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12517 *
var = (*var)->data.original.transvar;
12528 if ( (*var)->data.multaggr.nvars == 1 )
12530 assert( (*var)->data.multaggr.vars !=
NULL );
12531 assert( (*var)->data.multaggr.scalars !=
NULL );
12532 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
12534 (*bound) /= (*var)->data.multaggr.scalars[0];
12535 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
12536 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
12543 *
var = (*var)->data.multaggr.vars[0];
12550 assert((*var)->data.aggregate.scalar != 0.0);
12552 (*bound) /= (*var)->data.aggregate.scalar;
12553 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12554 if( (*var)->data.aggregate.scalar < 0.0 )
12561 *
var = (*var)->data.aggregate.var;
12568 assert((*var)->negatedvar->negatedvar == *
var);
12569 (*bound) = (*var)->data.negate.constant - *
bound;
12574 *
var = (*var)->negatedvar;
12600 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
12605 if( (*var)->data.original.transvar ==
NULL )
12607 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12610 *
var = (*var)->data.original.transvar;
12622 assert((*var)->data.aggregate.scalar != 0.0);
12625 (*left) /= (*var)->data.aggregate.scalar;
12626 (*right) /= (*var)->data.aggregate.scalar;
12629 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12630 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12632 *
var = (*var)->data.aggregate.var;
12635 if( (*var)->data.aggregate.scalar < 0.0 )
12648 assert((*var)->negatedvar->negatedvar == *
var);
12651 (*left) = (*var)->data.negate.constant - (*left);
12652 (*right) = (*var)->data.negate.constant - (*right);
12654 *
var = (*var)->negatedvar;
12690 if( (*var)->data.original.transvar ==
NULL )
12692 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12695 *
var = (*var)->data.original.transvar;
12708 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12714 (*constant) += *scalar * (*var)->glbdom.lb;
12730 if ( (*var)->data.multaggr.nvars == 1 )
12733 assert((*var)->data.multaggr.scalars !=
NULL);
12734 assert((*var)->data.multaggr.vars[0] !=
NULL);
12744 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12757 (*constant) += *scalar * (*var)->data.multaggr.constant;
12759 (*scalar) *= (*var)->data.multaggr.scalars[0];
12760 *
var = (*var)->data.multaggr.vars[0];
12770 (*constant) += *scalar * (*var)->data.aggregate.constant;
12771 (*scalar) *= (*var)->data.aggregate.scalar;
12772 *
var = (*var)->data.aggregate.var;
12778 assert((*var)->negatedvar->negatedvar == *
var);
12782 (*constant) += *scalar * (*var)->data.negate.constant;
12784 *
var = (*var)->negatedvar;
12819 if( (*var)->nparentvars == 0 )
12825 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *
var) )
12828 *constant -= (*var)->data.negate.constant * (*scalar);
12829 *
var = (*var)->negatedvar;
12857 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12899 parentvar =
var->parentvars[0];
12939 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12981 return var->locdom.lb;
12990 else if(
var->data.aggregate.scalar > 0.0 )
12995 else if(
var->data.aggregate.scalar < 0.0 )
13009 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
13051 return var->locdom.ub;
13060 if(
var->data.aggregate.scalar > 0.0 )
13065 else if(
var->data.aggregate.scalar < 0.0 )
13078 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
13105 if(
var->data.original.transvar ==
NULL )
13118 return var->locdom.lb;
13137 return var->data.aggregate.scalar * lpsolval +
var->data.aggregate.constant;
13151 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13186 return var->nlpsol;
13196 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13199 solval =
var->data.multaggr.constant;
13200 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13206 return var->data.negate.constant - solval;
13229 if(
var->data.original.transvar ==
NULL )
13239 return var->locdom.lb;
13256 return var->data.aggregate.scalar * pseudosolval +
var->data.aggregate.constant;
13265 pseudosol =
var->data.multaggr.constant;
13266 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13333 if(
var->bestrootredcost > 0.0 )
13338 currcutoffbound = (
bound -
var->bestrootsol) *
var->bestrootredcost +
var->bestrootlpobjval;
13343 if( rootredcost > 0.0 )
13348 cutoffbound = (
bound -
rootsol) * rootredcost + rootlpobjval;
13351 if( cutoffbound > currcutoffbound )
13357 var->bestrootredcost = rootredcost;
13358 var->bestrootlpobjval = rootlpobjval;
13369 var->bestrootredcost = rootredcost;
13370 var->bestrootlpobjval = rootlpobjval;
13389 if(
var->data.original.transvar ==
NULL )
13395 return var->rootsol;
13399 return var->locdom.lb;
13423 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13491#define MAX_CLIQUELENGTH 50
13514#ifdef SCIP_MORE_DEBUG
13552 for(
c = ncliques - 1;
c >= 0; --
c )
13554 clique = cliques[
c];
13569 for( v = nclqvars - 1; v >= 0; --v )
13571 clqvar = clqvars[v];
13579 assert(0 < probindex && probindex < nentries);
13581#ifdef SCIP_DISABLED_CODE
13585 assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));
13587 if( entries[probindex] == 0 )
13589 ids[nids] = probindex;
13593 entries[probindex] = (clqvalues[v] ? probindex : -probindex);
13603 for( v = nids - 1; v >= 0; --v )
13606 assert(0 <
id &&
id < nentries);
13607 assert(entries[
id] != 0);
13613 if( (entries[
id] > 0) != varfixing )
13619 implredcost += redcost;
13629#ifdef SCIP_MORE_DEBUG
13655 for( v =
nvars - 1; v >= 0; --v )
13683 redcost *= (lb - bounds[v]);
13685 redcost *= (bounds[v] - lb);
13693 redcost *= (bounds[v] - ub);
13695 redcost *= (ub - bounds[v]);
13709 redcost *= (lb - bounds[v]);
13711 redcost *= (bounds[v] - lb);
13719 redcost *= (bounds[v] - ub);
13721 redcost *= (ub - bounds[v]);
13727 implredcost += redcost;
13731#ifdef SCIP_MORE_DEBUG
13732 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13736 return implredcost;
13754 if(
var->data.original.transvar ==
NULL )
13760 return var->bestrootsol;
13764 return var->locdom.lb;
13788 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13818 if(
var->data.original.transvar ==
NULL )
13824 return var->bestrootredcost;
13852 if(
var->data.original.transvar ==
NULL )
13858 return var->bestrootlpobjval;
13884 var->bestrootredcost = rootredcost;
13885 var->bestrootlpobjval = rootlpobjval;
13913 var->relaxsol = solval;
13919 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13928 (solval -
var->data.aggregate.constant)/
var->data.aggregate.scalar, updateobj) );
13931 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13971 return var->relaxsol;
13983 if(
var->data.aggregate.scalar * solval > 0.0 )
13985 if(
var->data.aggregate.scalar * solval < 0.0 )
13988 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13991 solvalsum =
var->data.multaggr.constant;
13992 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13997 if(
var->data.multaggr.scalars[
i] * solval > 0.0 )
13999 if(
var->data.multaggr.scalars[
i] * solval < 0.0 )
14002 solvalsum +=
var->data.multaggr.scalars[
i] * solval;
14012 return var->data.negate.constant - solval;
14029 return var->relaxsol;
14052 var->nlpsol = solval;
14058 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
14071 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14101 if(
var->data.original.transvar ==
NULL )
14107 avgsol =
var->primsolavg;
14108 avgsol =
MAX(avgsol,
var->glbdom.lb);
14109 avgsol =
MIN(avgsol,
var->glbdom.ub);
14114 return var->locdom.lb;
14120 +
var->data.aggregate.constant;
14129 avgsol =
var->data.multaggr.constant;
14130 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14168 *closestvlbidx = -1;
14186 i =
var->closestvlbidx;
14189 *closestvlbidx =
i;
14195 for(
i = 0;
i < nvlbs;
i++ )
14202 if( vlbsol > *closestvlb )
14204 *closestvlb = vlbsol;
14205 *closestvlbidx =
i;
14213 if(
var->closestvblpcount != stat->
lpcount )
14214 var->closestvubidx = -1;
14215 var->closestvlbidx = *closestvlbidx;
14242 *closestvubidx = -1;
14260 i =
var->closestvubidx;
14263 *closestvubidx =
i;
14269 for(
i = 0;
i < nvubs;
i++ )
14276 if( vubsol < *closestvub )
14278 *closestvub = vubsol;
14279 *closestvubidx =
i;
14287 if(
var->closestvblpcount != stat->
lpcount )
14288 var->closestvlbidx = -1;
14289 var->closestvubidx = *closestvubidx;
14325 if(
var->data.original.transvar ==
NULL )
14363 row,
var->data.aggregate.scalar * val) );
14374 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14377 row,
var->data.multaggr.scalars[
i] * val) );
14397#ifdef SCIP_HISTORYTOFILE
14399const char* historypath=
".";
14428 if(
var->data.original.transvar ==
NULL )
14430 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
14451#ifdef SCIP_HISTORYTOFILE
14454 char filename[256];
14461 f = fopen(filename,
"a");
14464 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
14480 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
14486 solvaldelta/
var->data.aggregate.scalar, objdelta, weight) );
14490 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
14518 if(
var->data.original.transvar ==
NULL )
14567 if(
var->data.original.transvar ==
NULL )
14611 if(
var->data.original.transvar ==
NULL )
14624 if(
var->data.aggregate.scalar > 0.0 )
14656 if(
var->data.original.transvar ==
NULL )
14669 if(
var->data.aggregate.scalar > 0.0 )
14715 return MIN(upscore, downscore);
14731 if(
var->data.original.transvar ==
NULL )
14738 if( onlycurrentrun )
14747 if(
var->data.aggregate.scalar > 0.0 )
14788 if( onlycurrentrun )
14795 confidencebound /= count;
14796 confidencebound = sqrt(confidencebound);
14803 confidencebound = 0.0;
14805 return confidencebound;
14829 size =
MIN(downsize, upsize);
14839 if( downsize >= 1.9 )
14845 normval =
MAX(1.0, normval);
14847 relerrordown /= normval;
14850 relerrordown = 0.0;
14852 if( upsize >= 1.9 )
14858 normval =
MAX(1.0, normval);
14859 relerrorup /= normval;
14865 relerror =
MAX(relerrorup, relerrordown);
14867 return (relerror <= threshold);
14916 if( countx <= 1.9 || county <= 1.9 )
15013 SCIPerrorMessage(
"Confidence level set to unknown value <%d>", (
int)clevel);
15018 return (probability >= problimit);
15038 if(
var->valuehistory ==
NULL )
15063 if( !
set->history_valuebased )
15101 if(
var->data.original.transvar ==
NULL )
15103 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15134 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15136 if(
var->data.aggregate.scalar > 0.0 )
15142 assert(
var->data.aggregate.scalar < 0.0);
15152 value = 1.0 - value;
15174 if(
var->data.original.transvar ==
NULL )
15176 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15234 if(
var->data.original.transvar ==
NULL )
15236 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
15265 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15267 if(
var->data.aggregate.scalar > 0.0 )
15273 assert(
var->data.aggregate.scalar < 0.0);
15279 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
15283 value = 1.0 - value;
15308 if(
var->data.original.transvar ==
NULL )
15321 if(
var->data.aggregate.scalar > 0.0 )
15355 if(
var->data.original.transvar ==
NULL )
15368 if(
var->data.aggregate.scalar > 0.0 )
15398 if(
var->data.original.transvar ==
NULL )
15410 if(
var->data.aggregate.scalar > 0.0 )
15442 if(
var->data.original.transvar ==
NULL )
15455 if(
var->data.aggregate.scalar > 0.0 )
15495 if(
var->data.original.transvar ==
NULL )
15497 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
15524 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
15528 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15530 if(
var->data.aggregate.scalar > 0.0 )
15536 assert(
var->data.aggregate.scalar < 0.0);
15542 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
15546 value = 1.0 - value;
15579 if(
var->data.original.transvar ==
NULL )
15581 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
15608 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15612 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15614 if(
var->data.aggregate.scalar > 0.0 )
15620 assert(
var->data.aggregate.scalar < 0.0);
15626 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15630 value = 1.0 - value;
15663 if(
var->data.original.transvar ==
NULL )
15665 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15696 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15698 if(
var->data.aggregate.scalar > 0.0 )
15704 assert(
var->data.aggregate.scalar < 0.0);
15710 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15714 value = 1.0 - value;
15737 if(
var->data.original.transvar ==
NULL )
15750 if(
var->data.aggregate.scalar > 0.0 )
15782 if(
var->data.original.transvar ==
NULL )
15795 if(
var->data.aggregate.scalar > 0.0 )
15825 if(
var->data.original.transvar ==
NULL )
15838 if(
var->data.aggregate.scalar > 0.0 )
15870 if(
var->data.original.transvar ==
NULL )
15883 if(
var->data.aggregate.scalar > 0.0 )
15920 if(
var->data.original.transvar ==
NULL )
15934 if(
var->data.aggregate.scalar > 0.0 )
15967 SCIPerrorMessage(
"invalid branching direction %d when asking for VSIDS value\n", dir);
15974 if(
var->data.original.transvar ==
NULL )
15987 if(
var->data.aggregate.scalar > 0.0 )
16017 if(
var->data.original.transvar ==
NULL )
16030 if(
var->data.aggregate.scalar > 0.0 )
16062 if(
var->data.original.transvar ==
NULL )
16075 if(
var->data.aggregate.scalar > 0.0 )
16107 if(
var->data.original.transvar ==
NULL )
16130 if(
var->data.aggregate.scalar > 0.0 )
16164 if(
var->data.original.transvar ==
NULL )
16187 if(
var->data.aggregate.scalar > 0.0 )
16217 if(
var->data.original.transvar ==
NULL )
16230 if(
var->data.aggregate.scalar > 0.0 )
16260 if(
var->data.original.transvar ==
NULL )
16273 if(
var->data.aggregate.scalar > 0.0 )
16305 if(
var->data.original.transvar ==
NULL )
16320 if(
var->data.aggregate.scalar > 0.0 )
16352 if(
var->data.original.transvar ==
NULL )
16367 if(
var->data.aggregate.scalar > 0.0 )
16397 if(
var->data.original.transvar ==
NULL )
16439 if(
var->data.original.transvar !=
NULL )
16481 if(
var->data.original.transvar !=
NULL )
16523 if(
var->data.original.transvar !=
NULL )
16572 (*bdchginfo)->oldbound = oldbound;
16573 (*bdchginfo)->newbound = newbound;
16574 (*bdchginfo)->var =
var;
16575 (*bdchginfo)->inferencedata.var =
var;
16576 (*bdchginfo)->inferencedata.reason.prop =
NULL;
16577 (*bdchginfo)->inferencedata.info = 0;
16578 (*bdchginfo)->bdchgidx.depth = INT_MAX;
16579 (*bdchginfo)->bdchgidx.pos = -1;
16580 (*bdchginfo)->pos = 0;
16582 (*bdchginfo)->boundtype = boundtype;
16583 (*bdchginfo)->inferboundtype = boundtype;
16584 (*bdchginfo)->redundant =
FALSE;
16618 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16625 if(
var->lbchginfos[
i].redundant )
16627 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16631 return &
var->lbchginfos[
i];
16636 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16643 if(
var->lbchginfos[
i].redundant )
16645 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16649 return &
var->lbchginfos[
i];
16674 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16681 if(
var->ubchginfos[
i].redundant )
16683 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16687 return &
var->ubchginfos[
i];
16692 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16699 if(
var->ubchginfos[
i].redundant )
16701 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16705 return &
var->ubchginfos[
i];
16749 switch( varstatus )
16757 if( bdchgidx ==
NULL )
16764 if( bdchginfo !=
NULL )
16767 return var->glbdom.lb;
16770 return var->glbdom.lb;
16781 if(
var->data.aggregate.scalar > 0.0 )
16787 +
var->data.aggregate.constant;
16789 else if(
var->data.aggregate.scalar < 0.0 )
16795 +
var->data.aggregate.constant;
16806 if (
var->data.multaggr.nvars == 1 )
16812 if(
var->data.multaggr.scalars[0] > 0.0 )
16818 +
var->data.multaggr.constant;
16820 else if(
var->data.multaggr.scalars[0] < 0.0 )
16826 +
var->data.multaggr.constant;
16835 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16868 switch( varstatus )
16876 if( bdchgidx ==
NULL )
16883 if( bdchginfo !=
NULL )
16886 return var->glbdom.ub;
16890 return var->glbdom.ub;
16901 if(
var->data.aggregate.scalar > 0.0 )
16907 +
var->data.aggregate.constant;
16909 else if(
var->data.aggregate.scalar < 0.0 )
16915 +
var->data.aggregate.constant;
16926 if (
var->data.multaggr.nvars == 1 )
16932 if(
var->data.multaggr.scalars[0] > 0.0 )
16938 +
var->data.multaggr.constant;
16940 else if(
var->data.multaggr.scalars[0] < 0.0 )
16946 +
var->data.multaggr.constant;
16955 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
17042 lbchgidx = (
var->nlbchginfos > 0 && !
var->lbchginfos[
var->nlbchginfos-1].redundant
17044 ubchgidx = (
var->nubchginfos > 0 && !
var->ubchginfos[
var->nubchginfos-1].redundant
17066 return bdchgidx->
depth;
17109 return var->ubchginfos[
i].bdchgidx.depth;
17137 return var->lbchginfos[
i].bdchgidx.depth;
17225#undef SCIPboundchgGetNewbound
17226#undef SCIPboundchgGetVar
17227#undef SCIPboundchgGetBoundchgtype
17228#undef SCIPboundchgGetBoundtype
17229#undef SCIPboundchgIsRedundant
17230#undef SCIPdomchgGetNBoundchgs
17231#undef SCIPdomchgGetBoundchg
17232#undef SCIPholelistGetLeft
17233#undef SCIPholelistGetRight
17234#undef SCIPholelistGetNext
17235#undef SCIPvarGetName
17236#undef SCIPvarGetNUses
17237#undef SCIPvarGetData
17238#undef SCIPvarSetData
17239#undef SCIPvarSetDelorigData
17240#undef SCIPvarSetTransData
17241#undef SCIPvarSetDeltransData
17242#undef SCIPvarGetStatus
17243#undef SCIPvarIsOriginal
17244#undef SCIPvarIsTransformed
17245#undef SCIPvarIsNegated
17246#undef SCIPvarGetType
17247#undef SCIPvarIsBinary
17248#undef SCIPvarIsIntegral
17249#undef SCIPvarIsInitial
17250#undef SCIPvarIsRemovable
17251#undef SCIPvarIsDeleted
17252#undef SCIPvarIsDeletable
17253#undef SCIPvarMarkDeletable
17254#undef SCIPvarMarkNotDeletable
17255#undef SCIPvarIsActive
17256#undef SCIPvarGetIndex
17257#undef SCIPvarGetProbindex
17258#undef SCIPvarGetTransVar
17259#undef SCIPvarGetCol
17260#undef SCIPvarIsInLP
17261#undef SCIPvarGetAggrVar
17262#undef SCIPvarGetAggrScalar
17263#undef SCIPvarGetAggrConstant
17264#undef SCIPvarGetMultaggrNVars
17265#undef SCIPvarGetMultaggrVars
17266#undef SCIPvarGetMultaggrScalars
17267#undef SCIPvarGetMultaggrConstant
17268#undef SCIPvarGetNegatedVar
17269#undef SCIPvarGetNegationVar
17270#undef SCIPvarGetNegationConstant
17271#undef SCIPvarGetObj
17272#undef SCIPvarGetLbOriginal
17273#undef SCIPvarGetUbOriginal
17274#undef SCIPvarGetHolelistOriginal
17275#undef SCIPvarGetLbGlobal
17276#undef SCIPvarGetUbGlobal
17277#undef SCIPvarGetHolelistGlobal
17278#undef SCIPvarGetBestBoundGlobal
17279#undef SCIPvarGetWorstBoundGlobal
17280#undef SCIPvarGetLbLocal
17281#undef SCIPvarGetUbLocal
17282#undef SCIPvarGetHolelistLocal
17283#undef SCIPvarGetBestBoundLocal
17284#undef SCIPvarGetWorstBoundLocal
17285#undef SCIPvarGetBestBoundType
17286#undef SCIPvarGetWorstBoundType
17287#undef SCIPvarGetLbLazy
17288#undef SCIPvarGetUbLazy
17289#undef SCIPvarGetBranchFactor
17290#undef SCIPvarGetBranchPriority
17291#undef SCIPvarGetBranchDirection
17292#undef SCIPvarGetNVlbs
17293#undef SCIPvarGetVlbVars
17294#undef SCIPvarGetVlbCoefs
17295#undef SCIPvarGetVlbConstants
17296#undef SCIPvarGetNVubs
17297#undef SCIPvarGetVubVars
17298#undef SCIPvarGetVubCoefs
17299#undef SCIPvarGetVubConstants
17300#undef SCIPvarGetNImpls
17301#undef SCIPvarGetImplVars
17302#undef SCIPvarGetImplTypes
17303#undef SCIPvarGetImplBounds
17304#undef SCIPvarGetImplIds
17305#undef SCIPvarGetNCliques
17306#undef SCIPvarGetCliques
17307#undef SCIPvarGetLPSol
17308#undef SCIPvarGetNLPSol
17309#undef SCIPvarGetBdchgInfoLb
17310#undef SCIPvarGetNBdchgInfosLb
17311#undef SCIPvarGetBdchgInfoUb
17312#undef SCIPvarGetNBdchgInfosUb
17313#undef SCIPvarGetValuehistory
17314#undef SCIPvarGetPseudoSol
17315#undef SCIPvarCatchEvent
17316#undef SCIPvarDropEvent
17317#undef SCIPvarGetVSIDS
17318#undef SCIPvarGetCliqueComponentIdx
17319#undef SCIPvarIsRelaxationOnly
17320#undef SCIPvarMarkRelaxationOnly
17321#undef SCIPbdchgidxGetPos
17322#undef SCIPbdchgidxIsEarlierNonNull
17323#undef SCIPbdchgidxIsEarlier
17324#undef SCIPbdchginfoGetOldbound
17325#undef SCIPbdchginfoGetNewbound
17326#undef SCIPbdchginfoGetVar
17327#undef SCIPbdchginfoGetChgtype
17328#undef SCIPbdchginfoGetBoundtype
17329#undef SCIPbdchginfoGetDepth
17330#undef SCIPbdchginfoGetPos
17331#undef SCIPbdchginfoGetIdx
17332#undef SCIPbdchginfoGetInferVar
17333#undef SCIPbdchginfoGetInferCons
17334#undef SCIPbdchginfoGetInferProp
17335#undef SCIPbdchginfoGetInferInfo
17336#undef SCIPbdchginfoGetInferBoundtype
17337#undef SCIPbdchginfoIsRedundant
17338#undef SCIPbdchginfoHasInferenceReason
17339#undef SCIPbdchginfoIsTighter
17359 return boundchg->
var;
17439 return holelist->
next;
17472 return var->vardata;
17483 var->vardata = vardata;
17495 var->vardelorig = vardelorig;
17507 var->vartrans = vartrans;
17518 var->vardeltrans = vardeltrans;
17529 var->varcopy = varcopy;
17543 var->initial = initial;
17559 var->removable = removable;
17653 return var->initial;
17663 return var->removable;
17673 return var->deleted;
17709 var->delglobalstructs =
TRUE;
17719 return var->delglobalstructs;
17739 return var->relaxationonly;
17771 return var->deletable;
17781 return (
var->probindex >= 0);
17801 return var->probindex;
17812 return var->data.original.transvar;
17823 return var->data.col;
17845 return var->data.aggregate.var;
17857 return var->data.aggregate.scalar;
17869 return var->data.aggregate.constant;
17881 return var->data.multaggr.nvars;
17893 return var->data.multaggr.vars;
17905 return var->data.multaggr.scalars;
17917 return var->data.multaggr.constant;
17927 return var->negatedvar;
17938 return var->negatedvar;
17949 return var->data.negate.constant;
17969 return var->unchangedobj;
17986 while( probvar !=
NULL )
18059 return var->data.original.origdom.lb;
18066 return var->data.negate.constant -
var->negatedvar->data.original.origdom.ub;
18079 return var->data.original.origdom.ub;
18086 return var->data.negate.constant -
var->negatedvar->data.original.origdom.lb;
18099 return var->data.original.origdom.holelist;
18111 return var->glbdom.lb;
18121 return var->glbdom.ub;
18131 return var->glbdom.holelist;
18141 if(
var->obj >= 0.0 )
18142 return var->glbdom.lb;
18144 return var->glbdom.ub;
18154 if(
var->obj >= 0.0 )
18155 return var->glbdom.ub;
18157 return var->glbdom.lb;
18167 return var->locdom.lb;
18177 return var->locdom.ub;
18187 return var->locdom.holelist;
18197 if(
var->obj >= 0.0 )
18198 return var->locdom.lb;
18200 return var->locdom.ub;
18210 if(
var->obj >= 0.0 )
18211 return var->locdom.ub;
18213 return var->locdom.lb;
18223 if(
var->obj >= 0.0 )
18236 if(
var->obj >= 0.0 )
18249 return var->lazylb;
18259 return var->lazyub;
18271 return var->branchfactor;
18283 return var->branchpriority;
18499 return var->nlpsol;
18511 assert(pos < var->nlbchginfos);
18513 return &
var->lbchginfos[pos];
18521 return var->nlbchginfos;
18531 assert(pos < var->nubchginfos);
18533 return &
var->ubchginfos[pos];
18543 return var->nubchginfos;
18553 return var->valuehistory;
18604 eventtype,
var->name, (
void*)eventhdlr, (
void*)eventdata);
18628 SCIPsetDebugMsg(
set,
"drop event of variable <%s> with handler %p and data %p\n",
var->name, (
void*)eventhdlr,
18643 return bdchgidx->
pos;
18659 return (bdchgidx1->
depth < bdchgidx2->
depth)
18660 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18677 if( bdchgidx1 ==
NULL )
18679 else if( bdchgidx2 ==
NULL )
18682 return (bdchgidx1->
depth < bdchgidx2->
depth)
18683 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18713 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_BDCHGINFO * lbchginfos
int nlocksdown[NLOCKTYPES]
SCIP_HISTORY * historycrun
unsigned int donotmultaggr
SCIP_Real conflictrelaxedub
SCIP_BDCHGINFO * ubchginfos
union SCIP_Var::@062351145146014100220174313010263165251013276204 data
SCIP_Real conflictrelaxedlb
SCIP_CLIQUELIST * cliquelist
unsigned int branchdirection
SCIP_Longint closestvblpcount
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
struct SCIP_BranchCand SCIP_BRANCHCAND
struct SCIP_Cons SCIP_CONS
#define SCIP_EVENTTYPE_GHOLEADDED
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_EVENTTYPE_GUBCHANGED
struct SCIP_EventData SCIP_EVENTDATA
struct SCIP_EventFilter SCIP_EVENTFILTER
struct SCIP_EventQueue SCIP_EVENTQUEUE
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_VARCHANGED
#define SCIP_EVENTTYPE_LBCHANGED
#define SCIP_EVENTTYPE_UBCHANGED
#define SCIP_EVENTTYPE_LHOLEADDED
struct SCIP_Event SCIP_EVENT
struct SCIP_History SCIP_HISTORY
@ SCIP_BRANCHDIR_DOWNWARDS
struct SCIP_ValueHistory SCIP_VALUEHISTORY
enum SCIP_BranchDir SCIP_BRANCHDIR
struct SCIP_Clique SCIP_CLIQUE
struct SCIP_CliqueTable SCIP_CLIQUETABLE
enum SCIP_BoundType SCIP_BOUNDTYPE
enum SCIP_BaseStat SCIP_BASESTAT
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
struct SCIP_HashMap SCIP_HASHMAP
#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
struct SCIP_Primal SCIP_PRIMAL
struct SCIP_Prob SCIP_PROB
enum SCIP_Objsense SCIP_OBJSENSE
struct SCIP_Prop SCIP_PROP
struct SCIP_Relaxation SCIP_RELAXATION
struct SCIP_Reopt SCIP_REOPT
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_TRANSFORMING
struct SCIP_Stat SCIP_STAT
struct SCIP_Node SCIP_NODE
struct SCIP_Tree SCIP_TREE
struct SCIP_VarData SCIP_VARDATA
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
struct SCIP_DomChgBoth SCIP_DOMCHGBOTH
#define SCIP_DECL_VARDELORIG(x)
struct SCIP_HoleChg SCIP_HOLECHG
union SCIP_DomChg SCIP_DOMCHG
@ SCIP_DOMCHGTYPE_DYNAMIC
struct SCIP_BoundChg SCIP_BOUNDCHG
struct SCIP_BdChgIdx SCIP_BDCHGIDX
struct SCIP_DomChgDyn SCIP_DOMCHGDYN
#define SCIP_DECL_VARTRANS(x)
struct SCIP_DomChgBound SCIP_DOMCHGBOUND
struct SCIP_Holelist SCIP_HOLELIST
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_PROPINFER
@ SCIP_BOUNDCHGTYPE_BRANCHING
@ SCIP_BOUNDCHGTYPE_CONSINFER
@ SCIP_VARSTATUS_ORIGINAL
@ SCIP_VARSTATUS_MULTAGGR
@ SCIP_VARSTATUS_AGGREGATED
struct SCIP_BdChgInfo SCIP_BDCHGINFO
#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