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) );
3831 if(
var->glbdom.lb !=
var->glbdom.ub )
3840 var->glbdom.lb = fixedval;
3841 var->glbdom.ub = fixedval;
3845 var->locdom.lb =
var->glbdom.lb;
3846 var->locdom.ub =
var->glbdom.ub;
3862 if(
var->probindex != -1 )
3868 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
3890 childfixedval = (
var->data.aggregate.scalar < 0.0 ? -fixedval : fixedval);
3892 childfixedval = (fixedval -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
3893 SCIP_CALL(
SCIPvarFix(
var->data.aggregate.var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3894 branchcand, eventfilter, eventqueue, cliquetable, childfixedval, infeasible, fixed) );
3908 SCIP_CALL(
SCIPvarFix(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3909 branchcand, eventfilter, eventqueue, cliquetable,
var->data.negate.constant - fixedval, infeasible, fixed) );
3997 activeconstant = 0.0;
3998 activeconstantinf =
FALSE;
3999 activevarssize = (*nvars) * 2;
4001 tmpvarssize = *
nvars;
4016 for( v = ntmpvars - 1; v >= 0; --v )
4019 scalar = tmpscalars[v];
4040 tmpscalars[v] = scalar;
4042 noldtmpvars = ntmpvars;
4045 SCIPsortPtrReal((
void**)tmpvars, tmpscalars, SCIPvarComp, noldtmpvars);
4047 for( v = 1; v < noldtmpvars; ++v )
4052 tmpscalars[ntmpvars] += tmpscalars[v];
4059 tmpscalars[ntmpvars] = tmpscalars[v];
4060 tmpvars[ntmpvars] = tmpvars[v];
4066#ifdef SCIP_MORE_DEBUG
4067 for( v = 1; v < ntmpvars; ++v )
4072 while( ntmpvars >= 1 )
4076 var = tmpvars[ntmpvars];
4077 scalar = tmpscalars[ntmpvars];
4095 if( nactivevars >= activevarssize )
4097 activevarssize *= 2;
4100 assert(nactivevars < activevarssize);
4102 activevars[nactivevars] =
var;
4103 activescalars[nactivevars] = scalar;
4109 nmultvars =
var->data.multaggr.nvars;
4110 multvars =
var->data.multaggr.vars;
4111 multscalars =
var->data.multaggr.scalars;
4114 if( nmultvars + ntmpvars > tmpvarssize )
4116 while( nmultvars + ntmpvars > tmpvarssize )
4120 assert(nmultvars + ntmpvars <= tmpvarssize);
4123 if( nmultvars > tmpvarssize2 )
4125 while( nmultvars > tmpvarssize2 )
4129 assert(nmultvars <= tmpvarssize2);
4134 for( ; nmultvars >= 0; --nmultvars )
4136 multvar = multvars[nmultvars];
4137 multscalar = multscalars[nmultvars];
4149 if( !activeconstantinf )
4156 if( scalar * multconstant > 0.0 )
4159 activeconstantinf =
TRUE;
4164 activeconstantinf =
TRUE;
4168 activeconstant += scalar * multconstant;
4183 tmpscalars[pos] += scalar * multscalar;
4187 tmpvars2[ntmpvars2] = multvar;
4188 tmpscalars2[ntmpvars2] = scalar * multscalar;
4190 assert(ntmpvars2 <= tmpvarssize2);
4197 SCIPsortPtrReal((
void**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);
4199 for( v = 1; v < ntmpvars2; ++v )
4204 tmpscalars2[pos] += tmpscalars2[v];
4211 tmpscalars2[pos] = tmpscalars2[v];
4212 tmpvars2[pos] = tmpvars2[v];
4216 ntmpvars2 = pos + 1;
4217#ifdef SCIP_MORE_DEBUG
4218 for( v = 1; v < ntmpvars2; ++v )
4222 for( v = 1; v < ntmpvars; ++v )
4229 pos = ntmpvars + ntmpvars2 - 1;
4230 ntmpvars += ntmpvars2;
4232 while( v >= 0 && k >= 0 )
4238 tmpvars[pos] = tmpvars[v];
4239 tmpscalars[pos] = tmpscalars[v];
4244 tmpvars[pos] = tmpvars2[k];
4245 tmpscalars[pos] = tmpscalars2[k];
4254 tmpvars[pos] = tmpvars[v];
4255 tmpscalars[pos] = tmpscalars[v];
4262 tmpvars[pos] = tmpvars2[k];
4263 tmpscalars[pos] = tmpscalars2[k];
4268#ifdef SCIP_MORE_DEBUG
4269 for( v = 1; v < ntmpvars; ++v )
4275 if( !activeconstantinf )
4284 if( scalar * multconstant > 0.0 )
4287 activeconstantinf =
TRUE;
4292 activeconstantinf =
TRUE;
4296 activeconstant += scalar * multconstant;
4323 if( mergemultiples )
4328 SCIPsortPtrReal((
void**)activevars, activescalars, SCIPvarComp, nactivevars);
4331 v = nactivevars - 1;
4337 if( activescalars[v - 1] + activescalars[v] != 0.0 )
4339 activescalars[v - 1] += activescalars[v];
4341 activevars[v] = activevars[nactivevars];
4342 activescalars[v] = activescalars[nactivevars];
4347 activevars[v] = activevars[nactivevars];
4348 activescalars[v] = activescalars[nactivevars];
4351 activevars[v] = activevars[nactivevars];
4352 activescalars[v] = activescalars[nactivevars];
4366 for( v = 0; v < nactivevars / 2; ++v )
4368 tmpvar = activevars[v];
4369 tmpscalar = activescalars[v];
4370 activevars[v] = activevars[nactivevars - 1 - v];
4371 activescalars[v] = activescalars[nactivevars - 1 - v];
4372 activevars[nactivevars - 1 - v] = tmpvar;
4373 activescalars[nactivevars - 1 - v] = tmpscalar;
4377 *requiredsize = nactivevars;
4379 if( varssize >= *requiredsize )
4383 *
nvars = *requiredsize;
4388 if( activeconstantinf )
4389 (*constant) = activeconstant;
4391 (*constant) += activeconstant;
4402 for( v = 0; v < *
nvars; ++v )
4404 vars[v] = activevars[v];
4405 scalars[v] = activescalars[v];
4436 int multrequiredsize;
4465 nlocksup[
i] =
var->nlocksup[
i];
4466 nlocksdown[
i] =
var->nlocksdown[
i];
4471 multconstant =
var->data.multaggr.constant;
4472 nmultvars =
var->data.multaggr.nvars;
4473 multvarssize =
var->data.multaggr.varssize;
4477 if( multrequiredsize > multvarssize )
4481 multvarssize = multrequiredsize;
4483 assert( multrequiredsize <= multvarssize );
4499 var->data.multaggr.constant = multconstant;
4500 var->data.multaggr.nvars = nmultvars;
4501 var->data.multaggr.varssize = multvarssize;
4585 *infeasible =
FALSE;
4588 SCIPsetDebugMsg(
set,
"updating bounds of variables in aggregation <%s> == %g*<%s> %+g\n",
var->name, scalar, aggvar->
name, constant);
4595 aggvarbdschanged =
FALSE;
4603 varlb = aggvar->
glbdom.
lb * scalar + constant;
4607 varub = aggvar->
glbdom.
ub * scalar + constant;
4614 varub = aggvar->
glbdom.
lb * scalar + constant;
4618 varlb = aggvar->
glbdom.
ub * scalar + constant;
4620 varlb =
MAX(varlb,
var->glbdom.lb);
4621 varub =
MIN(varub,
var->glbdom.ub);
4635 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4636 eventfilter, eventqueue, cliquetable, varlb, infeasible, fixed) );
4637 if( !(*infeasible) )
4641 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4642 eventfilter, eventqueue, cliquetable, (varlb-constant)/scalar, infeasible, &aggfixed) );
4643 assert(*fixed == aggfixed);
4668 aggvarlb = (
var->glbdom.lb - constant) / scalar;
4672 aggvarub = (
var->glbdom.ub - constant) / scalar;
4679 aggvarub = (
var->glbdom.lb - constant) / scalar;
4683 aggvarlb = (
var->glbdom.ub - constant) / scalar;
4700 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4701 eventfilter, eventqueue, cliquetable, aggvarlb, infeasible, fixed) );
4702 if( !(*infeasible) )
4706 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4707 eventfilter, eventqueue, cliquetable, aggvarlb * scalar + constant, infeasible, &varfixed) );
4708 assert(*fixed == varfixed);
4732 while( aggvarbdschanged );
4786 *infeasible =
FALSE;
4787 *aggregated =
FALSE;
4795 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventfilter,
4796 eventqueue, cliquetable, constant, infeasible, aggregated) );
4831 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4832 eventfilter, eventqueue, cliquetable, constant/(1.0-scalar), infeasible, aggregated) );
4838 SCIP_CALL(
varUpdateAggregationBounds(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
4839 branchcand, eventfilter, eventqueue, cliquetable, aggvar, scalar, constant, infeasible, &fixed) );
4840 if( *infeasible || fixed )
4842 *aggregated = fixed;
4858 nlocksdown[
i] =
var->nlocksdown[
i];
4859 nlocksup[
i] =
var->nlocksup[
i];
4861 var->nlocksdown[
i] = 0;
4862 var->nlocksup[
i] = 0;
4872 var->data.negate.constant = 1.0;
4873 var->negatedvar = aggvar;
4888 var->data.aggregate.var = aggvar;
4889 var->data.aggregate.scalar = scalar;
4890 var->data.aggregate.constant = constant;
4920 for(
i = 0;
i < nvbds && !(*infeasible); ++
i )
4922 SCIP_CALL(
SCIPvarAddVlb(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4932 for(
i = 0;
i < nvbds && !(*infeasible); ++
i )
4934 SCIP_CALL(
SCIPvarAddVub(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4948 for(
i = 0;
i < 2; ++
i )
4960 for( j = 0; j < nimpls && !(*infeasible); ++j )
4965 SCIP_CALL(
SCIPvarAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
4966 branchcand, eventqueue, (
SCIP_Bool)
i, implvars[j], impltypes[j], implbounds[j],
FALSE, infeasible,
5023 if(
var->probindex != -1 )
5032 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5041 if( *infeasible || *aggregated )
5095#define MAXDNOM 1000000LL
5120 *infeasible =
FALSE;
5121 *aggregated =
FALSE;
5141 a = (scm/scalarxd)*scalarxn;
5142 b = (scm/scalaryd)*scalaryn;
5174 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5175 branchcand, eventfilter, eventqueue, vary, (
SCIP_Real)(-
b/
a), (
SCIP_Real)(
c/
a), infeasible, aggregated) );
5183 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5184 branchcand, eventfilter, eventqueue, varx, (
SCIP_Real)(-
a/
b), (
SCIP_Real)(
c/
b), infeasible, aggregated) );
5215 currentclass =
c %
a;
5216 if( currentclass < 0 )
5218 assert(0 <= currentclass && currentclass <
a);
5220 classstep = (-
b) %
a;
5224 assert(0 <= classstep && classstep <
a);
5226 while( currentclass != 0 )
5228 assert(0 <= currentclass && currentclass <
a);
5229 currentclass += classstep;
5230 if( currentclass >=
a )
5237 xsol = (
c -
b*ysol)/
a;
5262 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5263 branchcand, eventfilter, eventqueue, aggvar, (
SCIP_Real)(-
b), (
SCIP_Real)xsol, infeasible, aggregated) );
5264 assert(*aggregated || *infeasible);
5266 if( !(*infeasible) )
5268 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5269 branchcand, eventfilter, eventqueue, aggvar, (
SCIP_Real)
a, (
SCIP_Real)ysol, infeasible, aggregated) );
5270 assert(*aggregated || *infeasible);
5338 *infeasible =
FALSE;
5339 *aggregated =
FALSE;
5409 scalar = -scalary/scalarx;
5410 constant = rhs/scalarx;
5430 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5431 branchcand, eventfilter, eventqueue, vary, scalar, constant, infeasible, aggregated) );
5438 SCIP_CALL(
tryAggregateIntVars(
set, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5439 branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
5482 int tmprequiredsize;
5494 SCIPsetDebugMsg(
set,
"trying multi-aggregating variable <%s> == ...%d vars... %+g\n",
var->name, naggvars, constant);
5496 *infeasible =
FALSE;
5497 *aggregated =
FALSE;
5502 if(
var->data.original.transvar ==
NULL )
5504 SCIPerrorMessage(
"cannot multi-aggregate an untransformed original variable\n");
5508 reopt, lp, cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars, constant, infeasible, aggregated) );
5515 ntmpvars = naggvars;
5516 tmpvarssize = naggvars;
5517 tmpconstant = constant;
5523 if( tmprequiredsize > tmpvarssize )
5527 tmpvarssize = tmprequiredsize;
5529 assert( tmprequiredsize <= tmpvarssize );
5537 for( v = ntmpvars - 1; v >= 0; --v )
5542 if( tmpvars[v]->index ==
var->index )
5544 tmpscalar += tmpscalars[v];
5545 tmpvars[v] = tmpvars[ntmpvars - 1];
5546 tmpscalars[v] = tmpscalars[ntmpvars - 1];
5558 SCIPsetDebugMsg(
set,
"Possible multi-aggregation was completely resolved and detected to be redundant.\n");
5563 SCIPsetDebugMsg(
set,
"Multi-aggregation was completely resolved and led to infeasibility.\n");
5568 else if( ntmpvars == 1 )
5570 assert(tmpscalars[0] != 0.0);
5574 SCIP_CALL(
SCIPvarFix(tmpvars[0], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5575 branchcand, eventfilter, eventqueue, cliquetable, -constant/tmpscalars[0], infeasible, aggregated) );
5578 else if( ntmpvars == 2 )
5581 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5585 cliquetable, branchcand, eventfilter, eventqueue, tmpvars[0], tmpvars[1], tmpscalars[0],
5586 tmpscalars[1], -tmpconstant, infeasible, aggregated) );
5599 tmpscalar = 1 - tmpscalar;
5600 tmpconstant /= tmpscalar;
5601 for( v = ntmpvars - 1; v >= 0; --v )
5602 tmpscalars[v] /= tmpscalar;
5609 SCIP_CALL(
SCIPvarFix(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5610 eventfilter, eventqueue, cliquetable, tmpconstant, infeasible, aggregated) );
5617 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5621 cliquetable, branchcand, eventfilter, eventqueue,
var, tmpvars[0], 1.0, -tmpscalars[0], tmpconstant,
5622 infeasible, aggregated) );
5662 nlocksdown[
i] =
var->nlocksdown[
i];
5663 nlocksup[
i] =
var->nlocksup[
i];
5665 var->nlocksdown[
i] = 0;
5666 var->nlocksup[
i] = 0;
5673 var->data.multaggr.constant = tmpconstant;
5674 var->data.multaggr.nvars = ntmpvars;
5675 var->data.multaggr.varssize = ntmpvars;
5689 branchfactor =
var->branchfactor;
5690 branchpriority =
var->branchpriority;
5693 for( v = 0; v < ntmpvars; ++v )
5697 branchfactor =
MAX(tmpvars[v]->branchfactor, branchfactor);
5698 branchpriority =
MAX(tmpvars[v]->branchpriority, branchpriority);
5703 for( v = 0; v < ntmpvars; ++v )
5709 if( tmpscalars[v] >= 0.0 )
5722 if(
var->probindex != -1 )
5734 SCIP_CALL(
SCIPvarAddObj(
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue,
obj) );
5757 SCIPerrorMessage(
"cannot multi-aggregate a multiple aggregated variable again\n");
5770 for( v = 0; v < naggvars; ++v )
5774 SCIP_CALL(
SCIPvarMultiaggregate(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5775 cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars,
5776 var->data.negate.constant - constant, infeasible, aggregated) );
5779 for( v = 0; v < naggvars; ++v )
5789 if( *infeasible || *aggregated )
5952 (*negvar)->data.negate.constant = 1.0;
5954 (*negvar)->data.negate.constant =
var->glbdom.lb +
var->glbdom.ub;
5963 (*negvar)->glbdom.lb = (*negvar)->data.negate.constant -
var->glbdom.ub;
5964 (*negvar)->glbdom.ub = (*negvar)->data.negate.constant -
var->glbdom.lb;
5965 (*negvar)->locdom.lb = (*negvar)->data.negate.constant -
var->locdom.ub;
5966 (*negvar)->locdom.ub = (*negvar)->data.negate.constant -
var->locdom.lb;
5970 var->negatedvar = *negvar;
5978 (*negvar)->branchfactor =
var->branchfactor;
5979 (*negvar)->branchpriority =
var->branchpriority;
5983 (*negvar)->donotaggr =
var->donotaggr;
5984 (*negvar)->donotmultaggr =
var->donotmultaggr;
5987 (*negvar)->lazylb = (*negvar)->data.negate.constant -
var->lazyub;
5988 (*negvar)->lazyub = (*negvar)->data.negate.constant -
var->lazylb;
5992 assert((*negvar)->nuses == 1);
5997 *negvar =
var->negatedvar;
6017 var->probindex = probindex;
6021 var->data.col->var_probindex = probindex;
6049 var->name = (
char*)name;
6127 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be aggregated.\n");
6163 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be multi-aggregated.\n");
6195 if(
var->probindex >= 0 )
6197 SCIPerrorMessage(
"cannot change type of variable already in the problem\n");
6202 var->vartype = vartype;
6215 var->negatedvar->vartype = vartype;
6288 if(
var->data.original.transvar !=
NULL )
6326 SCIPerrorMessage(
"cannot change objective value of a fixed, aggregated, multi-aggregated, or negated variable\n");
6370 if(
var->data.original.transvar !=
NULL )
6379 var->unchangedobj += addobj;
6392 var->unchangedobj += addobj;
6409 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6416 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6418 lp, eventfilter, eventqueue,
var->data.aggregate.scalar * addobj) );
6425 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6426 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
6429 reopt, lp, eventfilter, eventqueue,
var->data.multaggr.scalars[
i] * addobj) );
6439 SCIP_CALL(
SCIPprimalUpdateObjoffset(primal, blkmem,
set, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );
6440 SCIP_CALL(
SCIPvarAddObj(
var->negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
6441 eventfilter, eventqueue, -addobj) );
6497 SCIPerrorMessage(
"cannot change diving objective value of a multi-aggregated variable\n");
6594 var->name,
var->data.original.origdom.lb, newbound);
6600 var->data.original.origdom.lb = newbound;
6609 for(
i = 0;
i <
var->nparentvars; ++
i )
6613 parentvar =
var->parentvars[
i];
6653 var->name,
var->data.original.origdom.ub, newbound);
6659 var->data.original.origdom.ub = newbound;
6668 for(
i = 0;
i <
var->nparentvars; ++
i )
6672 parentvar =
var->parentvars[
i];
6700 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6713 SCIPsetDebugMsg(
set,
"issue GLBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
6738 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));
6751 SCIPsetDebugMsg(
set,
"issue GUBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
6783 SCIPsetDebugMsg(
set,
"issue GHOLEADDED event for variable <%s>: (%.15g,%.15g)\n",
var->name, left, right);
6868 newbound =
var->glbdom.ub;
6874 SCIPsetDebugMsg(
set,
"process changing global lower bound of <%s> from %f to %f\n",
var->name,
var->glbdom.lb, newbound);
6876 if(
SCIPsetIsEQ(
set, newbound,
var->glbdom.lb) && !(newbound !=
var->glbdom.lb && newbound *
var->glbdom.lb <= 0.0) )
6883 oldbound =
var->glbdom.lb;
6885 var->glbdom.lb = newbound;
6901 for(
i = 0;
i <
var->nlbchginfos; ++
i )
6905 if(
var->lbchginfos[
i].oldbound <
var->glbdom.lb )
6907 SCIPsetDebugMsg(
set,
" -> adjust lower bound change <%s>: %g -> %g due to new global lower bound %g\n",
6909 var->lbchginfos[
i].oldbound =
var->glbdom.lb;
6913 var->lbchginfos[
i].newbound =
var->glbdom.lb;
6915 var->lbchginfos[
i].redundant =
TRUE;
6939 for(
i = 0;
i <
var->nparentvars; ++
i )
6941 parentvar =
var->parentvars[
i];
6954 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
6971 parentnewbound = newbound;
6987 parentnewbound = -newbound;
7044 newbound =
var->glbdom.lb;
7050 SCIPsetDebugMsg(
set,
"process changing global upper bound of <%s> from %f to %f\n",
var->name,
var->glbdom.ub, newbound);
7052 if(
SCIPsetIsEQ(
set, newbound,
var->glbdom.ub) && !(newbound !=
var->glbdom.ub && newbound *
var->glbdom.ub <= 0.0) )
7059 oldbound =
var->glbdom.ub;
7061 var->glbdom.ub = newbound;
7077 for(
i = 0;
i <
var->nubchginfos; ++
i )
7080 if(
var->ubchginfos[
i].oldbound >
var->glbdom.ub )
7082 SCIPsetDebugMsg(
set,
" -> adjust upper bound change <%s>: %g -> %g due to new global upper bound %g\n",
7084 var->ubchginfos[
i].oldbound =
var->glbdom.ub;
7088 var->ubchginfos[
i].newbound =
var->glbdom.ub;
7090 var->ubchginfos[
i].redundant =
TRUE;
7114 for(
i = 0;
i <
var->nparentvars; ++
i )
7116 parentvar =
var->parentvars[
i];
7129 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7145 parentnewbound = newbound;
7160 parentnewbound = -newbound;
7219 newbound =
MIN(newbound,
var->glbdom.ub);
7230 if(
SCIPsetIsEQ(
set,
var->glbdom.lb, newbound) && !(newbound !=
var->glbdom.lb && newbound *
var->glbdom.lb <= 0.0) )
7237 if(
var->data.original.transvar !=
NULL )
7240 cliquetable, newbound) );
7275 var->data.aggregate.var->glbdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7277 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7279 childnewbound = newbound;
7290 var->data.aggregate.var->glbdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7292 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7294 childnewbound = -newbound;
7306 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7314 var->data.negate.constant - newbound) );
7362 newbound =
MAX(newbound,
var->glbdom.lb);
7373 if(
SCIPsetIsEQ(
set,
var->glbdom.ub, newbound) && !(newbound !=
var->glbdom.ub && newbound *
var->glbdom.ub <= 0.0) )
7380 if(
var->data.original.transvar !=
NULL )
7418 var->data.aggregate.var->glbdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7420 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7422 childnewbound = newbound;
7433 var->data.aggregate.var->glbdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
7435 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
7437 childnewbound = -newbound;
7449 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7457 var->data.negate.constant - newbound) );
7486 var->lazylb = lazylb;
7509 var->lazyub = lazyub;
7560 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || newbound ==
var->glbdom.lb || (newbound != oldbound && newbound * oldbound <= 0.0));
7573 SCIPsetDebugMsg(
set,
"issue LBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
7598 assert(!
SCIPsetIsEQ(
set, oldbound, newbound) || newbound ==
var->glbdom.ub || (newbound != oldbound && newbound * oldbound <= 0.0));
7611 SCIPsetDebugMsg(
set,
"issue UBCHANGED event for variable <%s>: %g -> %g\n",
var->name, oldbound, newbound);
7669 newbound =
MIN(newbound,
var->locdom.ub);
7672 newbound =
MAX(newbound,
var->glbdom.lb);
7679 newbound =
var->glbdom.lb;
7680 else if(
SCIPsetIsEQ(
set, newbound,
var->locdom.lb) && !(newbound !=
var->locdom.lb && newbound *
var->locdom.lb <= 0.0) )
7684 oldbound =
var->locdom.lb;
7686 var->locdom.lb = newbound;
7708 for(
i = 0;
i <
var->nparentvars; ++
i )
7710 parentvar =
var->parentvars[
i];
7723 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7744 if( parentnewbound > parentvar->
glbdom.
ub )
7748 parentnewbound = parentvar->
glbdom.
ub;
7752 parentnewbound = newbound;
7772 if( parentnewbound < parentvar->glbdom.lb )
7776 parentnewbound = parentvar->
glbdom.
lb;
7780 parentnewbound = -newbound;
7836 newbound =
MAX(newbound,
var->locdom.lb);
7839 newbound =
MIN(newbound,
var->glbdom.ub);
7846 newbound =
var->glbdom.ub;
7847 else if(
SCIPsetIsEQ(
set, newbound,
var->locdom.ub) && !(newbound !=
var->locdom.ub && newbound *
var->locdom.ub <= 0.0) )
7851 oldbound =
var->locdom.ub;
7853 var->locdom.ub = newbound;
7875 for(
i = 0;
i <
var->nparentvars; ++
i )
7877 parentvar =
var->parentvars[
i];
7890 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7910 if( parentnewbound < parentvar->glbdom.lb )
7914 parentnewbound = parentvar->
glbdom.
lb;
7918 parentnewbound = newbound;
7937 if( parentnewbound > parentvar->
glbdom.
ub )
7941 parentnewbound = parentvar->
glbdom.
ub;
7945 parentnewbound = -newbound;
8000 newbound =
MIN(newbound,
var->locdom.ub);
8007 && !(newbound !=
var->locdom.lb && newbound *
var->locdom.lb <= 0.0) )
8014 if(
var->data.original.transvar !=
NULL )
8044 var->data.aggregate.var->locdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8046 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8048 childnewbound = newbound;
8059 var->data.aggregate.var->locdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8061 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8063 childnewbound = -newbound;
8075 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8083 var->data.negate.constant - newbound) );
8127 newbound =
MAX(newbound,
var->locdom.lb);
8134 && !(newbound !=
var->locdom.ub && newbound *
var->locdom.ub <= 0.0) )
8141 if(
var->data.original.transvar !=
NULL )
8170 var->data.aggregate.var->locdom.ub *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8172 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8174 childnewbound = newbound;
8185 var->data.aggregate.var->locdom.lb *
var->data.aggregate.scalar +
var->data.aggregate.constant));
8187 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8189 childnewbound = -newbound;
8201 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8209 var->data.negate.constant - newbound) );
8281 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8296 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8298 childnewbound = newbound;
8307 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8309 childnewbound = -newbound;
8320 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8371 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8386 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8388 childnewbound = newbound;
8397 childnewbound = (newbound -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8399 childnewbound = -newbound;
8410 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8453 lb =
var->data.multaggr.constant;
8454 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8456 aggrvar =
var->data.multaggr.vars[
i];
8457 if(
var->data.multaggr.scalars[
i] > 0.0 )
8466 lb +=
var->data.multaggr.scalars[
i] * bnd;
8477 lb +=
var->data.multaggr.scalars[
i] * bnd;
8519 ub =
var->data.multaggr.constant;
8520 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8522 aggrvar =
var->data.multaggr.vars[
i];
8523 if(
var->data.multaggr.scalars[
i] > 0.0 )
8532 ub +=
var->data.multaggr.scalars[
i] * bnd;
8543 ub +=
var->data.multaggr.scalars[
i] * bnd;
8585 lb =
var->data.multaggr.constant;
8586 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8588 aggrvar =
var->data.multaggr.vars[
i];
8589 if(
var->data.multaggr.scalars[
i] > 0.0 )
8598 lb +=
var->data.multaggr.scalars[
i] * bnd;
8609 lb +=
var->data.multaggr.scalars[
i] * bnd;
8651 ub =
var->data.multaggr.constant;
8652 for(
i =
var->data.multaggr.nvars-1 ;
i >= 0 ; --
i )
8654 aggrvar =
var->data.multaggr.vars[
i];
8655 if(
var->data.multaggr.scalars[
i] > 0.0 )
8664 ub +=
var->data.multaggr.scalars[
i] * bnd;
8675 ub +=
var->data.multaggr.scalars[
i] * bnd;
8786 newlb =
var->glbdom.lb;
8787 newub =
var->glbdom.ub;
8798 if(
var->eventfilter !=
NULL )
8804 for(
i = 0;
i <
var->nparentvars; ++
i )
8810 parentvar =
var->parentvars[
i];
8816 parentnewleft = left;
8817 parentnewright = right;
8824 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8866 parentnewleft, parentnewright, &localadded) );
8910 if(
var->data.original.transvar !=
NULL )
8913 left, right, added) );
8950 childnewleft = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8951 childnewright = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8955 childnewright = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8956 childnewleft = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
8964 childnewleft, childnewright, added) );
8976 childnewright = -left +
var->data.negate.constant;
8977 childnewleft = -right +
var->data.negate.constant;
8980 childnewleft, childnewright, added) );
9032 newlb =
var->locdom.lb;
9033 newub =
var->locdom.ub;
9042#ifdef SCIP_DISABLED_CODE
9051 for(
i = 0;
i <
var->nparentvars; ++
i )
9057 parentvar =
var->parentvars[
i];
9063 parentnewleft = left;
9064 parentnewright = right;
9071 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
9113 parentnewleft, parentnewright, &localadded) );
9160 if(
var->data.original.transvar !=
NULL )
9163 left, right, added) );
9189 childnewleft = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9190 childnewright = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9194 childnewright = (left -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9195 childnewleft = (right -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
9203 childnewleft, childnewright, added) );
9207 SCIPerrorMessage(
"cannot add domain hole to a multi-aggregated variable.\n");
9215 childnewright = -left +
var->data.negate.constant;
9216 childnewleft = -right +
var->data.negate.constant;
9368 var->closestvblpcount = -1;
9436 *infeasible =
FALSE;
9466 if( nbdchgs !=
NULL )
9496 if( nbdchgs !=
NULL )
9548 *infeasible =
FALSE;
9552 checkImplic(
set, implvar, impltype, implbound, &redundant, &conflict);
9553 assert(!redundant || !conflict);
9557 if(
var == implvar )
9582 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
9583 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
9605 vals[0] = varfixing;
9609 SCIP_CALL(
SCIPcliquetableAdd(cliquetable, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
9610 eventqueue,
vars, vals, 2,
FALSE, &conflict, nbdchgs) );
9622 isshortcut, &conflict, added) );
9625 assert(!conflict || !(*added));
9663 if( nbdchgs !=
NULL )
9701 varfixing ? implbound - ub : ub - implbound, varfixing ? ub : implbound) );
9709 varfixing ? implbound - lb : lb - implbound, varfixing ? lb : implbound) );
9745 *infeasible =
FALSE;
9762 while (
i >= 0 && !(*infeasible) )
9766 assert(implvars[
i] != implvar);
9773 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9774 eventqueue, varfixing, implvars[
i], impltypes[
i], implbounds[
i],
TRUE, infeasible, nbdchgs, &added) );
9824 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9825 eventqueue, varfixing, implvar, impltype, implbound,
FALSE, infeasible, nbdchgs, &added) );
9827 if( *infeasible ||
var == implvar || !transitive || !added )
9841 cliquetable, branchcand, eventqueue, varfixing, implvar, implvarfixing, infeasible, nbdchgs) );
9844 if( !(*infeasible) )
9847 cliquetable, branchcand, eventqueue, !implvarfixing,
var, !varfixing, infeasible, nbdchgs) );
9873 while (
i >= 0 && !(*infeasible) )
9875 assert(vlbvars[
i] != implvar);
9900 vbimplbound = (implbound - vlbconstants[
i])/vlbcoefs[
i];
9901 if( vlbcoefs[
i] >= 0.0 )
9904 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9906 infeasible, nbdchgs, &added) );
9911 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9913 infeasible, nbdchgs, &added) );
9916 i =
MIN(
i, nvlbvars);
9943 while (
i >= 0 && !(*infeasible) )
9945 assert(vubvars[
i] != implvar);
9970 vbimplbound = (implbound - vubconstants[
i])/vubcoefs[
i];
9971 if( vubcoefs[
i] >= 0.0 )
9974 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9976 infeasible, nbdchgs, &added) );
9981 SCIP_CALL(
varAddImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9983 infeasible, nbdchgs, &added) );
9986 i =
MIN(
i, nvubvars);
10029 *infeasible =
FALSE;
10030 if( nbdchgs !=
NULL )
10038 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef, vlbconstant, transitive, infeasible, nbdchgs) );
10052 *infeasible =
TRUE;
10072 if( nbdchgs !=
NULL )
10076 else if(
var == vlbvar )
10082 *infeasible =
TRUE;
10093 SCIP_Real newub = vlbconstant / (1.0 - vlbcoef);
10097 *infeasible =
TRUE;
10122 if( nbdchgs !=
NULL )
10133 newlb = vlbconstant / (1.0 - vlbcoef);
10137 *infeasible =
TRUE;
10162 if( nbdchgs !=
NULL )
10189 if( vlbcoef >= 0.0 )
10196 newzub = (xub - vlbconstant)/vlbcoef;
10204 *infeasible =
TRUE;
10230 if( nbdchgs !=
NULL )
10233 maxvlb = vlbcoef * zub + vlbconstant;
10235 minvlb = vlbcoef * zlb + vlbconstant;
10240 maxvlb = vlbcoef * zub + vlbconstant;
10242 minvlb = vlbcoef * zlb + vlbconstant;
10252 newzlb = (xub - vlbconstant)/vlbcoef;
10260 *infeasible =
TRUE;
10286 if( nbdchgs !=
NULL )
10289 maxvlb = vlbcoef * zlb + vlbconstant;
10291 minvlb = vlbcoef * zub + vlbconstant;
10296 maxvlb = vlbcoef * zlb + vlbconstant;
10298 minvlb = vlbcoef * zub + vlbconstant;
10301 if( maxvlb < minvlb )
10311 *infeasible =
TRUE;
10338 if( nbdchgs !=
NULL )
10352 if( vlbcoef >= 0.0 )
10354 vlbcoef = maxvlb - minvlb;
10355 vlbconstant = minvlb;
10359 vlbcoef = minvlb - maxvlb;
10360 vlbconstant = maxvlb;
10381 infeasible, nbdchgs) );
10390 implbound = -vlbconstant/vlbcoef;
10402 implbound, transitive, infeasible, nbdchgs) );
10421 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10422 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10428 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10429 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10447 SCIP_CALL(
SCIPvarAddVub(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10448 branchcand, eventqueue, vlbvar, -vlbcoef,
var->data.negate.constant - vlbconstant, transitive, infeasible,
10493 *infeasible =
FALSE;
10494 if( nbdchgs !=
NULL )
10502 cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );
10510 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10517 *infeasible =
TRUE;
10537 if( nbdchgs !=
NULL )
10541 else if(
var == vubvar )
10547 *infeasible =
TRUE;
10558 SCIP_Real newlb = vubconstant / (1.0 - vubcoef);
10562 *infeasible =
TRUE;
10587 if( nbdchgs !=
NULL )
10598 newub = vubconstant / (1.0 - vubcoef);
10602 *infeasible =
TRUE;
10627 if( nbdchgs !=
NULL )
10654 if( vubcoef >= 0.0 )
10661 newzlb = (xlb - vubconstant)/vubcoef;
10664 *infeasible =
TRUE;
10690 if( nbdchgs !=
NULL )
10693 minvub = vubcoef * zlb + vubconstant;
10695 maxvub = vubcoef * zub + vubconstant;
10700 maxvub = vubcoef * zub + vubconstant;
10702 minvub = vubcoef * zlb + vubconstant;
10712 newzub = (xlb - vubconstant)/vubcoef;
10715 *infeasible =
TRUE;
10741 if( nbdchgs !=
NULL )
10744 minvub = vubcoef * zub + vubconstant;
10746 maxvub = vubcoef * zlb + vubconstant;
10751 minvub = vubcoef * zub + vubconstant;
10753 maxvub = vubcoef * zlb + vubconstant;
10756 if( minvub > maxvub )
10766 *infeasible =
TRUE;
10794 if( nbdchgs !=
NULL )
10808 if( vubcoef >= 0.0 )
10810 vubcoef = maxvub - minvub;
10811 vubconstant = minvub;
10815 vubcoef = minvub - maxvub;
10816 vubconstant = maxvub;
10837 infeasible, nbdchgs) );
10847 (1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );
10866 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10867 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10873 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10874 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10892 SCIP_CALL(
SCIPvarAddVlb(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10893 branchcand, eventqueue, vubvar, -vubcoef,
var->data.negate.constant - vubconstant, transitive, infeasible,
10939 *infeasible =
FALSE;
10940 if( nbdchgs !=
NULL )
10948 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10962 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10963 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
10972 SCIP_CALL(
varAddTransitiveImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10973 branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
10982 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10983 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
11003 if(
var->data.aggregate.scalar > 0 )
11006 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
11012 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,
11036 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11044 SCIP_CALL(
SCIPvarAddImplic(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11047 infeasible, nbdchgs) );
11062 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? 1.0 : -1.0,
11071 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? -1.0 : 1.0,
11081 SCIP_CALL(
SCIPvarAddVub(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11082 branchcand, eventqueue,
var->negatedvar, (varfixing) ? 1.0 : -1.0,
11083 (varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );
11090 SCIP_CALL(
SCIPvarAddVlb(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11091 branchcand, eventqueue,
var->negatedvar, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,
11092 transitive, infeasible, nbdchgs) );
11169 if( bounds ==
NULL )
11172 if( lowerpos >= 0 )
11173 *lb = bounds[lowerpos];
11175 if( upperpos >= 0 )
11176 *ub = bounds[upperpos];
11204 *infeasible =
FALSE;
11206 if( value ==
FALSE )
11208 if(
var->glbdom.lb > 0.5 )
11209 *infeasible =
TRUE;
11210 else if(
var->glbdom.ub > 0.5 )
11229 if( nbdchgs !=
NULL )
11235 if(
var->glbdom.ub < 0.5 )
11236 *infeasible =
TRUE;
11237 else if(
var->glbdom.lb < 0.5 )
11256 if( nbdchgs !=
NULL )
11294 *infeasible =
FALSE;
11322 SCIP_CALL(
SCIPvarFixBinary(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11323 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
11329 if( oppositeentry )
11339 for(
i = 0;
i <
nvars && !(*infeasible); ++
i )
11344 SCIP_CALL(
SCIPvarFixBinary(
vars[
i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11345 eventqueue, cliquetable, !values[
i], infeasible, nbdchgs) );
11373 for( v =
nvars - 1; v >= 0; --v )
11511 branchfactor =
MAX(branchfactor,
eps);
11513 SCIPsetDebugMsg(
set,
"process changing branch factor of <%s> from %f to %f\n",
var->name,
var->branchfactor, branchfactor);
11519 var->branchfactor = branchfactor;
11522 for(
i = 0;
i <
var->nparentvars; ++
i )
11524 parentvar =
var->parentvars[
i];
11537 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11570 assert(branchfactor >= 0.0);
11572 SCIPdebugMessage(
"changing branch factor of <%s> from %g to %g\n",
var->name,
var->branchfactor, branchfactor);
11581 if(
var->data.original.transvar !=
NULL )
11588 var->branchfactor = branchfactor;
11606 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11640 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11641 var->name,
var->branchpriority, branchpriority);
11643 if( branchpriority ==
var->branchpriority )
11647 var->branchpriority = branchpriority;
11650 for(
i = 0;
i <
var->nparentvars; ++
i )
11652 parentvar =
var->parentvars[
i];
11665 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11695 SCIPdebugMessage(
"changing branch priority of <%s> from %d to %d\n",
var->name,
var->branchpriority, branchpriority);
11697 if(
var->branchpriority == branchpriority )
11704 if(
var->data.original.transvar !=
NULL )
11709 var->branchpriority = branchpriority;
11726 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11760 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11761 var->name,
var->branchdirection, branchdirection);
11767 var->branchdirection = branchdirection;
11770 for(
i = 0;
i <
var->nparentvars; ++
i )
11772 parentvar =
var->parentvars[
i];
11785 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11826 SCIPdebugMessage(
"changing branch direction of <%s> from %u to %d\n",
var->name,
var->branchdirection, branchdirection);
11835 if(
var->data.original.transvar !=
NULL )
11840 var->branchdirection = branchdirection;
11852 if(
var->data.aggregate.scalar > 0.0 )
11864 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11870 if(
var->data.multaggr.scalars[v] > 0.0 )
11977 else if( obj1 > obj2 )
12019 int activevarssize;
12043 activevarssize = *
nvars;
12045 tmpvarssize = *
nvars;
12052 noldtmpvars = ntmpvars;
12055 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12056 for( v = ntmpvars - 1; v > 0; --v )
12062 tmpvars[v] = tmpvars[ntmpvars];
12066 if( noldtmpvars > ntmpvars )
12067 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12070 while( ntmpvars >= 1 )
12073 var = tmpvars[ntmpvars];
12079 if(
var->data.original.transvar ==
NULL )
12081 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12085 tmpvars[ntmpvars] =
var->data.original.transvar;
12090 tmpvars[ntmpvars] =
var->data.aggregate.var;
12095 tmpvars[ntmpvars] =
var->negatedvar;
12102 if( nactivevars >= activevarssize )
12104 activevarssize *= 2;
12106 assert(nactivevars < activevarssize);
12108 activevars[nactivevars] =
var;
12114 nmultvars =
var->data.multaggr.nvars;
12115 multvars =
var->data.multaggr.vars;
12118 if( nmultvars + ntmpvars > tmpvarssize )
12120 while( nmultvars + ntmpvars > tmpvarssize )
12123 assert(nmultvars + ntmpvars <= tmpvarssize);
12132 ntmpvars += nmultvars;
12133 noldtmpvars = ntmpvars;
12136 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12137 for( v = ntmpvars - 1; v > 0; --v )
12143 tmpvars[v] = tmpvars[ntmpvars];
12147 if( noldtmpvars > ntmpvars )
12148 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12164 SCIPsortPtr((
void**)activevars, SCIPvarComp, nactivevars);
12167 v = nactivevars - 1;
12174 activevars[v] = activevars[nactivevars];
12178 *requiredsize = nactivevars;
12180 if( varssize >= *requiredsize )
12184 *
nvars = *requiredsize;
12206 for( v =
nvars - 1; v >= 0; --v )
12238 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12292 for( v =
nvars - 1; v >= 0; --v )
12294 var = &((*vars)[v]);
12295 negated = &((*negatedarr)[v]);
12326 orignegated = *negated;
12334 if( (*var)->data.original.transvar ==
NULL )
12336 *
var = (*var)->data.original.transvar;
12347 if ( (*var)->data.multaggr.nvars == 1 )
12349 assert( (*var)->data.multaggr.vars !=
NULL );
12350 assert( (*var)->data.multaggr.scalars !=
NULL );
12352 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1e-06));
12362 if(
EPSEQ((*var)->data.multaggr.constant, -1.0, 1e-06) || (
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) &&
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06)) )
12364 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12373 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )
12383 assert(
EPSZ((*var)->data.multaggr.constant, 1e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06)
12384 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)
12385 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12387 if( !
EPSZ((*var)->data.multaggr.constant, 1e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) )
12393 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12395 if(
EPSZ((*var)->data.multaggr.constant, 1e-06) )
12401 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?
12407 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12409 constant += (*negated) != orignegated ? -1.0 : 1.0;
12412 *negated = !(*negated);
12414 *
var = (*var)->data.multaggr.vars[0];
12423 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1e-06));
12424 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));
12426 constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
12429 *negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);
12430 *
var = (*var)->data.aggregate.var;
12436 constant += (*negated) != orignegated ? -1.0 : 1.0;
12439 *negated = !(*negated);
12440 *
var = (*var)->negatedvar;
12454 assert(
EPSZ(constant, 1e-06) == ((*negated) == orignegated));
12479 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
12484 if( (*var)->data.original.transvar ==
NULL )
12486 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12489 *
var = (*var)->data.original.transvar;
12500 if ( (*var)->data.multaggr.nvars == 1 )
12502 assert( (*var)->data.multaggr.vars !=
NULL );
12503 assert( (*var)->data.multaggr.scalars !=
NULL );
12504 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
12506 (*bound) /= (*var)->data.multaggr.scalars[0];
12507 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
12508 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
12515 *
var = (*var)->data.multaggr.vars[0];
12522 assert((*var)->data.aggregate.scalar != 0.0);
12524 (*bound) /= (*var)->data.aggregate.scalar;
12525 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12526 if( (*var)->data.aggregate.scalar < 0.0 )
12533 *
var = (*var)->data.aggregate.var;
12540 assert((*var)->negatedvar->negatedvar == *
var);
12541 (*bound) = (*var)->data.negate.constant - *
bound;
12546 *
var = (*var)->negatedvar;
12572 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
12577 if( (*var)->data.original.transvar ==
NULL )
12579 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12582 *
var = (*var)->data.original.transvar;
12594 assert((*var)->data.aggregate.scalar != 0.0);
12597 (*left) /= (*var)->data.aggregate.scalar;
12598 (*right) /= (*var)->data.aggregate.scalar;
12601 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12602 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12604 *
var = (*var)->data.aggregate.var;
12607 if( (*var)->data.aggregate.scalar < 0.0 )
12620 assert((*var)->negatedvar->negatedvar == *
var);
12623 (*left) = (*var)->data.negate.constant - (*left);
12624 (*right) = (*var)->data.negate.constant - (*right);
12626 *
var = (*var)->negatedvar;
12662 if( (*var)->data.original.transvar ==
NULL )
12664 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12667 *
var = (*var)->data.original.transvar;
12680 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12686 (*constant) += *scalar * (*var)->glbdom.lb;
12702 if ( (*var)->data.multaggr.nvars == 1 )
12705 assert((*var)->data.multaggr.scalars !=
NULL);
12706 assert((*var)->data.multaggr.vars[0] !=
NULL);
12716 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12729 (*constant) += *scalar * (*var)->data.multaggr.constant;
12731 (*scalar) *= (*var)->data.multaggr.scalars[0];
12732 *
var = (*var)->data.multaggr.vars[0];
12742 (*constant) += *scalar * (*var)->data.aggregate.constant;
12743 (*scalar) *= (*var)->data.aggregate.scalar;
12744 *
var = (*var)->data.aggregate.var;
12750 assert((*var)->negatedvar->negatedvar == *
var);
12754 (*constant) += *scalar * (*var)->data.negate.constant;
12756 *
var = (*var)->negatedvar;
12791 if( (*var)->nparentvars == 0 )
12797 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *
var) )
12800 *constant -= (*var)->data.negate.constant * (*scalar);
12801 *
var = (*var)->negatedvar;
12829 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12871 parentvar =
var->parentvars[0];
12911 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12953 return var->locdom.lb;
12962 else if(
var->data.aggregate.scalar > 0.0 )
12967 else if(
var->data.aggregate.scalar < 0.0 )
12981 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
13023 return var->locdom.ub;
13032 if(
var->data.aggregate.scalar > 0.0 )
13037 else if(
var->data.aggregate.scalar < 0.0 )
13050 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
13077 if(
var->data.original.transvar ==
NULL )
13090 return var->locdom.lb;
13109 return var->data.aggregate.scalar * lpsolval +
var->data.aggregate.constant;
13123 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13158 return var->nlpsol;
13168 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13171 solval =
var->data.multaggr.constant;
13172 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13178 return var->data.negate.constant - solval;
13201 if(
var->data.original.transvar ==
NULL )
13211 return var->locdom.lb;
13228 return var->data.aggregate.scalar * pseudosolval +
var->data.aggregate.constant;
13237 pseudosol =
var->data.multaggr.constant;
13238 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13305 if(
var->bestrootredcost > 0.0 )
13310 currcutoffbound = (
bound -
var->bestrootsol) *
var->bestrootredcost +
var->bestrootlpobjval;
13315 if( rootredcost > 0.0 )
13320 cutoffbound = (
bound -
rootsol) * rootredcost + rootlpobjval;
13323 if( cutoffbound > currcutoffbound )
13329 var->bestrootredcost = rootredcost;
13330 var->bestrootlpobjval = rootlpobjval;
13341 var->bestrootredcost = rootredcost;
13342 var->bestrootlpobjval = rootlpobjval;
13361 if(
var->data.original.transvar ==
NULL )
13367 return var->rootsol;
13371 return var->locdom.lb;
13395 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13463#define MAX_CLIQUELENGTH 50
13486#ifdef SCIP_MORE_DEBUG
13524 for(
c = ncliques - 1;
c >= 0; --
c )
13526 clique = cliques[
c];
13541 for( v = nclqvars - 1; v >= 0; --v )
13543 clqvar = clqvars[v];
13551 assert(0 < probindex && probindex < nentries);
13553#ifdef SCIP_DISABLED_CODE
13557 assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));
13559 if( entries[probindex] == 0 )
13561 ids[nids] = probindex;
13565 entries[probindex] = (clqvalues[v] ? probindex : -probindex);
13575 for( v = nids - 1; v >= 0; --v )
13578 assert(0 <
id &&
id < nentries);
13579 assert(entries[
id] != 0);
13585 if( (entries[
id] > 0) != varfixing )
13591 implredcost += redcost;
13601#ifdef SCIP_MORE_DEBUG
13627 for( v =
nvars - 1; v >= 0; --v )
13655 redcost *= (lb - bounds[v]);
13657 redcost *= (bounds[v] - lb);
13665 redcost *= (bounds[v] - ub);
13667 redcost *= (ub - bounds[v]);
13681 redcost *= (lb - bounds[v]);
13683 redcost *= (bounds[v] - lb);
13691 redcost *= (bounds[v] - ub);
13693 redcost *= (ub - bounds[v]);
13699 implredcost += redcost;
13703#ifdef SCIP_MORE_DEBUG
13704 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13708 return implredcost;
13726 if(
var->data.original.transvar ==
NULL )
13732 return var->bestrootsol;
13736 return var->locdom.lb;
13760 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13790 if(
var->data.original.transvar ==
NULL )
13796 return var->bestrootredcost;
13824 if(
var->data.original.transvar ==
NULL )
13830 return var->bestrootlpobjval;
13856 var->bestrootredcost = rootredcost;
13857 var->bestrootlpobjval = rootlpobjval;
13885 var->relaxsol = solval;
13891 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13900 (solval -
var->data.aggregate.constant)/
var->data.aggregate.scalar, updateobj) );
13903 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13943 return var->relaxsol;
13955 if(
var->data.aggregate.scalar * solval > 0.0 )
13957 if(
var->data.aggregate.scalar * solval < 0.0 )
13960 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13963 solvalsum =
var->data.multaggr.constant;
13964 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13969 if(
var->data.multaggr.scalars[
i] * solval > 0.0 )
13971 if(
var->data.multaggr.scalars[
i] * solval < 0.0 )
13974 solvalsum +=
var->data.multaggr.scalars[
i] * solval;
13984 return var->data.negate.constant - solval;
14001 return var->relaxsol;
14024 var->nlpsol = solval;
14030 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
14043 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14073 if(
var->data.original.transvar ==
NULL )
14079 avgsol =
var->primsolavg;
14080 avgsol =
MAX(avgsol,
var->glbdom.lb);
14081 avgsol =
MIN(avgsol,
var->glbdom.ub);
14086 return var->locdom.lb;
14092 +
var->data.aggregate.constant;
14101 avgsol =
var->data.multaggr.constant;
14102 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14140 *closestvlbidx = -1;
14158 i =
var->closestvlbidx;
14161 *closestvlbidx =
i;
14167 for(
i = 0;
i < nvlbs;
i++ )
14174 if( vlbsol > *closestvlb )
14176 *closestvlb = vlbsol;
14177 *closestvlbidx =
i;
14185 if(
var->closestvblpcount != stat->
lpcount )
14186 var->closestvubidx = -1;
14187 var->closestvlbidx = *closestvlbidx;
14214 *closestvubidx = -1;
14232 i =
var->closestvubidx;
14235 *closestvubidx =
i;
14241 for(
i = 0;
i < nvubs;
i++ )
14248 if( vubsol < *closestvub )
14250 *closestvub = vubsol;
14251 *closestvubidx =
i;
14259 if(
var->closestvblpcount != stat->
lpcount )
14260 var->closestvlbidx = -1;
14261 var->closestvubidx = *closestvubidx;
14297 if(
var->data.original.transvar ==
NULL )
14335 row,
var->data.aggregate.scalar * val) );
14346 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14349 row,
var->data.multaggr.scalars[
i] * val) );
14369#ifdef SCIP_HISTORYTOFILE
14371const char* historypath=
".";
14400 if(
var->data.original.transvar ==
NULL )
14402 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
14423#ifdef SCIP_HISTORYTOFILE
14426 char filename[256];
14433 f = fopen(filename,
"a");
14436 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
14452 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
14458 solvaldelta/
var->data.aggregate.scalar, objdelta, weight) );
14462 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
14490 if(
var->data.original.transvar ==
NULL )
14539 if(
var->data.original.transvar ==
NULL )
14583 if(
var->data.original.transvar ==
NULL )
14596 if(
var->data.aggregate.scalar > 0.0 )
14628 if(
var->data.original.transvar ==
NULL )
14641 if(
var->data.aggregate.scalar > 0.0 )
14687 return MIN(upscore, downscore);
14703 if(
var->data.original.transvar ==
NULL )
14710 if( onlycurrentrun )
14719 if(
var->data.aggregate.scalar > 0.0 )
14760 if( onlycurrentrun )
14767 confidencebound /= count;
14768 confidencebound = sqrt(confidencebound);
14775 confidencebound = 0.0;
14777 return confidencebound;
14801 size =
MIN(downsize, upsize);
14811 if( downsize >= 1.9 )
14817 normval =
MAX(1.0, normval);
14819 relerrordown /= normval;
14822 relerrordown = 0.0;
14824 if( upsize >= 1.9 )
14830 normval =
MAX(1.0, normval);
14831 relerrorup /= normval;
14837 relerror =
MAX(relerrorup, relerrordown);
14839 return (relerror <= threshold);
14888 if( countx <= 1.9 || county <= 1.9 )
14985 SCIPerrorMessage(
"Confidence level set to unknown value <%d>", (
int)clevel);
14990 return (probability >= problimit);
15010 if(
var->valuehistory ==
NULL )
15035 if( !
set->history_valuebased )
15073 if(
var->data.original.transvar ==
NULL )
15075 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15106 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15108 if(
var->data.aggregate.scalar > 0.0 )
15114 assert(
var->data.aggregate.scalar < 0.0);
15124 value = 1.0 - value;
15146 if(
var->data.original.transvar ==
NULL )
15148 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15206 if(
var->data.original.transvar ==
NULL )
15208 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
15237 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15239 if(
var->data.aggregate.scalar > 0.0 )
15245 assert(
var->data.aggregate.scalar < 0.0);
15251 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
15255 value = 1.0 - value;
15280 if(
var->data.original.transvar ==
NULL )
15293 if(
var->data.aggregate.scalar > 0.0 )
15327 if(
var->data.original.transvar ==
NULL )
15340 if(
var->data.aggregate.scalar > 0.0 )
15370 if(
var->data.original.transvar ==
NULL )
15382 if(
var->data.aggregate.scalar > 0.0 )
15414 if(
var->data.original.transvar ==
NULL )
15427 if(
var->data.aggregate.scalar > 0.0 )
15467 if(
var->data.original.transvar ==
NULL )
15469 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
15496 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
15500 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15502 if(
var->data.aggregate.scalar > 0.0 )
15508 assert(
var->data.aggregate.scalar < 0.0);
15514 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
15518 value = 1.0 - value;
15551 if(
var->data.original.transvar ==
NULL )
15553 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
15580 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15584 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15586 if(
var->data.aggregate.scalar > 0.0 )
15592 assert(
var->data.aggregate.scalar < 0.0);
15598 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15602 value = 1.0 - value;
15635 if(
var->data.original.transvar ==
NULL )
15637 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15668 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15670 if(
var->data.aggregate.scalar > 0.0 )
15676 assert(
var->data.aggregate.scalar < 0.0);
15682 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15686 value = 1.0 - value;
15709 if(
var->data.original.transvar ==
NULL )
15722 if(
var->data.aggregate.scalar > 0.0 )
15754 if(
var->data.original.transvar ==
NULL )
15767 if(
var->data.aggregate.scalar > 0.0 )
15797 if(
var->data.original.transvar ==
NULL )
15810 if(
var->data.aggregate.scalar > 0.0 )
15842 if(
var->data.original.transvar ==
NULL )
15855 if(
var->data.aggregate.scalar > 0.0 )
15892 if(
var->data.original.transvar ==
NULL )
15906 if(
var->data.aggregate.scalar > 0.0 )
15939 SCIPerrorMessage(
"invalid branching direction %d when asking for VSIDS value\n", dir);
15946 if(
var->data.original.transvar ==
NULL )
15959 if(
var->data.aggregate.scalar > 0.0 )
15989 if(
var->data.original.transvar ==
NULL )
16002 if(
var->data.aggregate.scalar > 0.0 )
16034 if(
var->data.original.transvar ==
NULL )
16047 if(
var->data.aggregate.scalar > 0.0 )
16079 if(
var->data.original.transvar ==
NULL )
16102 if(
var->data.aggregate.scalar > 0.0 )
16136 if(
var->data.original.transvar ==
NULL )
16159 if(
var->data.aggregate.scalar > 0.0 )
16189 if(
var->data.original.transvar ==
NULL )
16202 if(
var->data.aggregate.scalar > 0.0 )
16232 if(
var->data.original.transvar ==
NULL )
16245 if(
var->data.aggregate.scalar > 0.0 )
16277 if(
var->data.original.transvar ==
NULL )
16292 if(
var->data.aggregate.scalar > 0.0 )
16324 if(
var->data.original.transvar ==
NULL )
16339 if(
var->data.aggregate.scalar > 0.0 )
16369 if(
var->data.original.transvar ==
NULL )
16411 if(
var->data.original.transvar !=
NULL )
16453 if(
var->data.original.transvar !=
NULL )
16495 if(
var->data.original.transvar !=
NULL )
16544 (*bdchginfo)->oldbound = oldbound;
16545 (*bdchginfo)->newbound = newbound;
16546 (*bdchginfo)->var =
var;
16547 (*bdchginfo)->inferencedata.var =
var;
16548 (*bdchginfo)->inferencedata.reason.prop =
NULL;
16549 (*bdchginfo)->inferencedata.info = 0;
16550 (*bdchginfo)->bdchgidx.depth = INT_MAX;
16551 (*bdchginfo)->bdchgidx.pos = -1;
16552 (*bdchginfo)->pos = 0;
16554 (*bdchginfo)->boundtype = boundtype;
16555 (*bdchginfo)->inferboundtype = boundtype;
16556 (*bdchginfo)->redundant =
FALSE;
16590 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16597 if(
var->lbchginfos[
i].redundant )
16599 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16603 return &
var->lbchginfos[
i];
16608 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16615 if(
var->lbchginfos[
i].redundant )
16617 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16621 return &
var->lbchginfos[
i];
16646 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16653 if(
var->ubchginfos[
i].redundant )
16655 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16659 return &
var->ubchginfos[
i];
16664 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16671 if(
var->ubchginfos[
i].redundant )
16673 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16677 return &
var->ubchginfos[
i];
16721 switch( varstatus )
16729 if( bdchgidx ==
NULL )
16736 if( bdchginfo !=
NULL )
16739 return var->glbdom.lb;
16742 return var->glbdom.lb;
16753 if(
var->data.aggregate.scalar > 0.0 )
16759 +
var->data.aggregate.constant;
16761 else if(
var->data.aggregate.scalar < 0.0 )
16767 +
var->data.aggregate.constant;
16778 if (
var->data.multaggr.nvars == 1 )
16784 if(
var->data.multaggr.scalars[0] > 0.0 )
16790 +
var->data.multaggr.constant;
16792 else if(
var->data.multaggr.scalars[0] < 0.0 )
16798 +
var->data.multaggr.constant;
16807 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16840 switch( varstatus )
16848 if( bdchgidx ==
NULL )
16855 if( bdchginfo !=
NULL )
16858 return var->glbdom.ub;
16862 return var->glbdom.ub;
16873 if(
var->data.aggregate.scalar > 0.0 )
16879 +
var->data.aggregate.constant;
16881 else if(
var->data.aggregate.scalar < 0.0 )
16887 +
var->data.aggregate.constant;
16898 if (
var->data.multaggr.nvars == 1 )
16904 if(
var->data.multaggr.scalars[0] > 0.0 )
16910 +
var->data.multaggr.constant;
16912 else if(
var->data.multaggr.scalars[0] < 0.0 )
16918 +
var->data.multaggr.constant;
16927 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
17014 lbchgidx = (
var->nlbchginfos > 0 && !
var->lbchginfos[
var->nlbchginfos-1].redundant
17016 ubchgidx = (
var->nubchginfos > 0 && !
var->ubchginfos[
var->nubchginfos-1].redundant
17038 return bdchgidx->
depth;
17081 return var->ubchginfos[
i].bdchgidx.depth;
17109 return var->lbchginfos[
i].bdchgidx.depth;
17197#undef SCIPboundchgGetNewbound
17198#undef SCIPboundchgGetVar
17199#undef SCIPboundchgGetBoundchgtype
17200#undef SCIPboundchgGetBoundtype
17201#undef SCIPboundchgIsRedundant
17202#undef SCIPdomchgGetNBoundchgs
17203#undef SCIPdomchgGetBoundchg
17204#undef SCIPholelistGetLeft
17205#undef SCIPholelistGetRight
17206#undef SCIPholelistGetNext
17207#undef SCIPvarGetName
17208#undef SCIPvarGetNUses
17209#undef SCIPvarGetData
17210#undef SCIPvarSetData
17211#undef SCIPvarSetDelorigData
17212#undef SCIPvarSetTransData
17213#undef SCIPvarSetDeltransData
17214#undef SCIPvarGetStatus
17215#undef SCIPvarIsOriginal
17216#undef SCIPvarIsTransformed
17217#undef SCIPvarIsNegated
17218#undef SCIPvarGetType
17219#undef SCIPvarIsBinary
17220#undef SCIPvarIsIntegral
17221#undef SCIPvarIsInitial
17222#undef SCIPvarIsRemovable
17223#undef SCIPvarIsDeleted
17224#undef SCIPvarIsDeletable
17225#undef SCIPvarMarkDeletable
17226#undef SCIPvarMarkNotDeletable
17227#undef SCIPvarIsActive
17228#undef SCIPvarGetIndex
17229#undef SCIPvarGetProbindex
17230#undef SCIPvarGetTransVar
17231#undef SCIPvarGetCol
17232#undef SCIPvarIsInLP
17233#undef SCIPvarGetAggrVar
17234#undef SCIPvarGetAggrScalar
17235#undef SCIPvarGetAggrConstant
17236#undef SCIPvarGetMultaggrNVars
17237#undef SCIPvarGetMultaggrVars
17238#undef SCIPvarGetMultaggrScalars
17239#undef SCIPvarGetMultaggrConstant
17240#undef SCIPvarGetNegatedVar
17241#undef SCIPvarGetNegationVar
17242#undef SCIPvarGetNegationConstant
17243#undef SCIPvarGetObj
17244#undef SCIPvarGetLbOriginal
17245#undef SCIPvarGetUbOriginal
17246#undef SCIPvarGetHolelistOriginal
17247#undef SCIPvarGetLbGlobal
17248#undef SCIPvarGetUbGlobal
17249#undef SCIPvarGetHolelistGlobal
17250#undef SCIPvarGetBestBoundGlobal
17251#undef SCIPvarGetWorstBoundGlobal
17252#undef SCIPvarGetLbLocal
17253#undef SCIPvarGetUbLocal
17254#undef SCIPvarGetHolelistLocal
17255#undef SCIPvarGetBestBoundLocal
17256#undef SCIPvarGetWorstBoundLocal
17257#undef SCIPvarGetBestBoundType
17258#undef SCIPvarGetWorstBoundType
17259#undef SCIPvarGetLbLazy
17260#undef SCIPvarGetUbLazy
17261#undef SCIPvarGetBranchFactor
17262#undef SCIPvarGetBranchPriority
17263#undef SCIPvarGetBranchDirection
17264#undef SCIPvarGetNVlbs
17265#undef SCIPvarGetVlbVars
17266#undef SCIPvarGetVlbCoefs
17267#undef SCIPvarGetVlbConstants
17268#undef SCIPvarGetNVubs
17269#undef SCIPvarGetVubVars
17270#undef SCIPvarGetVubCoefs
17271#undef SCIPvarGetVubConstants
17272#undef SCIPvarGetNImpls
17273#undef SCIPvarGetImplVars
17274#undef SCIPvarGetImplTypes
17275#undef SCIPvarGetImplBounds
17276#undef SCIPvarGetImplIds
17277#undef SCIPvarGetNCliques
17278#undef SCIPvarGetCliques
17279#undef SCIPvarGetLPSol
17280#undef SCIPvarGetNLPSol
17281#undef SCIPvarGetBdchgInfoLb
17282#undef SCIPvarGetNBdchgInfosLb
17283#undef SCIPvarGetBdchgInfoUb
17284#undef SCIPvarGetNBdchgInfosUb
17285#undef SCIPvarGetValuehistory
17286#undef SCIPvarGetPseudoSol
17287#undef SCIPvarCatchEvent
17288#undef SCIPvarDropEvent
17289#undef SCIPvarGetVSIDS
17290#undef SCIPvarGetCliqueComponentIdx
17291#undef SCIPvarIsRelaxationOnly
17292#undef SCIPvarMarkRelaxationOnly
17293#undef SCIPbdchgidxGetPos
17294#undef SCIPbdchgidxIsEarlierNonNull
17295#undef SCIPbdchgidxIsEarlier
17296#undef SCIPbdchginfoGetOldbound
17297#undef SCIPbdchginfoGetNewbound
17298#undef SCIPbdchginfoGetVar
17299#undef SCIPbdchginfoGetChgtype
17300#undef SCIPbdchginfoGetBoundtype
17301#undef SCIPbdchginfoGetDepth
17302#undef SCIPbdchginfoGetPos
17303#undef SCIPbdchginfoGetIdx
17304#undef SCIPbdchginfoGetInferVar
17305#undef SCIPbdchginfoGetInferCons
17306#undef SCIPbdchginfoGetInferProp
17307#undef SCIPbdchginfoGetInferInfo
17308#undef SCIPbdchginfoGetInferBoundtype
17309#undef SCIPbdchginfoIsRedundant
17310#undef SCIPbdchginfoHasInferenceReason
17311#undef SCIPbdchginfoIsTighter
17331 return boundchg->
var;
17411 return holelist->
next;
17444 return var->vardata;
17455 var->vardata = vardata;
17467 var->vardelorig = vardelorig;
17479 var->vartrans = vartrans;
17490 var->vardeltrans = vardeltrans;
17501 var->varcopy = varcopy;
17515 var->initial = initial;
17531 var->removable = removable;
17625 return var->initial;
17635 return var->removable;
17645 return var->deleted;
17681 var->delglobalstructs =
TRUE;
17691 return var->delglobalstructs;
17711 return var->relaxationonly;
17743 return var->deletable;
17753 return (
var->probindex >= 0);
17773 return var->probindex;
17784 return var->data.original.transvar;
17795 return var->data.col;
17817 return var->data.aggregate.var;
17829 return var->data.aggregate.scalar;
17841 return var->data.aggregate.constant;
17853 return var->data.multaggr.nvars;
17865 return var->data.multaggr.vars;
17877 return var->data.multaggr.scalars;
17889 return var->data.multaggr.constant;
17899 return var->negatedvar;
17910 return var->negatedvar;
17921 return var->data.negate.constant;
17941 return var->unchangedobj;
17958 while( probvar !=
NULL )
18031 return var->data.original.origdom.lb;
18038 return var->data.negate.constant -
var->negatedvar->data.original.origdom.ub;
18051 return var->data.original.origdom.ub;
18058 return var->data.negate.constant -
var->negatedvar->data.original.origdom.lb;
18071 return var->data.original.origdom.holelist;
18083 return var->glbdom.lb;
18093 return var->glbdom.ub;
18103 return var->glbdom.holelist;
18113 if(
var->obj >= 0.0 )
18114 return var->glbdom.lb;
18116 return var->glbdom.ub;
18126 if(
var->obj >= 0.0 )
18127 return var->glbdom.ub;
18129 return var->glbdom.lb;
18139 return var->locdom.lb;
18149 return var->locdom.ub;
18159 return var->locdom.holelist;
18169 if(
var->obj >= 0.0 )
18170 return var->locdom.lb;
18172 return var->locdom.ub;
18182 if(
var->obj >= 0.0 )
18183 return var->locdom.ub;
18185 return var->locdom.lb;
18195 if(
var->obj >= 0.0 )
18208 if(
var->obj >= 0.0 )
18221 return var->lazylb;
18231 return var->lazyub;
18243 return var->branchfactor;
18255 return var->branchpriority;
18471 return var->nlpsol;
18483 assert(pos < var->nlbchginfos);
18485 return &
var->lbchginfos[pos];
18493 return var->nlbchginfos;
18503 assert(pos < var->nubchginfos);
18505 return &
var->ubchginfos[pos];
18515 return var->nubchginfos;
18525 return var->valuehistory;
18576 eventtype,
var->name, (
void*)eventhdlr, (
void*)eventdata);
18600 SCIPsetDebugMsg(
set,
"drop event of variable <%s> with handler %p and data %p\n",
var->name, (
void*)eventhdlr,
18615 return bdchgidx->
pos;
18631 return (bdchgidx1->
depth < bdchgidx2->
depth)
18632 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18649 if( bdchgidx1 ==
NULL )
18651 else if( bdchgidx2 ==
NULL )
18654 return (bdchgidx1->
depth < bdchgidx2->
depth)
18655 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18685 return bdchginfo->
var;
static GRAPHNODE ** active
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
internal methods for constraints and constraint handlers
#define SCIPdebugCheckLbGlobal(scip, var, lb)
#define SCIPdebugCheckImplic(set, var, varfixing, implvar, impltype, implbound)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
#define SCIPdebugCheckVbound(set, var, vbtype, vbvar, vbcoef, vbconstant)
#define SCIPdebugCheckAggregation(set, var, aggrvars, scalars, constant, naggrvars)
#define SCIP_DEFAULT_INFINITY
#define SCIP_CALL_ABORT(x)
SCIP_RETCODE SCIPeventCreateLbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateVarFixed(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateUbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateVarUnlocked(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateObjChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)
SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPeventCreateGholeAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)
SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPeventCreateImplAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)
SCIP_RETCODE SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPeventCreateGubChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateGlbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventCreateTypeChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_VARTYPE oldtype, SCIP_VARTYPE newtype)
internal methods for managing events
const char * SCIPgetProbName(SCIP *scip)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
void SCIPvarSetTransData(SCIP_VAR *var,)
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
void SCIPvarSetDelorigData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
SCIP_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
void SCIPvarMarkDeletable(SCIP_VAR *var)
void SCIPvarGetImplicVarBounds(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Real *lb, SCIP_Real *ub)
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
int SCIPvarGetNUses(SCIP_VAR *var)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLazy(SCIP_VAR *var)
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
void SCIPvarSetDeltransData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
SCIP_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
int SCIPvarGetBranchPriority(SCIP_VAR *var)
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
int SCIPvarGetNLocksUp(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
void SCIPvarSetCopyData(SCIP_VAR *var,)
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
SCIP_Real SCIPnormalCDF(SCIP_Real mean, SCIP_Real variance, SCIP_Real value)
SCIP_Real SCIPcomputeTwoSampleTTestValue(SCIP_Real meanx, SCIP_Real meany, SCIP_Real variancex, SCIP_Real variancey, SCIP_Real countx, SCIP_Real county)
SCIP_Real SCIPstudentTGetCriticalValue(SCIP_CONFIDENCELEVEL clevel, int df)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
SCIP_RETCODE SCIPvaluehistoryCreate(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvaluehistoryFind(SCIP_VALUEHISTORY *valuehistory, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real value, SCIP_HISTORY **history)
void SCIPvaluehistoryFree(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
void SCIPvaluehistoryScaleVSIDS(SCIP_VALUEHISTORY *valuehistory, SCIP_Real scalar)
assert(minobj< SCIPgetCutoffbound(scip))
void SCIPhistoryReset(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPhistoryGetNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistorySetLastGMIeff(SCIP_HISTORY *history, SCIP_Real gmieff)
void SCIPhistoryIncInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)
void SCIPhistoryIncNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real length)
void SCIPhistoryScaleVSIDS(SCIP_HISTORY *history, SCIP_Real scalar)
void SCIPhistoryIncCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
void SCIPhistoryIncNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, int depth)
void SCIPhistoryUpdatePseudocost(SCIP_HISTORY *history, SCIP_SET *set, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgBranchdepth(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetLastGMIeff(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetAvgGMIeff(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistoryUnite(SCIP_HISTORY *history, SCIP_HISTORY *addhistory, SCIP_Bool switcheddirs)
void SCIPhistoryIncGMIeffSum(SCIP_HISTORY *history, SCIP_Real gmieff)
SCIP_BRANCHDIR SCIPbranchdirOpposite(SCIP_BRANCHDIR dir)
void SCIPhistoryIncVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
internal methods for branching and inference history
SCIP_VAR ** SCIPimplicsGetVars(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
void SCIPcliqueDelVar(SCIP_CLIQUE *clique, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool value)
void SCIPcliquelistRemoveFromCliques(SCIP_CLIQUELIST *cliquelist, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool irrelevantvar)
void SCIPvboundsFree(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem)
SCIP_Real * SCIPvboundsGetCoefs(SCIP_VBOUNDS *vbounds)
void SCIPvboundsShrink(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, int newnvbds)
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
SCIP_CLIQUE ** SCIPcliquelistGetCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_Bool SCIPcliquelistsHaveCommonClique(SCIP_CLIQUELIST *cliquelist1, SCIP_Bool value1, SCIP_CLIQUELIST *cliquelist2, SCIP_Bool value2)
SCIP_Real * SCIPimplicsGetBounds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
void SCIPcliquelistCheck(SCIP_CLIQUELIST *cliquelist, SCIP_VAR *var)
SCIP_VAR ** SCIPvboundsGetVars(SCIP_VBOUNDS *vbounds)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPvboundsDel(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_VAR *vbdvar, SCIP_Bool negativecoef)
SCIP_RETCODE SCIPcliquetableAdd(SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
int * SCIPimplicsGetIds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_RETCODE SCIPimplicsAdd(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool isshortcut, SCIP_Bool *conflict, SCIP_Bool *added)
SCIP_RETCODE SCIPvboundsAdd(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BOUNDTYPE vboundtype, SCIP_VAR *var, SCIP_Real coef, SCIP_Real constant, SCIP_Bool *added)
void SCIPcliquelistFree(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem)
int SCIPimplicsGetNImpls(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_RETCODE SCIPcliqueAddVar(SCIP_CLIQUE *clique, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_Bool value, SCIP_Bool *doubleentry, SCIP_Bool *oppositeentry)
SCIP_BOUNDTYPE * SCIPimplicsGetTypes(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
int SCIPcliquelistGetNCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_RETCODE SCIPcliquelistDel(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_Bool SCIPcliqueIsCleanedUp(SCIP_CLIQUE *clique)
void SCIPimplicsGetVarImplicPoss(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, int *lowerimplicpos, int *upperimplicpos)
SCIP_RETCODE SCIPimplicsDel(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_Real * SCIPvboundsGetConstants(SCIP_VBOUNDS *vbounds)
int SCIPvboundsGetNVbds(SCIP_VBOUNDS *vbounds)
SCIP_Bool SCIPimplicsContainsImpl(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
void SCIPimplicsFree(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPcliquelistAdd(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
methods for implications, variable bounds, and cliques
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
SCIP_RETCODE SCIPcolChgUb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newub)
SCIP_RETCODE SCIPcolFree(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
void SCIPlpDecNLoosevars(SCIP_LP *lp)
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
SCIP_RETCODE SCIProwIncCoef(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_COL *col, SCIP_Real incval)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPcolCreate(SCIP_COL **col, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, int len, SCIP_ROW **rows, SCIP_Real *vals, SCIP_Bool removable)
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static const SCIP_Real scalars[]
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
internal methods for LP management
#define BMSreallocBlockMemorySize(mem, ptr, oldsize, newsize)
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSfreeBlockMemorySize(mem, ptr, size)
#define BMScopyMemoryArray(ptr, source, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSallocBlockMemorySize(mem, ptr, size)
struct BMS_BlkMem BMS_BLKMEM
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_RETCODE SCIPprimalUpdateObjoffset(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
internal methods for collecting primal CIP solutions and primal informations
void SCIPprobUpdateNObjVars(SCIP_PROB *prob, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
int SCIPprobGetNContVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobAddVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var)
SCIP_RETCODE SCIPprobVarChangedStatus(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
const char * SCIPprobGetName(SCIP_PROB *prob)
void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
internal methods for storing and manipulating the main problem
public methods for managing constraints
public methods for branching and inference history structure
public methods for implications, variable bounds, and cliques
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for propagators
public methods for problem variables
void SCIPrelaxationSolObjAdd(SCIP_RELAXATION *relaxation, SCIP_Real val)
internal methods for relaxators
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetGetHugeValue(SCIP_SET *set)
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetFreeCleanBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define SCIPsetAllocCleanBufferArray(set, ptr, num)
#define SCIPsetDuplicateBufferArray(set, ptr, source, num)
#define SCIPsetReallocBufferArray(set, ptr, num)
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
internal methods for storing primal CIP solutions
SCIP_RETCODE SCIPstatUpdateVarRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldrootpscostscore)
internal methods for problem statistics
#define SCIPstatIncrement(stat, set, field)
SCIP_INFERENCEDATA inferencedata
unsigned int boundchgtype
unsigned int inferboundtype
union SCIP_BoundChg::@126301315365336333353356203157377037022074222233 data
SCIP_INFERENCEDATA inferencedata
SCIP_BRANCHINGDATA branchingdata
unsigned int inferboundtype
unsigned int boundchgtype
SCIP_BOUNDCHG * boundchgs
SCIP_BOUNDCHG * boundchgs
SCIP_HISTORY * glbhistory
SCIP_BRANCHDIR lastbranchdir
SCIP_Bool collectvarhistory
SCIP_HISTORY * glbhistorycrun
SCIP_Real lastbranchvalue
SCIP_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