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) );
10046 SCIPsetDebugMsg(
set,
" -> transformed to variable lower bound <%s> >= %g<%s> + %g\n",
10050 if(
var == vlbvar )
10056 *infeasible =
TRUE;
10066 SCIP_Real newub = vlbconstant / (1.0 - vlbcoef);
10070 *infeasible =
TRUE;
10095 if( nbdchgs !=
NULL )
10106 newlb = vlbconstant / (1.0 - vlbcoef);
10110 *infeasible =
TRUE;
10135 if( nbdchgs !=
NULL )
10145 *infeasible =
TRUE;
10165 if( nbdchgs !=
NULL )
10190 if( vlbcoef >= 0.0 )
10197 newzub = (xub - vlbconstant)/vlbcoef;
10205 *infeasible =
TRUE;
10231 if( nbdchgs !=
NULL )
10234 maxvlb = vlbcoef * zub + vlbconstant;
10236 minvlb = vlbcoef * zlb + vlbconstant;
10241 maxvlb = vlbcoef * zub + vlbconstant;
10243 minvlb = vlbcoef * zlb + vlbconstant;
10253 newzlb = (xub - vlbconstant)/vlbcoef;
10261 *infeasible =
TRUE;
10287 if( nbdchgs !=
NULL )
10290 maxvlb = vlbcoef * zlb + vlbconstant;
10292 minvlb = vlbcoef * zub + vlbconstant;
10297 maxvlb = vlbcoef * zlb + vlbconstant;
10299 minvlb = vlbcoef * zub + vlbconstant;
10302 if( maxvlb < minvlb )
10312 *infeasible =
TRUE;
10339 if( nbdchgs !=
NULL )
10353 if( vlbcoef >= 0.0 )
10355 vlbcoef = maxvlb - minvlb;
10356 vlbconstant = minvlb;
10360 vlbcoef = minvlb - maxvlb;
10361 vlbconstant = maxvlb;
10382 infeasible, nbdchgs) );
10391 implbound = -vlbconstant/vlbcoef;
10403 implbound, transitive, infeasible, nbdchgs) );
10423 if(
var->data.aggregate.var == vlbvar &&
SCIPsetIsEQ(
set,
var->data.aggregate.scalar, vlbcoef) )
10426 *infeasible =
TRUE;
10432 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10433 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10439 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef/
var->data.aggregate.scalar,
10440 (vlbconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10458 SCIP_CALL(
SCIPvarAddVub(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10459 branchcand, eventqueue, vlbvar, -vlbcoef,
var->data.negate.constant - vlbconstant, transitive, infeasible,
10504 *infeasible =
FALSE;
10505 if( nbdchgs !=
NULL )
10513 cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );
10521 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10525 if(
var == vubvar )
10531 *infeasible =
TRUE;
10541 SCIP_Real newlb = vubconstant / (1.0 - vubcoef);
10545 *infeasible =
TRUE;
10570 if( nbdchgs !=
NULL )
10581 newub = vubconstant / (1.0 - vubcoef);
10585 *infeasible =
TRUE;
10610 if( nbdchgs !=
NULL )
10620 *infeasible =
TRUE;
10640 if( nbdchgs !=
NULL )
10665 if( vubcoef >= 0.0 )
10672 newzlb = (xlb - vubconstant)/vubcoef;
10675 *infeasible =
TRUE;
10701 if( nbdchgs !=
NULL )
10704 minvub = vubcoef * zlb + vubconstant;
10706 maxvub = vubcoef * zub + vubconstant;
10711 maxvub = vubcoef * zub + vubconstant;
10713 minvub = vubcoef * zlb + vubconstant;
10723 newzub = (xlb - vubconstant)/vubcoef;
10726 *infeasible =
TRUE;
10752 if( nbdchgs !=
NULL )
10755 minvub = vubcoef * zub + vubconstant;
10757 maxvub = vubcoef * zlb + vubconstant;
10762 minvub = vubcoef * zub + vubconstant;
10764 maxvub = vubcoef * zlb + vubconstant;
10767 if( minvub > maxvub )
10777 *infeasible =
TRUE;
10805 if( nbdchgs !=
NULL )
10819 if( vubcoef >= 0.0 )
10821 vubcoef = maxvub - minvub;
10822 vubconstant = minvub;
10826 vubcoef = minvub - maxvub;
10827 vubconstant = maxvub;
10848 infeasible, nbdchgs) );
10858 (1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );
10878 if(
var->data.aggregate.var == vubvar &&
SCIPsetIsEQ(
set,
var->data.aggregate.scalar, vubcoef) )
10881 *infeasible =
TRUE;
10887 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10888 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10894 cliquetable, branchcand, eventqueue, vubvar, vubcoef/
var->data.aggregate.scalar,
10895 (vubconstant -
var->data.aggregate.constant)/
var->data.aggregate.scalar, transitive, infeasible, nbdchgs) );
10913 SCIP_CALL(
SCIPvarAddVlb(
var->negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10914 branchcand, eventqueue, vubvar, -vubcoef,
var->data.negate.constant - vubconstant, transitive, infeasible,
10960 *infeasible =
FALSE;
10961 if( nbdchgs !=
NULL )
10969 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10983 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10984 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
10993 SCIP_CALL(
varAddTransitiveImplic(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10994 branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11003 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
11004 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
11024 if(
var->data.aggregate.scalar > 0 )
11027 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
11033 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,
11057 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
11065 SCIP_CALL(
SCIPvarAddImplic(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11068 infeasible, nbdchgs) );
11083 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? 1.0 : -1.0,
11092 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? -1.0 : 1.0,
11102 SCIP_CALL(
SCIPvarAddVub(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11103 branchcand, eventqueue,
var->negatedvar, (varfixing) ? 1.0 : -1.0,
11104 (varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );
11111 SCIP_CALL(
SCIPvarAddVlb(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
11112 branchcand, eventqueue,
var->negatedvar, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,
11113 transitive, infeasible, nbdchgs) );
11190 if( bounds ==
NULL )
11193 if( lowerpos >= 0 )
11194 *lb = bounds[lowerpos];
11196 if( upperpos >= 0 )
11197 *ub = bounds[upperpos];
11225 *infeasible =
FALSE;
11227 if( value ==
FALSE )
11229 if(
var->glbdom.lb > 0.5 )
11230 *infeasible =
TRUE;
11231 else if(
var->glbdom.ub > 0.5 )
11250 if( nbdchgs !=
NULL )
11256 if(
var->glbdom.ub < 0.5 )
11257 *infeasible =
TRUE;
11258 else if(
var->glbdom.lb < 0.5 )
11277 if( nbdchgs !=
NULL )
11315 *infeasible =
FALSE;
11343 SCIP_CALL(
SCIPvarFixBinary(
var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11344 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
11350 if( oppositeentry )
11360 for(
i = 0;
i <
nvars && !(*infeasible); ++
i )
11365 SCIP_CALL(
SCIPvarFixBinary(
vars[
i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
11366 eventqueue, cliquetable, !values[
i], infeasible, nbdchgs) );
11394 for( v =
nvars - 1; v >= 0; --v )
11532 branchfactor =
MAX(branchfactor,
eps);
11534 SCIPsetDebugMsg(
set,
"process changing branch factor of <%s> from %f to %f\n",
var->name,
var->branchfactor, branchfactor);
11540 var->branchfactor = branchfactor;
11543 for(
i = 0;
i <
var->nparentvars; ++
i )
11545 parentvar =
var->parentvars[
i];
11558 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11591 assert(branchfactor >= 0.0);
11593 SCIPdebugMessage(
"changing branch factor of <%s> from %g to %g\n",
var->name,
var->branchfactor, branchfactor);
11602 if(
var->data.original.transvar !=
NULL )
11609 var->branchfactor = branchfactor;
11627 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11661 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11662 var->name,
var->branchpriority, branchpriority);
11664 if( branchpriority ==
var->branchpriority )
11668 var->branchpriority = branchpriority;
11671 for(
i = 0;
i <
var->nparentvars; ++
i )
11673 parentvar =
var->parentvars[
i];
11686 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11716 SCIPdebugMessage(
"changing branch priority of <%s> from %d to %d\n",
var->name,
var->branchpriority, branchpriority);
11718 if(
var->branchpriority == branchpriority )
11725 if(
var->data.original.transvar !=
NULL )
11730 var->branchpriority = branchpriority;
11747 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11781 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11782 var->name,
var->branchdirection, branchdirection);
11788 var->branchdirection = branchdirection;
11791 for(
i = 0;
i <
var->nparentvars; ++
i )
11793 parentvar =
var->parentvars[
i];
11806 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11847 SCIPdebugMessage(
"changing branch direction of <%s> from %u to %d\n",
var->name,
var->branchdirection, branchdirection);
11856 if(
var->data.original.transvar !=
NULL )
11861 var->branchdirection = branchdirection;
11873 if(
var->data.aggregate.scalar > 0.0 )
11885 for( v = 0; v <
var->data.multaggr.nvars; ++v )
11891 if(
var->data.multaggr.scalars[v] > 0.0 )
11998 else if( obj1 > obj2 )
12040 int activevarssize;
12064 activevarssize = *
nvars;
12066 tmpvarssize = *
nvars;
12073 noldtmpvars = ntmpvars;
12076 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12077 for( v = ntmpvars - 1; v > 0; --v )
12083 tmpvars[v] = tmpvars[ntmpvars];
12087 if( noldtmpvars > ntmpvars )
12088 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12091 while( ntmpvars >= 1 )
12094 var = tmpvars[ntmpvars];
12100 if(
var->data.original.transvar ==
NULL )
12102 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12106 tmpvars[ntmpvars] =
var->data.original.transvar;
12111 tmpvars[ntmpvars] =
var->data.aggregate.var;
12116 tmpvars[ntmpvars] =
var->negatedvar;
12123 if( nactivevars >= activevarssize )
12125 activevarssize *= 2;
12127 assert(nactivevars < activevarssize);
12129 activevars[nactivevars] =
var;
12135 nmultvars =
var->data.multaggr.nvars;
12136 multvars =
var->data.multaggr.vars;
12139 if( nmultvars + ntmpvars > tmpvarssize )
12141 while( nmultvars + ntmpvars > tmpvarssize )
12144 assert(nmultvars + ntmpvars <= tmpvarssize);
12153 ntmpvars += nmultvars;
12154 noldtmpvars = ntmpvars;
12157 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12158 for( v = ntmpvars - 1; v > 0; --v )
12164 tmpvars[v] = tmpvars[ntmpvars];
12168 if( noldtmpvars > ntmpvars )
12169 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
12185 SCIPsortPtr((
void**)activevars, SCIPvarComp, nactivevars);
12188 v = nactivevars - 1;
12195 activevars[v] = activevars[nactivevars];
12199 *requiredsize = nactivevars;
12201 if( varssize >= *requiredsize )
12205 *
nvars = *requiredsize;
12227 for( v =
nvars - 1; v >= 0; --v )
12259 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12313 for( v =
nvars - 1; v >= 0; --v )
12315 var = &((*vars)[v]);
12316 negated = &((*negatedarr)[v]);
12347 orignegated = *negated;
12355 if( (*var)->data.original.transvar ==
NULL )
12357 *
var = (*var)->data.original.transvar;
12368 if ( (*var)->data.multaggr.nvars == 1 )
12370 assert( (*var)->data.multaggr.vars !=
NULL );
12371 assert( (*var)->data.multaggr.scalars !=
NULL );
12373 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1e-06));
12383 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)) )
12385 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12394 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )
12404 assert(
EPSZ((*var)->data.multaggr.constant, 1e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06)
12405 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)
12406 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));
12408 if( !
EPSZ((*var)->data.multaggr.constant, 1e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) )
12414 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12416 if(
EPSZ((*var)->data.multaggr.constant, 1e-06) )
12422 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?
12428 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
12430 constant += (*negated) != orignegated ? -1.0 : 1.0;
12433 *negated = !(*negated);
12435 *
var = (*var)->data.multaggr.vars[0];
12444 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1e-06));
12445 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));
12447 constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
12450 *negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);
12451 *
var = (*var)->data.aggregate.var;
12457 constant += (*negated) != orignegated ? -1.0 : 1.0;
12460 *negated = !(*negated);
12461 *
var = (*var)->negatedvar;
12475 assert(
EPSZ(constant, 1e-06) == ((*negated) == orignegated));
12500 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
12505 if( (*var)->data.original.transvar ==
NULL )
12507 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12510 *
var = (*var)->data.original.transvar;
12521 if ( (*var)->data.multaggr.nvars == 1 )
12523 assert( (*var)->data.multaggr.vars !=
NULL );
12524 assert( (*var)->data.multaggr.scalars !=
NULL );
12525 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
12527 (*bound) /= (*var)->data.multaggr.scalars[0];
12528 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
12529 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
12536 *
var = (*var)->data.multaggr.vars[0];
12543 assert((*var)->data.aggregate.scalar != 0.0);
12545 (*bound) /= (*var)->data.aggregate.scalar;
12546 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12547 if( (*var)->data.aggregate.scalar < 0.0 )
12554 *
var = (*var)->data.aggregate.var;
12561 assert((*var)->negatedvar->negatedvar == *
var);
12562 (*bound) = (*var)->data.negate.constant - *
bound;
12567 *
var = (*var)->negatedvar;
12593 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
12598 if( (*var)->data.original.transvar ==
NULL )
12600 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12603 *
var = (*var)->data.original.transvar;
12615 assert((*var)->data.aggregate.scalar != 0.0);
12618 (*left) /= (*var)->data.aggregate.scalar;
12619 (*right) /= (*var)->data.aggregate.scalar;
12622 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12623 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12625 *
var = (*var)->data.aggregate.var;
12628 if( (*var)->data.aggregate.scalar < 0.0 )
12641 assert((*var)->negatedvar->negatedvar == *
var);
12644 (*left) = (*var)->data.negate.constant - (*left);
12645 (*right) = (*var)->data.negate.constant - (*right);
12647 *
var = (*var)->negatedvar;
12683 if( (*var)->data.original.transvar ==
NULL )
12685 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12688 *
var = (*var)->data.original.transvar;
12701 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12707 (*constant) += *scalar * (*var)->glbdom.lb;
12723 if ( (*var)->data.multaggr.nvars == 1 )
12726 assert((*var)->data.multaggr.scalars !=
NULL);
12727 assert((*var)->data.multaggr.vars[0] !=
NULL);
12737 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12750 (*constant) += *scalar * (*var)->data.multaggr.constant;
12752 (*scalar) *= (*var)->data.multaggr.scalars[0];
12753 *
var = (*var)->data.multaggr.vars[0];
12763 (*constant) += *scalar * (*var)->data.aggregate.constant;
12764 (*scalar) *= (*var)->data.aggregate.scalar;
12765 *
var = (*var)->data.aggregate.var;
12771 assert((*var)->negatedvar->negatedvar == *
var);
12775 (*constant) += *scalar * (*var)->data.negate.constant;
12777 *
var = (*var)->negatedvar;
12812 if( (*var)->nparentvars == 0 )
12818 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *
var) )
12821 *constant -= (*var)->data.negate.constant * (*scalar);
12822 *
var = (*var)->negatedvar;
12850 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12892 parentvar =
var->parentvars[0];
12932 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12974 return var->locdom.lb;
12983 else if(
var->data.aggregate.scalar > 0.0 )
12988 else if(
var->data.aggregate.scalar < 0.0 )
13002 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
13044 return var->locdom.ub;
13053 if(
var->data.aggregate.scalar > 0.0 )
13058 else if(
var->data.aggregate.scalar < 0.0 )
13071 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
13098 if(
var->data.original.transvar ==
NULL )
13111 return var->locdom.lb;
13130 return var->data.aggregate.scalar * lpsolval +
var->data.aggregate.constant;
13144 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13179 return var->nlpsol;
13189 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13192 solval =
var->data.multaggr.constant;
13193 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13199 return var->data.negate.constant - solval;
13222 if(
var->data.original.transvar ==
NULL )
13232 return var->locdom.lb;
13249 return var->data.aggregate.scalar * pseudosolval +
var->data.aggregate.constant;
13258 pseudosol =
var->data.multaggr.constant;
13259 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13326 if(
var->bestrootredcost > 0.0 )
13331 currcutoffbound = (
bound -
var->bestrootsol) *
var->bestrootredcost +
var->bestrootlpobjval;
13336 if( rootredcost > 0.0 )
13341 cutoffbound = (
bound -
rootsol) * rootredcost + rootlpobjval;
13344 if( cutoffbound > currcutoffbound )
13350 var->bestrootredcost = rootredcost;
13351 var->bestrootlpobjval = rootlpobjval;
13362 var->bestrootredcost = rootredcost;
13363 var->bestrootlpobjval = rootlpobjval;
13382 if(
var->data.original.transvar ==
NULL )
13388 return var->rootsol;
13392 return var->locdom.lb;
13416 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13484#define MAX_CLIQUELENGTH 50
13507#ifdef SCIP_MORE_DEBUG
13545 for(
c = ncliques - 1;
c >= 0; --
c )
13547 clique = cliques[
c];
13562 for( v = nclqvars - 1; v >= 0; --v )
13564 clqvar = clqvars[v];
13572 assert(0 < probindex && probindex < nentries);
13574#ifdef SCIP_DISABLED_CODE
13578 assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));
13580 if( entries[probindex] == 0 )
13582 ids[nids] = probindex;
13586 entries[probindex] = (clqvalues[v] ? probindex : -probindex);
13596 for( v = nids - 1; v >= 0; --v )
13599 assert(0 <
id &&
id < nentries);
13600 assert(entries[
id] != 0);
13606 if( (entries[
id] > 0) != varfixing )
13612 implredcost += redcost;
13622#ifdef SCIP_MORE_DEBUG
13648 for( v =
nvars - 1; v >= 0; --v )
13676 redcost *= (lb - bounds[v]);
13678 redcost *= (bounds[v] - lb);
13686 redcost *= (bounds[v] - ub);
13688 redcost *= (ub - bounds[v]);
13702 redcost *= (lb - bounds[v]);
13704 redcost *= (bounds[v] - lb);
13712 redcost *= (bounds[v] - ub);
13714 redcost *= (ub - bounds[v]);
13720 implredcost += redcost;
13724#ifdef SCIP_MORE_DEBUG
13725 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13729 return implredcost;
13747 if(
var->data.original.transvar ==
NULL )
13753 return var->bestrootsol;
13757 return var->locdom.lb;
13781 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13811 if(
var->data.original.transvar ==
NULL )
13817 return var->bestrootredcost;
13845 if(
var->data.original.transvar ==
NULL )
13851 return var->bestrootlpobjval;
13877 var->bestrootredcost = rootredcost;
13878 var->bestrootlpobjval = rootlpobjval;
13906 var->relaxsol = solval;
13912 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13921 (solval -
var->data.aggregate.constant)/
var->data.aggregate.scalar, updateobj) );
13924 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13964 return var->relaxsol;
13976 if(
var->data.aggregate.scalar * solval > 0.0 )
13978 if(
var->data.aggregate.scalar * solval < 0.0 )
13981 return var->data.aggregate.scalar * solval +
var->data.aggregate.constant;
13984 solvalsum =
var->data.multaggr.constant;
13985 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
13990 if(
var->data.multaggr.scalars[
i] * solval > 0.0 )
13992 if(
var->data.multaggr.scalars[
i] * solval < 0.0 )
13995 solvalsum +=
var->data.multaggr.scalars[
i] * solval;
14005 return var->data.negate.constant - solval;
14022 return var->relaxsol;
14045 var->nlpsol = solval;
14051 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
14064 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
14094 if(
var->data.original.transvar ==
NULL )
14100 avgsol =
var->primsolavg;
14101 avgsol =
MAX(avgsol,
var->glbdom.lb);
14102 avgsol =
MIN(avgsol,
var->glbdom.ub);
14107 return var->locdom.lb;
14113 +
var->data.aggregate.constant;
14122 avgsol =
var->data.multaggr.constant;
14123 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14161 *closestvlbidx = -1;
14179 i =
var->closestvlbidx;
14182 *closestvlbidx =
i;
14188 for(
i = 0;
i < nvlbs;
i++ )
14195 if( vlbsol > *closestvlb )
14197 *closestvlb = vlbsol;
14198 *closestvlbidx =
i;
14206 if(
var->closestvblpcount != stat->
lpcount )
14207 var->closestvubidx = -1;
14208 var->closestvlbidx = *closestvlbidx;
14235 *closestvubidx = -1;
14253 i =
var->closestvubidx;
14256 *closestvubidx =
i;
14262 for(
i = 0;
i < nvubs;
i++ )
14269 if( vubsol < *closestvub )
14271 *closestvub = vubsol;
14272 *closestvubidx =
i;
14280 if(
var->closestvblpcount != stat->
lpcount )
14281 var->closestvlbidx = -1;
14282 var->closestvubidx = *closestvubidx;
14318 if(
var->data.original.transvar ==
NULL )
14356 row,
var->data.aggregate.scalar * val) );
14367 for(
i = 0;
i <
var->data.multaggr.nvars; ++
i )
14370 row,
var->data.multaggr.scalars[
i] * val) );
14390#ifdef SCIP_HISTORYTOFILE
14392const char* historypath=
".";
14421 if(
var->data.original.transvar ==
NULL )
14423 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
14444#ifdef SCIP_HISTORYTOFILE
14447 char filename[256];
14454 f = fopen(filename,
"a");
14457 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
14473 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
14479 solvaldelta/
var->data.aggregate.scalar, objdelta, weight) );
14483 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
14511 if(
var->data.original.transvar ==
NULL )
14560 if(
var->data.original.transvar ==
NULL )
14604 if(
var->data.original.transvar ==
NULL )
14617 if(
var->data.aggregate.scalar > 0.0 )
14649 if(
var->data.original.transvar ==
NULL )
14662 if(
var->data.aggregate.scalar > 0.0 )
14708 return MIN(upscore, downscore);
14724 if(
var->data.original.transvar ==
NULL )
14731 if( onlycurrentrun )
14740 if(
var->data.aggregate.scalar > 0.0 )
14781 if( onlycurrentrun )
14788 confidencebound /= count;
14789 confidencebound = sqrt(confidencebound);
14796 confidencebound = 0.0;
14798 return confidencebound;
14822 size =
MIN(downsize, upsize);
14832 if( downsize >= 1.9 )
14838 normval =
MAX(1.0, normval);
14840 relerrordown /= normval;
14843 relerrordown = 0.0;
14845 if( upsize >= 1.9 )
14851 normval =
MAX(1.0, normval);
14852 relerrorup /= normval;
14858 relerror =
MAX(relerrorup, relerrordown);
14860 return (relerror <= threshold);
14909 if( countx <= 1.9 || county <= 1.9 )
15006 SCIPerrorMessage(
"Confidence level set to unknown value <%d>", (
int)clevel);
15011 return (probability >= problimit);
15031 if(
var->valuehistory ==
NULL )
15056 if( !
set->history_valuebased )
15094 if(
var->data.original.transvar ==
NULL )
15096 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15127 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15129 if(
var->data.aggregate.scalar > 0.0 )
15135 assert(
var->data.aggregate.scalar < 0.0);
15145 value = 1.0 - value;
15167 if(
var->data.original.transvar ==
NULL )
15169 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
15227 if(
var->data.original.transvar ==
NULL )
15229 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
15258 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15260 if(
var->data.aggregate.scalar > 0.0 )
15266 assert(
var->data.aggregate.scalar < 0.0);
15272 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
15276 value = 1.0 - value;
15301 if(
var->data.original.transvar ==
NULL )
15314 if(
var->data.aggregate.scalar > 0.0 )
15348 if(
var->data.original.transvar ==
NULL )
15361 if(
var->data.aggregate.scalar > 0.0 )
15391 if(
var->data.original.transvar ==
NULL )
15403 if(
var->data.aggregate.scalar > 0.0 )
15435 if(
var->data.original.transvar ==
NULL )
15448 if(
var->data.aggregate.scalar > 0.0 )
15488 if(
var->data.original.transvar ==
NULL )
15490 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
15517 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
15521 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15523 if(
var->data.aggregate.scalar > 0.0 )
15529 assert(
var->data.aggregate.scalar < 0.0);
15535 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
15539 value = 1.0 - value;
15572 if(
var->data.original.transvar ==
NULL )
15574 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
15601 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15605 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15607 if(
var->data.aggregate.scalar > 0.0 )
15613 assert(
var->data.aggregate.scalar < 0.0);
15619 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15623 value = 1.0 - value;
15656 if(
var->data.original.transvar ==
NULL )
15658 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15689 value = (value -
var->data.aggregate.constant)/
var->data.aggregate.scalar;
15691 if(
var->data.aggregate.scalar > 0.0 )
15697 assert(
var->data.aggregate.scalar < 0.0);
15703 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15707 value = 1.0 - value;
15730 if(
var->data.original.transvar ==
NULL )
15743 if(
var->data.aggregate.scalar > 0.0 )
15775 if(
var->data.original.transvar ==
NULL )
15788 if(
var->data.aggregate.scalar > 0.0 )
15818 if(
var->data.original.transvar ==
NULL )
15831 if(
var->data.aggregate.scalar > 0.0 )
15863 if(
var->data.original.transvar ==
NULL )
15876 if(
var->data.aggregate.scalar > 0.0 )
15913 if(
var->data.original.transvar ==
NULL )
15927 if(
var->data.aggregate.scalar > 0.0 )
15960 SCIPerrorMessage(
"invalid branching direction %d when asking for VSIDS value\n", dir);
15967 if(
var->data.original.transvar ==
NULL )
15980 if(
var->data.aggregate.scalar > 0.0 )
16010 if(
var->data.original.transvar ==
NULL )
16023 if(
var->data.aggregate.scalar > 0.0 )
16055 if(
var->data.original.transvar ==
NULL )
16068 if(
var->data.aggregate.scalar > 0.0 )
16100 if(
var->data.original.transvar ==
NULL )
16123 if(
var->data.aggregate.scalar > 0.0 )
16157 if(
var->data.original.transvar ==
NULL )
16180 if(
var->data.aggregate.scalar > 0.0 )
16210 if(
var->data.original.transvar ==
NULL )
16223 if(
var->data.aggregate.scalar > 0.0 )
16253 if(
var->data.original.transvar ==
NULL )
16266 if(
var->data.aggregate.scalar > 0.0 )
16298 if(
var->data.original.transvar ==
NULL )
16313 if(
var->data.aggregate.scalar > 0.0 )
16345 if(
var->data.original.transvar ==
NULL )
16360 if(
var->data.aggregate.scalar > 0.0 )
16390 if(
var->data.original.transvar ==
NULL )
16432 if(
var->data.original.transvar !=
NULL )
16474 if(
var->data.original.transvar !=
NULL )
16516 if(
var->data.original.transvar !=
NULL )
16565 (*bdchginfo)->oldbound = oldbound;
16566 (*bdchginfo)->newbound = newbound;
16567 (*bdchginfo)->var =
var;
16568 (*bdchginfo)->inferencedata.var =
var;
16569 (*bdchginfo)->inferencedata.reason.prop =
NULL;
16570 (*bdchginfo)->inferencedata.info = 0;
16571 (*bdchginfo)->bdchgidx.depth = INT_MAX;
16572 (*bdchginfo)->bdchgidx.pos = -1;
16573 (*bdchginfo)->pos = 0;
16575 (*bdchginfo)->boundtype = boundtype;
16576 (*bdchginfo)->inferboundtype = boundtype;
16577 (*bdchginfo)->redundant =
FALSE;
16611 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16618 if(
var->lbchginfos[
i].redundant )
16620 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16624 return &
var->lbchginfos[
i];
16629 for(
i =
var->nlbchginfos-1;
i >= 0; --
i )
16636 if(
var->lbchginfos[
i].redundant )
16638 assert(
var->lbchginfos[
i].oldbound <
var->lbchginfos[
i].newbound);
16642 return &
var->lbchginfos[
i];
16667 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16674 if(
var->ubchginfos[
i].redundant )
16676 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16680 return &
var->ubchginfos[
i];
16685 for(
i =
var->nubchginfos-1;
i >= 0; --
i )
16692 if(
var->ubchginfos[
i].redundant )
16694 assert(
var->ubchginfos[
i].oldbound >
var->ubchginfos[
i].newbound);
16698 return &
var->ubchginfos[
i];
16742 switch( varstatus )
16750 if( bdchgidx ==
NULL )
16757 if( bdchginfo !=
NULL )
16760 return var->glbdom.lb;
16763 return var->glbdom.lb;
16774 if(
var->data.aggregate.scalar > 0.0 )
16780 +
var->data.aggregate.constant;
16782 else if(
var->data.aggregate.scalar < 0.0 )
16788 +
var->data.aggregate.constant;
16799 if (
var->data.multaggr.nvars == 1 )
16805 if(
var->data.multaggr.scalars[0] > 0.0 )
16811 +
var->data.multaggr.constant;
16813 else if(
var->data.multaggr.scalars[0] < 0.0 )
16819 +
var->data.multaggr.constant;
16828 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16861 switch( varstatus )
16869 if( bdchgidx ==
NULL )
16876 if( bdchginfo !=
NULL )
16879 return var->glbdom.ub;
16883 return var->glbdom.ub;
16894 if(
var->data.aggregate.scalar > 0.0 )
16900 +
var->data.aggregate.constant;
16902 else if(
var->data.aggregate.scalar < 0.0 )
16908 +
var->data.aggregate.constant;
16919 if (
var->data.multaggr.nvars == 1 )
16925 if(
var->data.multaggr.scalars[0] > 0.0 )
16931 +
var->data.multaggr.constant;
16933 else if(
var->data.multaggr.scalars[0] < 0.0 )
16939 +
var->data.multaggr.constant;
16948 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
17035 lbchgidx = (
var->nlbchginfos > 0 && !
var->lbchginfos[
var->nlbchginfos-1].redundant
17037 ubchgidx = (
var->nubchginfos > 0 && !
var->ubchginfos[
var->nubchginfos-1].redundant
17059 return bdchgidx->
depth;
17102 return var->ubchginfos[
i].bdchgidx.depth;
17130 return var->lbchginfos[
i].bdchgidx.depth;
17218#undef SCIPboundchgGetNewbound
17219#undef SCIPboundchgGetVar
17220#undef SCIPboundchgGetBoundchgtype
17221#undef SCIPboundchgGetBoundtype
17222#undef SCIPboundchgIsRedundant
17223#undef SCIPdomchgGetNBoundchgs
17224#undef SCIPdomchgGetBoundchg
17225#undef SCIPholelistGetLeft
17226#undef SCIPholelistGetRight
17227#undef SCIPholelistGetNext
17228#undef SCIPvarGetName
17229#undef SCIPvarGetNUses
17230#undef SCIPvarGetData
17231#undef SCIPvarSetData
17232#undef SCIPvarSetDelorigData
17233#undef SCIPvarSetTransData
17234#undef SCIPvarSetDeltransData
17235#undef SCIPvarGetStatus
17236#undef SCIPvarIsOriginal
17237#undef SCIPvarIsTransformed
17238#undef SCIPvarIsNegated
17239#undef SCIPvarGetType
17240#undef SCIPvarIsBinary
17241#undef SCIPvarIsIntegral
17242#undef SCIPvarIsInitial
17243#undef SCIPvarIsRemovable
17244#undef SCIPvarIsDeleted
17245#undef SCIPvarIsDeletable
17246#undef SCIPvarMarkDeletable
17247#undef SCIPvarMarkNotDeletable
17248#undef SCIPvarIsActive
17249#undef SCIPvarGetIndex
17250#undef SCIPvarGetProbindex
17251#undef SCIPvarGetTransVar
17252#undef SCIPvarGetCol
17253#undef SCIPvarIsInLP
17254#undef SCIPvarGetAggrVar
17255#undef SCIPvarGetAggrScalar
17256#undef SCIPvarGetAggrConstant
17257#undef SCIPvarGetMultaggrNVars
17258#undef SCIPvarGetMultaggrVars
17259#undef SCIPvarGetMultaggrScalars
17260#undef SCIPvarGetMultaggrConstant
17261#undef SCIPvarGetNegatedVar
17262#undef SCIPvarGetNegationVar
17263#undef SCIPvarGetNegationConstant
17264#undef SCIPvarGetObj
17265#undef SCIPvarGetLbOriginal
17266#undef SCIPvarGetUbOriginal
17267#undef SCIPvarGetHolelistOriginal
17268#undef SCIPvarGetLbGlobal
17269#undef SCIPvarGetUbGlobal
17270#undef SCIPvarGetHolelistGlobal
17271#undef SCIPvarGetBestBoundGlobal
17272#undef SCIPvarGetWorstBoundGlobal
17273#undef SCIPvarGetLbLocal
17274#undef SCIPvarGetUbLocal
17275#undef SCIPvarGetHolelistLocal
17276#undef SCIPvarGetBestBoundLocal
17277#undef SCIPvarGetWorstBoundLocal
17278#undef SCIPvarGetBestBoundType
17279#undef SCIPvarGetWorstBoundType
17280#undef SCIPvarGetLbLazy
17281#undef SCIPvarGetUbLazy
17282#undef SCIPvarGetBranchFactor
17283#undef SCIPvarGetBranchPriority
17284#undef SCIPvarGetBranchDirection
17285#undef SCIPvarGetNVlbs
17286#undef SCIPvarGetVlbVars
17287#undef SCIPvarGetVlbCoefs
17288#undef SCIPvarGetVlbConstants
17289#undef SCIPvarGetNVubs
17290#undef SCIPvarGetVubVars
17291#undef SCIPvarGetVubCoefs
17292#undef SCIPvarGetVubConstants
17293#undef SCIPvarGetNImpls
17294#undef SCIPvarGetImplVars
17295#undef SCIPvarGetImplTypes
17296#undef SCIPvarGetImplBounds
17297#undef SCIPvarGetImplIds
17298#undef SCIPvarGetNCliques
17299#undef SCIPvarGetCliques
17300#undef SCIPvarGetLPSol
17301#undef SCIPvarGetNLPSol
17302#undef SCIPvarGetBdchgInfoLb
17303#undef SCIPvarGetNBdchgInfosLb
17304#undef SCIPvarGetBdchgInfoUb
17305#undef SCIPvarGetNBdchgInfosUb
17306#undef SCIPvarGetValuehistory
17307#undef SCIPvarGetPseudoSol
17308#undef SCIPvarCatchEvent
17309#undef SCIPvarDropEvent
17310#undef SCIPvarGetVSIDS
17311#undef SCIPvarGetCliqueComponentIdx
17312#undef SCIPvarIsRelaxationOnly
17313#undef SCIPvarMarkRelaxationOnly
17314#undef SCIPbdchgidxGetPos
17315#undef SCIPbdchgidxIsEarlierNonNull
17316#undef SCIPbdchgidxIsEarlier
17317#undef SCIPbdchginfoGetOldbound
17318#undef SCIPbdchginfoGetNewbound
17319#undef SCIPbdchginfoGetVar
17320#undef SCIPbdchginfoGetChgtype
17321#undef SCIPbdchginfoGetBoundtype
17322#undef SCIPbdchginfoGetDepth
17323#undef SCIPbdchginfoGetPos
17324#undef SCIPbdchginfoGetIdx
17325#undef SCIPbdchginfoGetInferVar
17326#undef SCIPbdchginfoGetInferCons
17327#undef SCIPbdchginfoGetInferProp
17328#undef SCIPbdchginfoGetInferInfo
17329#undef SCIPbdchginfoGetInferBoundtype
17330#undef SCIPbdchginfoIsRedundant
17331#undef SCIPbdchginfoHasInferenceReason
17332#undef SCIPbdchginfoIsTighter
17352 return boundchg->
var;
17432 return holelist->
next;
17465 return var->vardata;
17476 var->vardata = vardata;
17488 var->vardelorig = vardelorig;
17500 var->vartrans = vartrans;
17511 var->vardeltrans = vardeltrans;
17522 var->varcopy = varcopy;
17536 var->initial = initial;
17552 var->removable = removable;
17646 return var->initial;
17656 return var->removable;
17666 return var->deleted;
17702 var->delglobalstructs =
TRUE;
17712 return var->delglobalstructs;
17732 return var->relaxationonly;
17764 return var->deletable;
17774 return (
var->probindex >= 0);
17794 return var->probindex;
17805 return var->data.original.transvar;
17816 return var->data.col;
17838 return var->data.aggregate.var;
17850 return var->data.aggregate.scalar;
17862 return var->data.aggregate.constant;
17874 return var->data.multaggr.nvars;
17886 return var->data.multaggr.vars;
17898 return var->data.multaggr.scalars;
17910 return var->data.multaggr.constant;
17920 return var->negatedvar;
17931 return var->negatedvar;
17942 return var->data.negate.constant;
17962 return var->unchangedobj;
17979 while( probvar !=
NULL )
18052 return var->data.original.origdom.lb;
18059 return var->data.negate.constant -
var->negatedvar->data.original.origdom.ub;
18072 return var->data.original.origdom.ub;
18079 return var->data.negate.constant -
var->negatedvar->data.original.origdom.lb;
18092 return var->data.original.origdom.holelist;
18104 return var->glbdom.lb;
18114 return var->glbdom.ub;
18124 return var->glbdom.holelist;
18134 if(
var->obj >= 0.0 )
18135 return var->glbdom.lb;
18137 return var->glbdom.ub;
18147 if(
var->obj >= 0.0 )
18148 return var->glbdom.ub;
18150 return var->glbdom.lb;
18160 return var->locdom.lb;
18170 return var->locdom.ub;
18180 return var->locdom.holelist;
18190 if(
var->obj >= 0.0 )
18191 return var->locdom.lb;
18193 return var->locdom.ub;
18203 if(
var->obj >= 0.0 )
18204 return var->locdom.ub;
18206 return var->locdom.lb;
18216 if(
var->obj >= 0.0 )
18229 if(
var->obj >= 0.0 )
18242 return var->lazylb;
18252 return var->lazyub;
18264 return var->branchfactor;
18276 return var->branchpriority;
18492 return var->nlpsol;
18504 assert(pos < var->nlbchginfos);
18506 return &
var->lbchginfos[pos];
18514 return var->nlbchginfos;
18524 assert(pos < var->nubchginfos);
18526 return &
var->ubchginfos[pos];
18536 return var->nubchginfos;
18546 return var->valuehistory;
18597 eventtype,
var->name, (
void*)eventhdlr, (
void*)eventdata);
18621 SCIPsetDebugMsg(
set,
"drop event of variable <%s> with handler %p and data %p\n",
var->name, (
void*)eventhdlr,
18636 return bdchgidx->
pos;
18652 return (bdchgidx1->
depth < bdchgidx2->
depth)
18653 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18670 if( bdchgidx1 ==
NULL )
18672 else if( bdchgidx2 ==
NULL )
18675 return (bdchgidx1->
depth < bdchgidx2->
depth)
18676 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
18706 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