63 #define MAXIMPLSCLOSURE 100 65 #define MAXABSVBCOEF 1e+5 81 assert(holelist != NULL);
82 assert(blkmem != NULL);
85 SCIPsetDebugMsg(
set,
"create hole list element (%.15g,%.15g) in blkmem %p\n", left, right, (
void*)blkmem);
88 (*holelist)->hole.left = left;
89 (*holelist)->hole.right = right;
90 (*holelist)->next = NULL;
102 assert(holelist != NULL);
103 assert(blkmem != NULL);
105 while( *holelist != NULL )
110 (*holelist)->hole.left, (*holelist)->hole.right, (
void*)blkmem);
112 next = (*holelist)->
next;
114 assert(*holelist == NULL);
118 assert(*holelist == NULL);
130 assert(target != NULL);
132 while( source != NULL )
136 source = source->
next;
137 target = &(*target)->
next;
158 assert(added != NULL);
162 while( *insertpos != NULL && (*insertpos)->
hole.
left < left )
163 insertpos = &(*insertpos)->
next;
166 if( *insertpos != NULL && (*insertpos)->
hole.
left == left && (*insertpos)->hole.right >= right )
168 SCIPsetDebugMsg(
set,
"new hole (%.15g,%.15g) is redundant through known hole (%.15g,%.15g)\n",
169 left, right, (*insertpos)->hole.left, (*insertpos)->hole.right);
179 (*insertpos)->next = next;
213 while( *holelistptr != NULL )
215 if( (*holelistptr)->next != NULL )
217 assert(
SCIPsetIsLE(
set, lastleft, (*holelistptr)->hole.left) );
218 lastleft = (*holelistptr)->hole.left;
221 holelistptr = &(*holelistptr)->
next;
229 lastrightptr = &dom->
lb;
230 lastnextptr = holelistptr;
232 while( *holelistptr != NULL )
234 SCIPsetDebugMsg(
set,
"check hole (%.15g,%.15g) last right interval was <%.15g>\n", (*holelistptr)->hole.left, (*holelistptr)->hole.right, *lastrightptr);
237 assert(
SCIPsetIsLT(
set, (*holelistptr)->hole.left, (*holelistptr)->hole.right));
242 SCIPsetDebugMsg(
set,
"remove remaining hole since upper bound <%.15g> is less then the left hand side of the current hole\n", dom->
ub);
244 assert(*holelistptr == NULL);
249 else if(
SCIPsetIsGT(
set, (*holelistptr)->hole.right, dom->
ub) )
252 SCIPsetDebugMsg(
set,
"upper bound <%.15g> lays in current hole; store new upper bound and remove this and all remaining holes\n", dom->
ub);
254 assert(
SCIPsetIsLT(
set, (*holelistptr)->hole.left, dom->
ub));
257 dom->
ub = (*holelistptr)->hole.left;
260 *newub = (*holelistptr)->hole.left;
264 assert(*holelistptr == NULL);
269 else if(
SCIPsetIsGT(
set, *lastrightptr, (*holelistptr)->hole.left) )
279 SCIPsetDebugMsg(
set,
"lower bound <%.15g> lays in current hole; store new lower bound and remove hole\n", dom->
lb);
280 *lastrightptr =
MAX(*lastrightptr, (*holelistptr)->hole.right);
283 dom->
lb = *lastrightptr;
286 *newlb = *lastrightptr;
290 SCIPsetDebugMsg(
set,
"current hole overlaps with the previous one (...,%.15g); merge to (...,%.15g)\n",
291 *lastrightptr,
MAX(*lastrightptr, (*holelistptr)->hole.right) );
292 *lastrightptr =
MAX(*lastrightptr, (*holelistptr)->hole.right);
294 nextholelist = (*holelistptr)->
next;
295 (*holelistptr)->
next = NULL;
299 *lastnextptr = nextholelist;
302 *holelistptr = nextholelist;
307 lastrightptr = &(*holelistptr)->
hole.
right;
308 lastnextptr = &(*holelistptr)->
next;
311 holelistptr = &(*holelistptr)->
next;
323 while( *holelistptr != NULL )
326 assert(
SCIPsetIsLE(
set, lastright, (*holelistptr)->hole.left) );
329 assert(
SCIPsetIsLT(
set, (*holelistptr)->hole.left, (*holelistptr)->hole.right) );
330 lastright = (*holelistptr)->hole.right;
333 holelistptr = &(*holelistptr)->
next;
367 assert(num <= var->lbchginfossize);
393 assert(num <= var->ubchginfossize);
426 SCIPsetDebugMsg(
set,
"adding lower bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
448 switch( boundchgtype )
453 assert(infercons != NULL);
501 SCIPsetDebugMsg(
set,
"adding upper bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n",
523 switch( boundchgtype )
528 assert(infercons != NULL);
564 assert(boundchg != NULL);
565 assert(stat != NULL);
568 assert(cutoff != NULL);
594 SCIPsetDebugMsg(
set,
" -> branching: new lower bound of <%s>[%g,%g]: %g\n",
605 SCIPsetDebugMsg(
set,
" -> constraint <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
615 SCIPsetDebugMsg(
set,
" -> propagator <%s> inference: new lower bound of <%s>[%g,%g]: %g\n",
635 SCIPsetDebugMsg(
set,
" -> cutoff: new lower bound of <%s>[%g,%g]: %g\n",
644 SCIPsetDebugMsg(
set,
" -> inactive %s: new lower bound of <%s>[%g,%g]: %g\n",
661 SCIPsetDebugMsg(
set,
" -> branching: new upper bound of <%s>[%g,%g]: %g\n",
672 SCIPsetDebugMsg(
set,
" -> constraint <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
682 SCIPsetDebugMsg(
set,
" -> propagator <%s> inference: new upper bound of <%s>[%g,%g]: %g\n",
702 SCIPsetDebugMsg(
set,
" -> cutoff: new upper bound of <%s>[%g,%g]: %g\n",
711 SCIPsetDebugMsg(
set,
" -> inactive %s: new upper bound of <%s>[%g,%g]: %g\n",
726 assert(var == boundchg->
var);
758 assert(boundchg != NULL);
759 assert(stat != NULL);
779 SCIPsetDebugMsg(
set,
"removed lower bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
800 SCIPsetDebugMsg(
set,
"removed upper bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n",
847 assert(boundchg != NULL);
848 assert(cutoff != NULL);
871 SCIPsetDebugMsg(
set,
"applying global bound change: <%s>[%g,%g] %s %g\n",
895 assert(boundchg != NULL);
898 assert(boundchg->
var != NULL);
932 assert(boundchg != NULL);
952 assert(boundchg->
var != NULL);
966 assert(domchg != NULL);
967 assert(blkmem != NULL);
971 (*domchg)->domchgdyn.nboundchgs = 0;
972 (*domchg)->domchgdyn.boundchgs = NULL;
973 (*domchg)->domchgdyn.nholechgs = 0;
974 (*domchg)->domchgdyn.holechgs = NULL;
975 (*domchg)->domchgdyn.boundchgssize = 0;
976 (*domchg)->domchgdyn.holechgssize = 0;
990 assert(domchg != NULL);
991 assert(blkmem != NULL);
993 if( *domchg != NULL )
998 for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
1004 switch( (*domchg)->domchgdyn.domchgtype )
1036 assert(domchg != NULL);
1037 assert(blkmem != NULL);
1039 SCIPdebugMessage(
"making domain change data %p pointing to %p dynamic\n", (
void*)domchg, (
void*)*domchg);
1041 if( *domchg == NULL )
1047 switch( (*domchg)->domchgdyn.domchgtype )
1051 (*domchg)->domchgdyn.nholechgs = 0;
1052 (*domchg)->domchgdyn.holechgs = NULL;
1053 (*domchg)->domchgdyn.boundchgssize = (*domchg)->domchgdyn.nboundchgs;
1054 (*domchg)->domchgdyn.holechgssize = 0;
1059 (*domchg)->domchgdyn.boundchgssize = (*domchg)->domchgdyn.nboundchgs;
1060 (*domchg)->domchgdyn.holechgssize = (*domchg)->domchgdyn.nholechgs;
1073 for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
1075 ||
EPSISINT((*domchg)->domchgbound.boundchgs[i].newbound, 1e-06));
1091 assert(domchg != NULL);
1092 assert(blkmem != NULL);
1094 SCIPsetDebugMsg(
set,
"making domain change data %p pointing to %p static\n", (
void*)domchg, (
void*)*domchg);
1096 if( *domchg != NULL )
1098 switch( (*domchg)->domchgdyn.domchgtype )
1101 if( (*domchg)->domchgbound.nboundchgs == 0 )
1107 if( (*domchg)->domchgboth.nholechgs == 0 )
1109 if( (*domchg)->domchgbound.nboundchgs == 0 )
1121 if( (*domchg)->domchgboth.nholechgs == 0 )
1123 if( (*domchg)->domchgbound.nboundchgs == 0 )
1131 (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );
1143 (*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );
1145 (*domchg)->domchgdyn.holechgssize, (*domchg)->domchgdyn.nholechgs) );
1157 if( *domchg != NULL )
1160 for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
1179 assert(domchg != NULL);
1190 assert(num <= domchg->domchgdyn.boundchgssize);
1204 assert(domchg != NULL);
1215 assert(num <= domchg->domchgdyn.holechgssize);
1235 assert(cutoff != NULL);
1239 SCIPsetDebugMsg(
set,
"applying domain changes at %p in depth %d\n", (
void*)domchg, depth);
1241 if( domchg == NULL )
1248 branchcand, eventqueue, depth, i, cutoff) );
1282 SCIPsetDebugMsg(
set,
"undoing domain changes at %p\n", (
void*)domchg);
1283 if( domchg == NULL )
1319 assert(cutoff != NULL);
1323 if( domchg == NULL )
1326 SCIPsetDebugMsg(
set,
"applying domain changes at %p to the global problem\n", (
void*)domchg);
1332 branchcand, eventqueue, cliquetable, cutoff) );
1362 assert(domchg != NULL);
1363 assert(var != NULL);
1371 SCIPsetDebugMsg(
set,
"adding %s bound change <%s: %g> of variable <%s> to domain change at %p pointing to %p\n",
1373 newbound, var->
name, (
void*)domchg, (
void*)*domchg);
1378 if( *domchg == NULL )
1392 boundchg = &(*domchg)->domchgdyn.boundchgs[(*domchg)->domchgdyn.nboundchgs];
1393 boundchg->
var = var;
1394 switch( boundchgtype )
1400 assert(infercons != NULL);
1421 (*domchg)->domchgdyn.nboundchgs++;
1426 #ifdef SCIP_DISABLED_CODE 1427 #ifdef SCIP_MORE_DEBUG 1430 for( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )
1452 assert(domchg != NULL);
1453 assert(ptr != NULL);
1458 if( *domchg == NULL )
1472 holechg = &(*domchg)->domchgdyn.holechgs[(*domchg)->domchgdyn.nholechgs];
1476 (*domchg)->domchgdyn.nholechgs++;
1544 assert(var != NULL);
1551 SCIPsetDebugMsg(
set,
"removing %s implications and vbounds of %s<%s>[%g,%g]\n",
1552 onlyredundant ?
"redundant" :
"all", irrelevantvar ?
"irrelevant " :
"",
SCIPvarGetName(var), lb, ub);
1555 if( var->
implics != NULL && (!onlyredundant || lb > 0.5 || ub < 0.5) )
1573 for( i = 0; i < nimpls; i++ )
1578 implvar = implvars[i];
1579 impltype = impltypes[i];
1580 assert(implvar != var);
1589 if( implvar->
vubs != NULL )
1591 SCIPsetDebugMsg(
set,
"deleting variable bound: <%s> == %u ==> <%s> <= %g\n",
1601 if( implvar->
vlbs != NULL )
1603 SCIPsetDebugMsg(
set,
"deleting variable bound: <%s> == %u ==> <%s> >= %g\n",
1612 varfixing = !varfixing;
1614 while( varfixing ==
TRUE );
1624 if( var->
vlbs != NULL )
1643 for( i = 0; i < nvbds; i++ )
1648 assert(newnvbds <= i);
1651 assert(implvar != NULL);
1669 vars[newnvbds] = implvar;
1670 coefs[newnvbds] = coef;
1671 constants[newnvbds] = constants[i];
1680 if( implvar->
implics != NULL )
1682 SCIPsetDebugMsg(
set,
"deleting implication: <%s> == %d ==> <%s> >= %g\n",
1686 if( coef > 0.0 && implvar->
vubs != NULL )
1688 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1694 else if( coef < 0.0 && implvar->vlbs != NULL )
1696 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1718 if( var->
vubs != NULL )
1737 for( i = 0; i < nvbds; i++ )
1742 assert(newnvbds <= i);
1745 assert(implvar != NULL);
1763 vars[newnvbds] = implvar;
1764 coefs[newnvbds] = coefs[i];
1765 constants[newnvbds] = constants[i];
1774 if( implvar->
implics != NULL )
1776 SCIPsetDebugMsg(
set,
"deleting implication: <%s> == %d ==> <%s> <= %g\n",
1780 if( coef < 0.0 && implvar->vubs != NULL )
1782 SCIPsetDebugMsg(
set,
"deleting variable upper bound from <%s> involving variable %s\n",
1788 else if( coef > 0.0 && implvar->
vlbs != NULL )
1790 SCIPsetDebugMsg(
set,
"deleting variable lower bound from <%s> involving variable %s\n",
1829 assert(blkmem != NULL);
1830 assert(var != NULL);
1836 assert(stat != NULL);
1873 assert(var != NULL);
1874 assert(blkmem != NULL);
1875 assert(stat != NULL);
1892 SCIPerrorMessage(
"invalid bounds [%.2g,%.2g] for binary variable <%s>\n", lb, ub, name);
1906 (*var)->scip =
set->scip;
1909 (*var)->unchangedobj = obj;
1910 (*var)->branchfactor = 1.0;
1911 (*var)->rootsol = 0.0;
1912 (*var)->bestrootsol = 0.0;
1913 (*var)->bestrootredcost = 0.0;
1915 (*var)->relaxsol = 0.0;
1916 (*var)->nlpsol = 0.0;
1917 (*var)->primsolavg = 0.5 * (lb + ub);
1920 (*var)->conflictrelaxedlb = (*var)->conflictlb;
1921 (*var)->conflictrelaxedub = (*var)->conflictub;
1924 (*var)->glbdom.holelist = NULL;
1925 (*var)->glbdom.lb = lb;
1926 (*var)->glbdom.ub = ub;
1927 (*var)->locdom.holelist = NULL;
1928 (*var)->locdom.lb = lb;
1929 (*var)->locdom.ub = ub;
1930 (*var)->varcopy = varcopy;
1931 (*var)->vardelorig = vardelorig;
1932 (*var)->vartrans = vartrans;
1933 (*var)->vardeltrans = vardeltrans;
1934 (*var)->vardata = vardata;
1935 (*var)->parentvars = NULL;
1936 (*var)->negatedvar = NULL;
1937 (*var)->vlbs = NULL;
1938 (*var)->vubs = NULL;
1939 (*var)->implics = NULL;
1940 (*var)->cliquelist = NULL;
1941 (*var)->eventfilter = NULL;
1942 (*var)->lbchginfos = NULL;
1943 (*var)->ubchginfos = NULL;
1944 (*var)->index = stat->
nvaridx;
1945 (*var)->probindex = -1;
1946 (*var)->pseudocandindex = -1;
1947 (*var)->eventqueueindexobj = -1;
1948 (*var)->eventqueueindexlb = -1;
1949 (*var)->eventqueueindexub = -1;
1950 (*var)->parentvarssize = 0;
1951 (*var)->nparentvars = 0;
1953 (*var)->nlocksdown = 0;
1954 (*var)->nlocksup = 0;
1955 (*var)->branchpriority = 0;
1957 (*var)->lbchginfossize = 0;
1958 (*var)->nlbchginfos = 0;
1959 (*var)->ubchginfossize = 0;
1960 (*var)->nubchginfos = 0;
1961 (*var)->conflictlbcount = 0;
1962 (*var)->conflictubcount = 0;
1963 (*var)->closestvlbidx = -1;
1964 (*var)->closestvubidx = -1;
1965 (*var)->closestvblpcount = -1;
1966 (*var)->initial = initial;
1967 (*var)->removable = removable;
1968 (*var)->deleted =
FALSE;
1969 (*var)->donotmultaggr =
FALSE;
1970 (*var)->vartype = vartype;
1971 (*var)->pseudocostflag =
FALSE;
1972 (*var)->eventqueueimpl =
FALSE;
1973 (*var)->deletable =
FALSE;
1974 (*var)->delglobalstructs =
FALSE;
1983 (*var)->valuehistory = NULL;
2010 assert(var != NULL);
2011 assert(blkmem != NULL);
2012 assert(stat != NULL);
2015 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2016 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2020 (*var)->data.original.origdom.holelist = NULL;
2021 (*var)->data.original.origdom.lb = lb;
2022 (*var)->data.original.origdom.ub = ub;
2023 (*var)->data.original.transvar = NULL;
2053 assert(var != NULL);
2054 assert(blkmem != NULL);
2057 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2058 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2095 assert(
set != NULL);
2096 assert(blkmem != NULL);
2097 assert(stat != NULL);
2098 assert(sourcescip != NULL);
2099 assert(sourcevar != NULL);
2100 assert(var != NULL);
2102 assert(varmap != NULL);
2103 assert(consmap != NULL);
2127 NULL, NULL, NULL, NULL, NULL) );
2128 assert(*var != NULL);
2138 if( sourcevar->
vardata != NULL && sourcevar->varcopy != NULL )
2140 SCIP_CALL( sourcevar->varcopy(set->scip, sourcescip, sourcevar, sourcevar->
vardata,
2141 varmap, consmap, (*var), &targetdata, &result) );
2146 SCIPerrorMessage(
"variable data copying method returned invalid result <%d>\n", result);
2155 (*var)->varcopy = sourcevar->varcopy;
2156 (*var)->vardelorig = sourcevar->vardelorig;
2157 (*var)->vartrans = sourcevar->vartrans;
2158 (*var)->vardeltrans = sourcevar->vardeltrans;
2164 if( set->history_allowtransfer )
2174 (*var)->varcopy = sourcevar->varcopy;
2175 (*var)->vardelorig = sourcevar->vardelorig;
2176 (*var)->vartrans = sourcevar->vartrans;
2177 (*var)->vardeltrans = sourcevar->vardeltrans;
2196 if( strncmp(str,
"+inf", 4) == 0 )
2199 (*endptr) = (
char*)str + 4;
2201 else if( strncmp(str,
"-inf", 4) == 0 )
2204 (*endptr) = (
char*)str + 4;
2233 if ( strncmp(type,
"original", 8) != 0 && strncmp(type,
"global", 6) != 0 && strncmp(type,
"local", 5) != 0 && strncmp(type,
"lazy", 4) != 0 )
2253 while ( **endptr !=
'\0' && (**endptr ==
']' || **endptr ==
',') )
2285 assert(obj != NULL);
2286 assert(vartype != NULL);
2287 assert(lazylb != NULL);
2288 assert(lazyub != NULL);
2289 assert(success != NULL);
2295 assert(str != *endptr);
2299 if( strncmp(token,
"binary", 3) == 0 )
2301 else if( strncmp(token,
"integer", 3) == 0 )
2303 else if( strncmp(token,
"implicit", 3) == 0 )
2305 else if( strncmp(token,
"continuous", 3) == 0 )
2319 assert(endptr != NULL);
2342 assert(strncmp(token,
"global", 6) == 0 || strncmp(token,
"original", 8) == 0);
2352 for( i = 0; i < 2 && *endptr != NULL && **endptr !=
'\0'; ++i )
2361 if( *endptr == NULL )
2364 if( strncmp(token,
"local", 5) == 0 && local )
2369 else if( strncmp(token,
"lazy", 4) == 0 )
2377 if ( *endptr == NULL )
2385 SCIPerrorMessage(
"Parsed invalid bounds for binary variable <%s>: [%f, %f].\n", name, *lb, *ub);
2391 SCIPerrorMessage(
"Parsed invalid lazy bounds for binary variable <%s>: [%f, %f].\n", name, *lazylb, *lazyub);
2429 assert(var != NULL);
2430 assert(blkmem != NULL);
2431 assert(stat != NULL);
2432 assert(endptr != NULL);
2433 assert(success != NULL);
2436 SCIP_CALL(
varParse(
set, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub,
FALSE, endptr, success) );
2441 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2442 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2446 (*var)->data.original.origdom.holelist = NULL;
2447 (*var)->data.original.origdom.lb = lb;
2448 (*var)->data.original.origdom.ub = ub;
2449 (*var)->data.original.transvar = NULL;
2452 (*var)->lazylb = lazylb;
2453 (*var)->lazyub = lazyub;
2493 assert(var != NULL);
2494 assert(blkmem != NULL);
2495 assert(endptr != NULL);
2496 assert(success != NULL);
2499 SCIP_CALL(
varParse(
set, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub,
TRUE, endptr, success) );
2504 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2505 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2514 (*var)->lazylb = lazylb;
2515 (*var)->lazyub = lazyub;
2543 assert(num <= var->parentvarssize);
2557 assert(var != NULL);
2558 assert(parentvar != NULL);
2563 SCIPsetDebugMsg(
set,
"adding parent <%s>[%p] to variable <%s>[%p] in slot %d\n",
2568 var->parentvars[var->nparentvars] = parentvar;
2592 for( i = 0; i < (*var)->nparentvars; ++i )
2594 assert((*var)->parentvars != NULL);
2596 assert(parentvar != NULL);
2618 assert(v < parentvar->data.multaggr.nvars && parentvar->
data.
multaggr.
vars[v] == *var);
2619 if( v < parentvar->data.multaggr.nvars-1 )
2630 assert((*var)->negatedvar == parentvar);
2636 SCIPerrorMessage(
"parent variable is neither ORIGINAL, AGGREGATED nor NEGATED\n");
2659 assert(var != NULL);
2660 assert(*var != NULL);
2662 assert((*var)->nuses == 0);
2663 assert((*var)->probindex == -1);
2670 assert((*var)->data.original.transvar == NULL);
2671 holelistFree(&(*var)->data.original.origdom.holelist, blkmem);
2672 assert((*var)->data.original.origdom.holelist == NULL);
2699 if( (*var)->vardelorig != NULL )
2706 if( (*var)->vardeltrans != NULL )
2713 if( (*var)->eventfilter != NULL )
2717 assert((*var)->eventfilter == NULL);
2722 assert((*var)->glbdom.holelist == NULL);
2723 assert((*var)->locdom.holelist == NULL);
2756 assert(var != NULL);
2757 assert(var->
nuses >= 0);
2772 assert(var != NULL);
2773 assert(*var != NULL);
2774 assert((*var)->nuses >= 1);
2775 assert(blkmem != NULL);
2776 assert((*var)->scip == set->scip);
2778 SCIPsetDebugMsg(
set,
"release variable <%s> with nuses=%d\n", (*var)->name, (*var)->nuses);
2780 if( (*var)->nuses == 0 )
2797 assert(name != NULL);
2813 assert(var != NULL);
2831 assert(
set != NULL);
2861 if( holelist == NULL )
2871 while(holelist != NULL )
2897 assert(var != NULL);
2898 assert(var->
scip == set->scip);
2933 printBounds(
set, messagehdlr, file, lb, ub,
"original bounds");
2941 printBounds(
set, messagehdlr, file, lb, ub,
"lazy bounds");
2944 printHolelist(
set, messagehdlr, file, holelist,
"original holes");
2951 printBounds(
set, messagehdlr, file, lb, ub,
"global bounds");
2956 printBounds(
set, messagehdlr, file, lb, ub,
"local bounds");
2964 printBounds(
set, messagehdlr, file, lb, ub,
"lazy bounds");
2968 printHolelist(
set, messagehdlr, file, holelist,
"global holes");
2972 printHolelist(
set, messagehdlr, file, holelist,
"local holes");
3034 assert(var != NULL);
3036 assert(var->
scip == set->scip);
3057 assert(var != NULL);
3060 assert(var->
scip == set->scip);
3062 if( addnlocksdown == 0 && addnlocksup == 0 )
3065 SCIPsetDebugMsg(
set,
"add rounding locks %d/%d to variable <%s> (locks=%d/%d)\n",
3072 assert(lockvar != NULL);
3110 int tmp = addnlocksup;
3112 addnlocksup = addnlocksdown;
3113 addnlocksdown = tmp;
3141 int tmp = addnlocksup;
3147 addnlocksup = addnlocksdown;
3148 addnlocksdown = tmp;
3168 assert(var != NULL);
3223 assert(var != NULL);
3300 assert(origvar != NULL);
3301 assert(origvar->
scip == set->scip);
3305 assert(origvar->
vlbs == NULL);
3306 assert(origvar->
vubs == NULL);
3307 assert(transvar != NULL);
3322 origvar->vardelorig, origvar->vartrans, origvar->vardeltrans, origvar->varcopy, NULL) );
3338 (*transvar)->nlocksdown = origvar->
nlocksdown;
3339 (*transvar)->nlocksup = origvar->
nlocksup;
3340 assert((*transvar)->nlocksdown >= 0);
3341 assert((*transvar)->nlocksup >= 0);
3347 (*transvar)->lazylb = origvar->
lazylb;
3348 (*transvar)->lazyub = origvar->
lazyub;
3356 if( origvar->vartrans != NULL )
3361 (*transvar)->vardata = origvar->
vardata;
3364 SCIPsetDebugMsg(
set,
"transformed variable: <%s>[%p] -> <%s>[%p]\n", origvar->
name, (
void*)origvar, (*transvar)->
name, (
void*)*transvar);
3378 assert(origvar != NULL);
3380 assert(origvar->
scip == set->scip);
3410 assert(var != NULL);
3412 assert(var->
scip == set->scip);
3444 assert(var != NULL);
3446 assert(var->
scip == set->scip);
3447 assert(var->
data.
col != NULL);
3490 assert(var != NULL);
3491 assert(var->
scip == set->scip);
3492 assert(0 <= fixeventtype && fixeventtype <= 2);
3505 switch( fixeventtype )
3593 assert(var != NULL);
3594 assert(var->
scip == set->scip);
3597 assert(infeasible != NULL);
3598 assert(fixed != NULL);
3602 *infeasible =
FALSE;
3608 SCIPsetDebugMsg(
set,
" -> variable already fixed to %g (fixedval=%g): infeasible=%u\n", var->
locdom.
lb, fixedval, *infeasible);
3629 lp, branchcand, eventqueue, cliquetable, fixedval, infeasible, fixed) );
3660 assert(var->
vlbs == NULL);
3661 assert(var->
vubs == NULL);
3679 SCIP_CALL(
SCIPvarAddObj(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventqueue, obj) );
3704 SCIP_CALL(
SCIPvarFix(var->
data.
aggregate.
var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3705 branchcand, eventqueue, cliquetable, childfixedval, infeasible, fixed) );
3719 SCIP_CALL(
SCIPvarFix(var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
3720 branchcand, eventqueue, cliquetable, var->
data.
negate.
constant - fixedval, infeasible, fixed) );
3785 assert(
set != NULL);
3786 assert(nvars != NULL);
3787 assert(scalars != NULL || *nvars == 0);
3788 assert(constant != NULL);
3789 assert(requiredsize != NULL);
3790 assert(*nvars <= varssize);
3797 assert(vars != NULL);
3808 activeconstant = 0.0;
3809 activeconstantinf =
FALSE;
3810 activevarssize = (*nvars) * 2;
3812 tmpvarssize = *nvars;
3827 for( v = ntmpvars - 1; v >= 0; --v )
3830 scalar = tmpscalars[v];
3832 assert(var != NULL);
3838 assert(var != NULL);
3851 tmpscalars[v] = scalar;
3853 noldtmpvars = ntmpvars;
3856 SCIPsortPtrReal((
void**)tmpvars, tmpscalars, SCIPvarComp, noldtmpvars);
3858 for( v = 1; v < noldtmpvars; ++v )
3863 tmpscalars[ntmpvars] += tmpscalars[v];
3870 tmpscalars[ntmpvars] = tmpscalars[v];
3871 tmpvars[ntmpvars] = tmpvars[v];
3877 #ifdef SCIP_MORE_DEBUG 3878 for( v = 1; v < ntmpvars; ++v )
3884 while( ntmpvars >= 1 )
3888 var = tmpvars[ntmpvars];
3889 scalar = tmpscalars[ntmpvars];
3891 assert(var != NULL);
3907 if( nactivevars >= activevarssize )
3909 activevarssize *= 2;
3912 assert(nactivevars < activevarssize);
3914 activevars[nactivevars] = var;
3915 activescalars[nactivevars] = scalar;
3926 if( nmultvars + ntmpvars > tmpvarssize )
3928 while( nmultvars + ntmpvars > tmpvarssize )
3932 assert(nmultvars + ntmpvars <= tmpvarssize);
3935 if( nmultvars > tmpvarssize2 )
3937 while( nmultvars > tmpvarssize2 )
3941 assert(nmultvars <= tmpvarssize2);
3946 for( ; nmultvars >= 0; --nmultvars )
3948 multvar = multvars[nmultvars];
3949 multscalar = multscalars[nmultvars];
3952 assert(multvar != NULL);
3954 assert(multvar != NULL);
3961 if( !activeconstantinf )
3967 assert(scalar != 0.0);
3968 if( scalar * multconstant > 0.0 )
3971 activeconstantinf =
TRUE;
3976 activeconstantinf =
TRUE;
3980 activeconstant += scalar * multconstant;
3985 assert(!
SCIPsetIsInfinity(
set, activeconstant) || !(scalar * multconstant < 0.0 &&
3987 assert(!
SCIPsetIsInfinity(
set, -activeconstant) || !(scalar * multconstant > 0.0 &&
3995 tmpscalars[pos] += scalar * multscalar;
3999 tmpvars2[ntmpvars2] = multvar;
4000 tmpscalars2[ntmpvars2] = scalar * multscalar;
4002 assert(ntmpvars2 <= tmpvarssize2);
4009 SCIPsortPtrReal((
void**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);
4011 for( v = 1; v < ntmpvars2; ++v )
4016 tmpscalars2[pos] += tmpscalars2[v];
4023 tmpscalars2[pos] = tmpscalars2[v];
4024 tmpvars2[pos] = tmpvars2[v];
4028 ntmpvars2 = pos + 1;
4029 #ifdef SCIP_MORE_DEBUG 4030 for( v = 1; v < ntmpvars2; ++v )
4034 for( v = 1; v < ntmpvars; ++v )
4041 pos = ntmpvars + ntmpvars2 - 1;
4042 ntmpvars += ntmpvars2;
4044 while( v >= 0 && k >= 0 )
4050 tmpvars[pos] = tmpvars[v];
4051 tmpscalars[pos] = tmpscalars[v];
4056 tmpvars[pos] = tmpvars2[k];
4057 tmpscalars[pos] = tmpscalars2[k];
4066 tmpvars[pos] = tmpvars[v];
4067 tmpscalars[pos] = tmpscalars[v];
4074 tmpvars[pos] = tmpvars2[k];
4075 tmpscalars[pos] = tmpscalars2[k];
4080 #ifdef SCIP_MORE_DEBUG 4081 for( v = 1; v < ntmpvars; ++v )
4087 if( !activeconstantinf )
4095 assert(scalar != 0.0);
4096 if( scalar * multconstant > 0.0 )
4099 activeconstantinf =
TRUE;
4104 activeconstantinf =
TRUE;
4108 activeconstant += scalar * multconstant;
4114 assert(!
SCIPsetIsInfinity(
set, activeconstant) || !(scalar * multconstant < 0.0 &&
4116 assert(!
SCIPsetIsInfinity(
set, -activeconstant) || !(scalar * multconstant > 0.0 &&
4135 if( mergemultiples )
4140 SCIPsortPtrReal((
void**)activevars, activescalars, SCIPvarComp, nactivevars);
4143 v = nactivevars - 1;
4149 if( activescalars[v - 1] + activescalars[v] != 0.0 )
4151 activescalars[v - 1] += activescalars[v];
4153 activevars[v] = activevars[nactivevars];
4154 activescalars[v] = activescalars[nactivevars];
4159 activevars[v] = activevars[nactivevars];
4160 activescalars[v] = activescalars[nactivevars];
4163 activevars[v] = activevars[nactivevars];
4164 activescalars[v] = activescalars[nactivevars];
4178 for( v = 0; v < nactivevars / 2; ++v )
4180 tmpvar = activevars[v];
4181 tmpscalar = activescalars[v];
4182 activevars[v] = activevars[nactivevars - 1 - v];
4183 activescalars[v] = activescalars[nactivevars - 1 - v];
4184 activevars[nactivevars - 1 - v] = tmpvar;
4185 activescalars[nactivevars - 1 - v] = tmpscalar;
4189 *requiredsize = nactivevars;
4191 if( varssize >= *requiredsize )
4193 assert(vars != NULL);
4195 *nvars = *requiredsize;
4200 if( activeconstantinf )
4201 (*constant) = activeconstant;
4203 (*constant) += activeconstant;
4214 for( v = 0; v < *nvars; ++v )
4216 vars[v] = activevars[v];
4217 scalars[v] = activescalars[v];
4245 int multrequiredsize;
4247 assert( var != NULL );
4249 assert(var->
scip == set->scip);
4257 if( multrequiredsize > multvarssize )
4261 multvarssize = multrequiredsize;
4263 assert( multrequiredsize <= multvarssize );
4352 assert(var != NULL);
4353 assert(var->
scip == set->scip);
4354 assert(aggvar != NULL);
4356 assert(infeasible != NULL);
4357 assert(fixed != NULL);
4359 *infeasible =
FALSE;
4362 SCIPsetDebugMsg(
set,
"updating bounds of variables in aggregation <%s> == %g*<%s> %+g\n", var->
name, scalar, aggvar->
name, constant);
4369 aggvarbdschanged =
FALSE;
4377 varlb = aggvar->
glbdom.
lb * scalar + constant;
4381 varub = aggvar->
glbdom.
ub * scalar + constant;
4388 varub = aggvar->
glbdom.
lb * scalar + constant;
4392 varlb = aggvar->
glbdom.
ub * scalar + constant;
4395 varub = MIN(varub, var->
glbdom.
ub);
4409 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4410 eventqueue, cliquetable, varlb, infeasible, fixed) );
4411 if( !(*infeasible) )
4415 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4416 eventqueue, cliquetable, (varlb-constant)/scalar, infeasible, &aggfixed) );
4417 assert(*fixed == aggfixed);
4442 aggvarlb = (var->
glbdom.
lb - constant) / scalar;
4446 aggvarub = (var->
glbdom.
ub - constant) / scalar;
4453 aggvarub = (var->
glbdom.
lb - constant) / scalar;
4457 aggvarlb = (var->
glbdom.
ub - constant) / scalar;
4460 aggvarub = MIN(aggvarub, aggvar->
glbdom.
ub);
4474 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4475 eventqueue, cliquetable, aggvarlb, infeasible, fixed) );
4476 if( !(*infeasible) )
4480 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4481 eventqueue, cliquetable, aggvarlb * scalar + constant, infeasible, &varfixed) );
4482 assert(*fixed == varfixed);
4506 while( aggvarbdschanged );
4549 assert(var != NULL);
4550 assert(aggvar != NULL);
4551 assert(var->
scip == set->scip);
4556 assert(infeasible != NULL);
4557 assert(aggregated != NULL);
4559 *infeasible =
FALSE;
4560 *aggregated =
FALSE;
4568 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4569 cliquetable, constant, infeasible, aggregated) );
4597 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4598 eventqueue, cliquetable, constant/(1.0-scalar), infeasible, aggregated) );
4604 SCIP_CALL(
varUpdateAggregationBounds(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
4605 branchcand, eventqueue, cliquetable, aggvar, scalar, constant, infeasible, &fixed) );
4606 if( *infeasible || fixed )
4608 *aggregated = fixed;
4672 if( var->
vlbs != NULL )
4678 for( i = 0; i < nvbds && !(*infeasible); ++i )
4680 SCIP_CALL(
SCIPvarAddVlb(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4681 eventqueue, vars[i], coefs[i], constants[i],
FALSE, infeasible, NULL) );
4684 if( var->
vubs != NULL )
4690 for( i = 0; i < nvbds && !(*infeasible); ++i )
4692 SCIP_CALL(
SCIPvarAddVub(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4693 eventqueue, vars[i], coefs[i], constants[i],
FALSE, infeasible, NULL) );
4706 for( i = 0; i < 2; ++i )
4718 for( j = 0; j < nimpls && !(*infeasible); ++j )
4723 SCIP_CALL(
SCIPvarAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
4724 branchcand, eventqueue, (
SCIP_Bool)i, implvars[j], impltypes[j], implbounds[j],
FALSE, infeasible,
4790 SCIP_CALL(
SCIPvarAddObj(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventqueue, obj) );
4848 #define MAXDNOM 1000000LL 4850 assert(
set != NULL);
4851 assert(blkmem != NULL);
4852 assert(stat != NULL);
4853 assert(transprob != NULL);
4854 assert(origprob != NULL);
4855 assert(tree != NULL);
4857 assert(cliquetable != NULL);
4858 assert(branchcand != NULL);
4859 assert(eventqueue != NULL);
4860 assert(varx != NULL);
4861 assert(vary != NULL);
4862 assert(varx != vary);
4863 assert(infeasible != NULL);
4864 assert(aggregated != NULL);
4873 *infeasible =
FALSE;
4874 *aggregated =
FALSE;
4882 assert(scalarxd >= 1);
4883 assert(scalaryd >= 1);
4887 a = (scm/scalarxd)*scalarxn;
4888 b = (scm/scalaryd)*scalaryn;
4915 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4916 branchcand, eventqueue, vary, (
SCIP_Real)(-b/a), (
SCIP_Real)(c/a), infeasible, aggregated) );
4917 assert(*aggregated);
4924 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4925 branchcand, eventqueue, varx, (
SCIP_Real)(-a/b), (
SCIP_Real)(c/b), infeasible, aggregated) );
4926 assert(*aggregated);
4957 if( currentclass < 0 )
4959 assert(0 <= currentclass && currentclass < a);
4965 assert(0 <= classstep && classstep < a);
4967 while( currentclass != 0 )
4969 assert(0 <= currentclass && currentclass < a);
4970 currentclass += classstep;
4971 if( currentclass >= a )
4976 assert(((c - b*ysol)%a) == 0);
4978 xsol = (c - b*ysol)/a;
4999 NULL, NULL, NULL, NULL, NULL) );
5003 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5004 branchcand, eventqueue, aggvar, (
SCIP_Real)(-b), (
SCIP_Real)xsol, infeasible, aggregated) );
5005 assert(*aggregated || *infeasible);
5007 if( !(*infeasible) )
5009 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5010 branchcand, eventqueue, aggvar, (
SCIP_Real)a, (
SCIP_Real)ysol, infeasible, aggregated) );
5011 assert(*aggregated || *infeasible);
5060 assert(
set != NULL);
5061 assert(blkmem != NULL);
5062 assert(stat != NULL);
5063 assert(transprob != NULL);
5064 assert(origprob != NULL);
5065 assert(tree != NULL);
5067 assert(cliquetable != NULL);
5068 assert(branchcand != NULL);
5069 assert(eventqueue != NULL);
5070 assert(varx != NULL);
5071 assert(vary != NULL);
5072 assert(varx != vary);
5073 assert(infeasible != NULL);
5074 assert(aggregated != NULL);
5081 *infeasible =
FALSE;
5082 *aggregated =
FALSE;
5084 absquot =
REALABS(scalarx / scalary);
5086 maxscalar =
MAX(maxscalar, 1.0);
5088 if( absquot > maxscalar || absquot < 1 / maxscalar )
5162 scalar = -scalary/scalarx;
5163 constant = rhs/scalarx;
5183 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5184 branchcand, eventqueue, vary, scalar, constant, infeasible, aggregated) );
5185 assert(*aggregated || *infeasible);
5191 SCIP_CALL(
tryAggregateIntVars(
set, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5192 branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );
5235 int tmprequiredsize;
5237 assert(var != NULL);
5238 assert(var->
scip == set->scip);
5241 assert(naggvars == 0 || aggvars != NULL);
5242 assert(naggvars == 0 ||
scalars != NULL);
5243 assert(infeasible != NULL);
5244 assert(aggregated != NULL);
5246 SCIPsetDebugMsg(
set,
"trying multi-aggregating variable <%s> == ...%d vars... %+g\n", var->
name, naggvars, constant);
5248 *infeasible =
FALSE;
5249 *aggregated =
FALSE;
5256 SCIPerrorMessage(
"cannot multi-aggregate an untransformed original variable\n");
5260 reopt, lp, cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars, constant, infeasible, aggregated) );
5267 ntmpvars = naggvars;
5268 tmpvarssize = naggvars;
5269 tmpconstant = constant;
5275 if( tmprequiredsize > tmpvarssize )
5279 tmpvarssize = tmprequiredsize;
5281 assert( tmprequiredsize <= tmpvarssize );
5289 for( v = ntmpvars - 1; v >= 0; --v )
5291 assert(tmpvars[v] != NULL);
5294 if( tmpvars[v]->index == var->
index )
5296 tmpscalar += tmpscalars[v];
5297 tmpvars[v] = tmpvars[ntmpvars - 1];
5298 tmpscalars[v] = tmpscalars[ntmpvars - 1];
5310 SCIPsetDebugMsg(
set,
"Possible multi-aggregation was completely resolved and detected to be redundant.\n");
5315 SCIPsetDebugMsg(
set,
"Multi-aggregation was completely resolved and led to infeasibility.\n");
5320 else if( ntmpvars == 1 )
5322 assert(tmpscalars[0] != 0.0);
5323 assert(tmpvars[0] != NULL);
5325 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to fixing of variable <%s> to %g.\n",
SCIPvarGetName(tmpvars[0]), -constant/tmpscalars[0]);
5326 SCIP_CALL(
SCIPvarFix(tmpvars[0], blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5327 branchcand, eventqueue, cliquetable, -constant/tmpscalars[0], infeasible, aggregated) );
5330 else if( ntmpvars == 2 )
5334 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5338 cliquetable, branchcand, eventfilter, eventqueue, tmpvars[0], tmpvars[1], tmpscalars[0],
5339 tmpscalars[1], -tmpconstant, infeasible, aggregated) );
5352 tmpscalar = 1 - tmpscalar;
5353 tmpconstant /= tmpscalar;
5354 for( v = ntmpvars - 1; v >= 0; --v )
5355 tmpscalars[v] /= tmpscalar;
5362 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
5363 eventqueue, cliquetable, tmpconstant, infeasible, aggregated) );
5370 SCIPsetDebugMsg(
set,
"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n",
5374 cliquetable, branchcand, eventfilter, eventqueue, var, tmpvars[0], 1.0, -tmpscalars[0], tmpconstant,
5375 infeasible, aggregated) );
5388 SCIPsetDebugMsg(
set,
"variable is not allowed to be multi-aggregated.\n");
5397 assert(var->
vlbs == NULL);
5398 assert(var->
vubs == NULL);
5440 for( v = 0; v < ntmpvars; ++v )
5442 assert(tmpvars[v] != NULL);
5444 branchfactor =
MAX(tmpvars[v]->branchfactor, branchfactor);
5445 branchpriority =
MAX(tmpvars[v]->branchpriority, branchpriority);
5450 for( v = 0; v < ntmpvars; ++v )
5456 if( tmpscalars[v] >= 0.0 )
5481 SCIP_CALL(
SCIPvarAddObj(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventqueue, obj) );
5504 SCIPerrorMessage(
"cannot multi-aggregate a multiple aggregated variable again\n");
5517 for( v = 0; v < naggvars; ++v )
5521 SCIP_CALL(
SCIPvarMultiaggregate(var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
5522 cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,
scalars,
5526 for( v = 0; v < naggvars; ++v )
5548 assert(var != NULL);
5556 assert(retvar != NULL);
5597 assert(var != NULL);
5600 assert(retvar != NULL);
5634 assert(var != NULL);
5635 assert(var->
scip == set->scip);
5636 assert(negvar != NULL);
5661 (*negvar)->data.negate.constant = 1.0;
5672 (*negvar)->glbdom.lb = (*negvar)->data.negate.constant - var->
glbdom.
ub;
5673 (*negvar)->glbdom.ub = (*negvar)->data.negate.constant - var->
glbdom.
lb;
5674 (*negvar)->locdom.lb = (*negvar)->data.negate.constant - var->
locdom.
ub;
5675 (*negvar)->locdom.ub = (*negvar)->data.negate.constant - var->
locdom.
lb;
5695 (*negvar)->lazylb = (*negvar)->data.negate.constant - var->
lazyub;
5696 (*negvar)->lazyub = (*negvar)->data.negate.constant - var->
lazylb;
5700 assert((*negvar)->nuses == 1);
5720 assert(var != NULL);
5721 assert(probindex >= 0 || var->
vlbs == NULL);
5722 assert(probindex >= 0 || var->
vubs == NULL);
5723 assert(probindex >= 0 || var->
implics == NULL);
5728 assert(var->
data.
col != NULL);
5739 assert(var != NULL);
5740 assert(probindex >= 0);
5754 assert(var != NULL);
5755 assert(name != NULL);
5757 var->
name = (
char*)name;
5776 assert(var->
scip == set->scip);
5807 assert(var != NULL);
5820 assert(var != NULL);
5823 assert(retvar != NULL);
5835 SCIPerrorMessage(
"cannot mark a multi-aggregated variable to not be multi-aggregated.\n");
5854 assert(var != NULL);
5860 SCIPerrorMessage(
"cannot change type of variable already in the problem\n");
5886 assert(var != NULL);
5887 assert(var->
scip == set->scip);
5913 assert(var != NULL);
5914 assert(
set != NULL);
5915 assert(var->
scip == set->scip);
5962 SCIPerrorMessage(
"cannot change objective value of a fixed, aggregated, multi-aggregated, or negated variable\n");
5990 assert(var != NULL);
5991 assert(
set != NULL);
5992 assert(var->
scip == set->scip);
6074 SCIP_CALL(
SCIPvarAddObj(var->
negatedvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
6075 eventqueue, -addobj) );
6095 assert(var != NULL);
6096 assert(
set != NULL);
6097 assert(var->
scip == set->scip);
6100 SCIPsetDebugMsg(
set,
"changing objective of <%s> to %g in current dive\n", var->
name, newobj);
6114 assert(var->
data.
col != NULL);
6131 SCIPerrorMessage(
"cannot change diving objective value of a multi-aggregated variable\n");
6157 assert(var != NULL);
6158 assert(
set != NULL);
6159 assert(var->
scip == set->scip);
6174 assert(var != NULL);
6175 assert(
set != NULL);
6176 assert(var->
scip == set->scip);
6209 assert(var != NULL);
6212 assert(
set != NULL);
6213 assert(var->
scip == set->scip);
6227 SCIPsetDebugMsg(
set,
"changing original lower bound of <%s> from %g to %g\n",
6248 assert(parentvar != NULL);
6268 assert(var != NULL);
6271 assert(
set != NULL);
6272 assert(var->
scip == set->scip);
6286 SCIPsetDebugMsg(
set,
"changing original upper bound of <%s> from %g to %g\n",
6307 assert(parentvar != NULL);
6331 assert(var != NULL);
6335 assert(
set != NULL);
6336 assert(var->
scip == set->scip);
6347 SCIPsetDebugMsg(
set,
"issue GLBCHANGED event for variable <%s>: %g -> %g\n", var->
name, oldbound, newbound);
6369 assert(var != NULL);
6373 assert(
set != NULL);
6374 assert(var->
scip == set->scip);
6385 SCIPsetDebugMsg(
set,
"issue GUBCHANGED event for variable <%s>: %g -> %g\n", var->
name, oldbound, newbound);
6405 assert(var != NULL);
6408 assert(
set != NULL);
6409 assert(var->
scip == set->scip);
6417 SCIPsetDebugMsg(
set,
"issue GHOLEADDED event for variable <%s>: (%.15g,%.15g)\n", var->
name, left, right);
6434 assert(var != NULL);
6435 assert(
set != NULL);
6436 assert(var->
scip == set->scip);
6437 assert(stat != NULL);
6485 assert(var != NULL);
6489 assert(blkmem != NULL);
6490 assert(
set != NULL);
6491 assert(var->
scip == set->scip);
6492 assert(stat != NULL);
6541 SCIPsetDebugMsg(
set,
" -> adjust lower bound change <%s>: %g -> %g due to new global lower bound %g\n",
6576 assert(parentvar != NULL);
6588 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
6605 parentnewbound = newbound;
6621 parentnewbound = -newbound;
6661 assert(var != NULL);
6665 assert(blkmem != NULL);
6666 assert(
set != NULL);
6667 assert(var->
scip == set->scip);
6668 assert(stat != NULL);
6716 SCIPsetDebugMsg(
set,
" -> adjust upper bound change <%s>: %g -> %g due to new global upper bound %g\n",
6751 assert(parentvar != NULL);
6763 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
6779 parentnewbound = newbound;
6794 parentnewbound = -newbound;
6831 assert(var != NULL);
6832 assert(blkmem != NULL);
6833 assert(
set != NULL);
6834 assert(var->
scip == set->scip);
6853 newbound = MIN(newbound, var->
glbdom.
ub);
6874 cliquetable, newbound) );
6913 childnewbound = newbound;
6928 childnewbound = -newbound;
6940 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
6974 assert(var != NULL);
6975 assert(blkmem != NULL);
6976 assert(
set != NULL);
6977 assert(var->
scip == set->scip);
7056 childnewbound = newbound;
7071 childnewbound = -newbound;
7083 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7109 assert(var != NULL);
7113 assert(
set != NULL);
7114 assert(var->
scip == set->scip);
7132 assert(var != NULL);
7136 assert(
set != NULL);
7137 assert(var->
scip == set->scip);
7169 return SCIPvarChgLbGlobal(var, blkmem,
set, stat, lp, branchcand, eventqueue, cliquetable, newbound);
7171 return SCIPvarChgUbGlobal(var, blkmem,
set, stat, lp, branchcand, eventqueue, cliquetable, newbound);
7191 assert(var != NULL);
7195 assert(
set != NULL);
7196 assert(var->
scip == set->scip);
7207 SCIPsetDebugMsg(
set,
"issue LBCHANGED event for variable <%s>: %g -> %g\n", var->
name, oldbound, newbound);
7229 assert(var != NULL);
7233 assert(
set != NULL);
7234 assert(var->
scip == set->scip);
7245 SCIPsetDebugMsg(
set,
"issue UBCHANGED event for variable <%s>: %g -> %g\n", var->
name, oldbound, newbound);
7286 assert(var != NULL);
7287 assert(
set != NULL);
7288 assert(var->
scip == set->scip);
7303 newbound = MIN(newbound, var->
locdom.
ub);
7345 assert(parentvar != NULL);
7357 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7378 if( parentnewbound > parentvar->
glbdom.
ub )
7382 parentnewbound = parentvar->
glbdom.
ub;
7386 parentnewbound = newbound;
7406 if( parentnewbound < parentvar->glbdom.lb )
7410 parentnewbound = parentvar->
glbdom.
lb;
7414 parentnewbound = -newbound;
7453 assert(var != NULL);
7454 assert(
set != NULL);
7455 assert(var->
scip == set->scip);
7473 newbound = MIN(newbound, var->
glbdom.
ub);
7512 assert(parentvar != NULL);
7524 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
7544 if( parentnewbound < parentvar->glbdom.lb )
7548 parentnewbound = parentvar->
glbdom.
lb;
7552 parentnewbound = newbound;
7571 if( parentnewbound > parentvar->
glbdom.
ub )
7575 parentnewbound = parentvar->
glbdom.
ub;
7579 parentnewbound = -newbound;
7615 assert(var != NULL);
7616 assert(blkmem != NULL);
7617 assert(
set != NULL);
7618 assert(var->
scip == set->scip);
7634 newbound = MIN(newbound, var->
locdom.
ub);
7681 childnewbound = newbound;
7696 childnewbound = -newbound;
7708 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7741 assert(var != NULL);
7742 assert(blkmem != NULL);
7743 assert(
set != NULL);
7744 assert(var->
scip == set->scip);
7806 childnewbound = newbound;
7821 childnewbound = -newbound;
7833 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7871 return SCIPvarChgLbLocal(var, blkmem,
set, stat, lp, branchcand, eventqueue, newbound);
7873 return SCIPvarChgUbLocal(var, blkmem,
set, stat, lp, branchcand, eventqueue, newbound);
7888 assert(var != NULL);
7889 assert(
set != NULL);
7890 assert(var->
scip == set->scip);
7897 SCIPsetDebugMsg(
set,
"changing lower bound of <%s> to %g in current dive\n", var->
name, newbound);
7908 assert(var->
data.
col != NULL);
7913 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
7930 childnewbound = newbound;
7941 childnewbound = -newbound;
7952 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
7978 assert(var != NULL);
7979 assert(
set != NULL);
7980 assert(var->
scip == set->scip);
7987 SCIPsetDebugMsg(
set,
"changing upper bound of <%s> to %g in current dive\n", var->
name, newbound);
7998 assert(var->
data.
col != NULL);
8003 SCIPerrorMessage(
"cannot change variable's bounds in dive for LOOSE variables\n");
8020 childnewbound = newbound;
8031 childnewbound = -newbound;
8042 SCIPerrorMessage(
"cannot change the bounds of a multi-aggregated variable.\n");
8078 assert(var != NULL);
8079 assert(
set != NULL);
8080 assert(var->
scip == set->scip);
8144 assert(var != NULL);
8145 assert(
set != NULL);
8146 assert(var->
scip == set->scip);
8210 assert(var != NULL);
8211 assert(
set != NULL);
8212 assert(var->
scip == set->scip);
8276 assert(var != NULL);
8277 assert(
set != NULL);
8278 assert(var->
scip == set->scip);
8335 assert(var != NULL);
8339 assert(
set != NULL);
8340 assert(var->
scip == set->scip);
8393 assert(var != NULL);
8394 assert(added != NULL);
8395 assert(blkmem != NULL);
8443 assert(parentvar != NULL);
8448 parentnewleft = left;
8449 parentnewright = right;
8456 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8495 assert(blkmem != NULL);
8496 assert(
SCIPsetIsLT(
set, parentnewleft, parentnewright));
8498 parentnewleft, parentnewright, &localadded) );
8520 assert(var != NULL);
8522 assert(blkmem != NULL);
8523 assert(added != NULL);
8545 left, right, added) );
8596 childnewleft, childnewright, added) );
8612 childnewleft, childnewright, added) );
8641 assert(var != NULL);
8642 assert(added != NULL);
8643 assert(blkmem != NULL);
8679 SCIP_CALL( varEventLholeAdded(var, blkmem,
set, lp, branchcand, eventqueue, left, right) );
8691 assert(parentvar != NULL);
8696 parentnewleft = left;
8697 parentnewright = right;
8704 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
8743 assert(blkmem != NULL);
8744 assert(
SCIPsetIsLT(
set, parentnewleft, parentnewright));
8746 parentnewleft, parentnewright, &localadded) );
8768 assert(var != NULL);
8772 assert(
set != NULL);
8773 assert(var->
scip == set->scip);
8775 assert(blkmem != NULL);
8776 assert(added != NULL);
8796 left, right, added) );
8836 childnewleft, childnewright, added) );
8840 SCIPerrorMessage(
"cannot add domain hole to a multi-aggregated variable.\n");
8870 assert(var != NULL);
8871 assert(
set != NULL);
8872 assert(var->
scip == set->scip);
8905 assert(var != NULL);
8956 assert(
SCIPsetIsGE(
set, lb, lb * vbcoef + vbconstant) );
8957 assert(
SCIPsetIsGE(
set, ub, ub * vbcoef + vbconstant) );
8961 assert(
SCIPsetIsGE(
set, lb, ub * vbcoef + vbconstant) );
8962 assert(
SCIPsetIsGE(
set, ub, lb * vbcoef + vbconstant) );
8970 assert(
SCIPsetIsLE(
set, lb, lb * vbcoef + vbconstant) );
8971 assert(
SCIPsetIsLE(
set, ub, ub * vbcoef + vbconstant) );
8975 assert(
SCIPsetIsLE(
set, lb, ub * vbcoef + vbconstant) );
8976 assert(
SCIPsetIsLE(
set, ub, lb * vbcoef + vbconstant) );
8980 SCIPsetDebugMsg(
set,
"redundant variable bound: <%s> %s %g<%s> %+g\n",
9026 assert(redundant != NULL);
9027 assert(infeasible != NULL);
9067 assert(infeasible != NULL);
9069 *infeasible =
FALSE;
9087 assert(tree != NULL);
9088 assert(transprob != NULL);
9099 if( nbdchgs != NULL )
9117 assert(tree != NULL);
9118 assert(transprob != NULL);
9129 if( nbdchgs != NULL )
9170 assert(var != NULL);
9175 assert(infeasible != NULL);
9176 assert(added != NULL);
9181 *infeasible =
FALSE;
9185 checkImplic(
set, implvar, impltype, implbound, &redundant, &conflict);
9186 assert(!redundant || !conflict);
9190 if( var == implvar )
9215 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
9216 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
9238 vals[0] = varfixing;
9242 SCIP_CALL(
SCIPcliquetableAdd(cliquetable, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
9243 eventqueue, vars, vals, 2,
FALSE, &conflict, nbdchgs) );
9251 SCIPsetDebugMsg(
set,
"adding implication: <%s> == %u ==> <%s> %s %g\n",
9255 isshortcut, &conflict, added) );
9258 assert(!conflict || !(*added));
9270 assert(tree != NULL);
9271 assert(transprob != NULL);
9296 if( nbdchgs != NULL )
9334 varfixing ? implbound - ub : ub - implbound, varfixing ? ub : implbound) );
9342 varfixing ? implbound - lb : lb - implbound, varfixing ? lb : implbound) );
9378 *infeasible =
FALSE;
9395 while ( i >= 0 && !(*infeasible) )
9399 assert(implvars[i] != implvar);
9406 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9407 eventqueue, varfixing, implvars[i], impltypes[i], implbounds[i],
TRUE, infeasible, nbdchgs, &added) );
9449 assert(var != NULL);
9452 assert(implvar != NULL);
9454 assert(infeasible != NULL);
9457 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
9458 eventqueue, varfixing, implvar, impltype, implbound,
FALSE, infeasible, nbdchgs, &added) );
9460 if( *infeasible || var == implvar || !transitive || !added )
9474 cliquetable, branchcand, eventqueue, varfixing, implvar, implvarfixing, infeasible, nbdchgs) );
9477 if( !(*infeasible) )
9480 cliquetable, branchcand, eventqueue, !implvarfixing, var, !varfixing, infeasible, nbdchgs) );
9506 while ( i >= 0 && !(*infeasible) )
9508 assert(vlbvars[i] != implvar);
9533 vbimplbound = (implbound - vlbconstants[i])/vlbcoefs[i];
9534 if( vlbcoefs[i] >= 0.0 )
9537 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9539 infeasible, nbdchgs, &added) );
9544 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9546 infeasible, nbdchgs, &added) );
9549 i = MIN(i, nvlbvars);
9576 while ( i >= 0 && !(*infeasible) )
9578 assert(vubvars[i] != implvar);
9603 vbimplbound = (implbound - vubconstants[i])/vubcoefs[i];
9604 if( vubcoefs[i] >= 0.0 )
9607 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9609 infeasible, nbdchgs, &added) );
9614 SCIP_CALL(
varAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9616 infeasible, nbdchgs, &added) );
9619 i = MIN(i, nvubvars);
9654 assert(var != NULL);
9655 assert(
set != NULL);
9656 assert(var->
scip == set->scip);
9658 assert(infeasible != NULL);
9662 *infeasible =
FALSE;
9663 if( nbdchgs != NULL )
9671 cliquetable, branchcand, eventqueue, vlbvar, vlbcoef, vlbconstant, transitive, infeasible, nbdchgs) );
9693 assert(tree != NULL);
9694 assert(transprob != NULL);
9705 if( nbdchgs != NULL )
9719 assert(vlbcoef != 0.0);
9730 if( vlbcoef >= 0.0 )
9737 newzub = (xub - vlbconstant)/vlbcoef;
9758 assert(tree != NULL);
9759 assert(transprob != NULL);
9771 if( nbdchgs != NULL )
9774 maxvlb = vlbcoef * zub + vlbconstant;
9776 minvlb = vlbcoef * zlb + vlbconstant;
9781 maxvlb = vlbcoef * zub + vlbconstant;
9783 minvlb = vlbcoef * zlb + vlbconstant;
9793 newzlb = (xub - vlbconstant)/vlbcoef;
9814 assert(tree != NULL);
9815 assert(transprob != NULL);
9827 if( nbdchgs != NULL )
9830 maxvlb = vlbcoef * zlb + vlbconstant;
9832 minvlb = vlbcoef * zub + vlbconstant;
9837 maxvlb = vlbcoef * zlb + vlbconstant;
9839 minvlb = vlbcoef * zub + vlbconstant;
9842 if( maxvlb < minvlb )
9866 assert(tree != NULL);
9867 assert(transprob != NULL);
9879 if( nbdchgs != NULL )
9893 if( vlbcoef >= 0.0 )
9895 vlbcoef = maxvlb - minvlb;
9896 vlbconstant = minvlb;
9900 vlbcoef = minvlb - maxvlb;
9901 vlbconstant = maxvlb;
9921 cliquetable, branchcand, eventqueue, (vlbcoef >= 0.0), var,
SCIP_BOUNDTYPE_LOWER, maxvlb, transitive,
9922 infeasible, nbdchgs) );
9931 implbound = -vlbconstant/vlbcoef;
9943 implbound, transitive, infeasible, nbdchgs) );
9988 SCIP_CALL(
SCIPvarAddVub(var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
9989 branchcand, eventqueue, vlbvar, -vlbcoef, var->
data.
negate.
constant - vlbconstant, transitive, infeasible,
10026 assert(var != NULL);
10027 assert(
set != NULL);
10028 assert(var->
scip == set->scip);
10030 assert(infeasible != NULL);
10034 *infeasible =
FALSE;
10035 if( nbdchgs != NULL )
10043 cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );
10051 SCIPsetDebugMsg(
set,
" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n",
10058 *infeasible =
TRUE;
10066 assert(tree != NULL);
10067 assert(transprob != NULL);
10078 if( nbdchgs != NULL )
10092 assert(vubcoef != 0.0);
10103 if( vubcoef >= 0.0 )
10110 newzlb = (xlb - vubconstant)/vubcoef;
10113 *infeasible =
TRUE;
10126 assert(tree != NULL);
10127 assert(transprob != NULL);
10139 if( nbdchgs != NULL )
10142 minvub = vubcoef * zlb + vubconstant;
10144 maxvub = vubcoef * zub + vubconstant;
10149 maxvub = vubcoef * zub + vubconstant;
10151 minvub = vubcoef * zlb + vubconstant;
10161 newzub = (xlb - vubconstant)/vubcoef;
10164 *infeasible =
TRUE;
10177 assert(tree != NULL);
10178 assert(transprob != NULL);
10190 if( nbdchgs != NULL )
10193 minvub = vubcoef * zub + vubconstant;
10195 maxvub = vubcoef * zlb + vubconstant;
10200 minvub = vubcoef * zub + vubconstant;
10202 maxvub = vubcoef * zlb + vubconstant;
10206 if( minvub > maxvub )
10216 *infeasible =
TRUE;
10230 assert(tree != NULL);
10231 assert(transprob != NULL);
10243 if( nbdchgs != NULL )
10257 if( vubcoef >= 0.0 )
10259 vubcoef = maxvub - minvub;
10260 vubconstant = minvub;
10264 vubcoef = minvub - maxvub;
10265 vubconstant = maxvub;
10285 cliquetable, branchcand, eventqueue, (vubcoef < 0.0), var,
SCIP_BOUNDTYPE_UPPER, minvub, transitive,
10286 infeasible, nbdchgs) );
10296 (1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );
10341 SCIP_CALL(
SCIPvarAddVlb(var->
negatedvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10342 branchcand, eventqueue, vubvar, -vubcoef, var->
data.
negate.
constant - vubconstant, transitive, infeasible,
10382 assert(var != NULL);
10383 assert(
set != NULL);
10384 assert(var->
scip == set->scip);
10386 assert(infeasible != NULL);
10388 *infeasible =
FALSE;
10389 if( nbdchgs != NULL )
10397 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10411 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10412 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
10421 SCIP_CALL(
varAddTransitiveImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10422 branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
10431 SCIP_CALL(
applyImplic(blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,
10432 cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );
10455 cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,
10461 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,
10485 cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );
10493 SCIP_CALL(
SCIPvarAddImplic(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10496 infeasible, nbdchgs) );
10511 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? 1.0 : -1.0,
10520 cliquetable, branchcand, eventqueue, implvar, (impltype ==
SCIP_BOUNDTYPE_UPPER) ? -1.0 : 1.0,
10530 SCIP_CALL(
SCIPvarAddVub(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10531 branchcand, eventqueue, var->
negatedvar, (varfixing) ? 1.0 : -1.0,
10532 (varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );
10539 SCIP_CALL(
SCIPvarAddVlb(implvar, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
10540 branchcand, eventqueue, var->
negatedvar, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,
10541 transitive, infeasible, nbdchgs) );
10566 assert(var != NULL);
10567 assert(implvar != NULL);
10610 assert(var != NULL);
10611 assert(
set != NULL);
10612 assert(var->
scip == set->scip);
10613 assert(infeasible != NULL);
10615 *infeasible =
FALSE;
10617 if( value ==
FALSE )
10620 *infeasible =
TRUE;
10628 assert(tree != NULL);
10629 assert(transprob != NULL);
10640 if( nbdchgs != NULL )
10647 *infeasible =
TRUE;
10655 assert(tree != NULL);
10656 assert(transprob != NULL);
10667 if( nbdchgs != NULL )
10702 assert(var != NULL);
10703 assert(
set != NULL);
10704 assert(var->
scip == set->scip);
10706 assert(infeasible != NULL);
10708 *infeasible =
FALSE;
10736 SCIP_CALL(
SCIPvarFixBinary(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
10737 eventqueue, cliquetable, !value, infeasible, nbdchgs) );
10743 if( oppositeentry )
10753 for( i = 0; i < nvars && !(*infeasible); ++i )
10755 if( vars[i] == var )
10758 SCIP_CALL(
SCIPvarFixBinary(vars[i], blkmem,
set, stat, transprob, origprob, tree, reopt, lp, branchcand,
10759 eventqueue, cliquetable, !values[i], infeasible, nbdchgs) );
10780 assert(vars != NULL);
10781 assert(values != NULL);
10783 assert(
set != NULL);
10784 assert(blkmem != NULL);
10785 assert(clique != NULL);
10787 for( v = nvars - 1; v >= 0; --v )
10814 assert(var != NULL);
10835 assert(var != NULL);
10853 assert(var != NULL);
10896 assert(var1 != NULL);
10897 assert(var2 != NULL);
10919 assert(var != NULL);
10920 assert(
set != NULL);
10921 assert(var->
scip == set->scip);
10925 branchfactor =
MAX(branchfactor,
eps);
10939 assert(parentvar != NULL);
10951 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
10981 assert(var != NULL);
10982 assert(
set != NULL);
10983 assert(var->
scip == set->scip);
10984 assert(branchfactor >= 0.0);
11051 assert(var != NULL);
11053 SCIPdebugMessage(
"process changing branch priority of <%s> from %d to %d\n",
11066 assert(parentvar != NULL);
11078 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11106 assert(var != NULL);
11170 assert(var != NULL);
11172 SCIPdebugMessage(
"process changing branch direction of <%s> from %u to %d\n",
11185 assert(parentvar != NULL);
11197 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
11236 assert(var != NULL);
11319 assert(var1 != NULL);
11320 assert(var2 != NULL);
11329 assert(var1 != NULL);
11330 assert(var2 != NULL);
11337 assert(var1 == var2);
11357 assert(var1 != NULL);
11358 assert(var2 != NULL);
11366 assert(var1 == var2);
11388 else if( obj1 > obj2 )
11430 int activevarssize;
11442 assert(
set != NULL);
11443 assert(nvars != NULL);
11444 assert(vars != NULL || *nvars == 0);
11445 assert(varssize >= *nvars);
11446 assert(requiredsize != NULL);
11454 activevarssize = *nvars;
11456 tmpvarssize = *nvars;
11462 noldtmpvars = ntmpvars;
11465 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
11466 for( v = ntmpvars - 1; v > 0; --v )
11472 tmpvars[v] = tmpvars[ntmpvars];
11476 if( noldtmpvars > ntmpvars )
11477 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
11480 while( ntmpvars >= 1 )
11483 var = tmpvars[ntmpvars];
11484 assert( var != NULL );
11491 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
11512 if( nactivevars >= activevarssize )
11514 activevarssize *= 2;
11516 assert(nactivevars < activevarssize);
11518 activevars[nactivevars] = var;
11528 if( nmultvars + ntmpvars > tmpvarssize )
11530 while( nmultvars + ntmpvars > tmpvarssize )
11533 assert(nmultvars + ntmpvars <= tmpvarssize);
11542 ntmpvars += nmultvars;
11543 noldtmpvars = ntmpvars;
11546 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
11547 for( v = ntmpvars - 1; v > 0; --v )
11553 tmpvars[v] = tmpvars[ntmpvars];
11557 if( noldtmpvars > ntmpvars )
11558 SCIPsortPtr((
void**)tmpvars, SCIPvarComp, ntmpvars);
11574 SCIPsortPtr((
void**)activevars, SCIPvarComp, nactivevars);
11577 v = nactivevars - 1;
11584 activevars[v] = activevars[nactivevars];
11588 *requiredsize = nactivevars;
11590 if( varssize >= *requiredsize )
11592 assert(vars != NULL);
11594 *nvars = *requiredsize;
11614 assert(vars != NULL || nvars == 0);
11616 for( v = nvars - 1; v >= 0; --v )
11618 assert(vars != NULL);
11619 assert(vars[v] != NULL);
11622 assert(vars[v] != NULL);
11633 assert(var != NULL);
11641 assert(retvar != NULL);
11648 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
11697 assert(vars != NULL);
11698 assert(*vars != NULL || nvars == 0);
11699 assert(negatedarr != NULL);
11700 assert(*negatedarr != NULL || nvars == 0);
11702 for( v = nvars - 1; v >= 0; --v )
11704 var = &((*vars)[v]);
11705 negated = &((*negatedarr)[v]);
11730 assert(var != NULL);
11731 assert(*var != NULL);
11732 assert(negated != NULL);
11736 orignegated = *negated;
11739 while( !
active && *var != NULL )
11744 if( (*var)->data.original.transvar == NULL )
11757 if ( (*var)->data.multaggr.nvars == 1 )
11759 assert( (*var)->data.multaggr.vars != NULL );
11760 assert( (*var)->data.multaggr.scalars != NULL );
11762 assert(!
EPSZ((*var)->data.multaggr.scalars[0], 1e-06));
11772 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)) )
11774 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06));
11783 if( !
EPSEQ(
REALABS((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )
11793 assert(
EPSZ((*var)->data.multaggr.constant, 1e-06) ||
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06)
11794 ||
EPSZ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)
11795 ||
EPSEQ((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));
11797 if( !
EPSZ((*var)->data.multaggr.constant, 1e-06) && !
EPSEQ((*var)->data.multaggr.constant, 1.0, 1e-06) )
11803 assert(
EPSEQ((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
11805 if(
EPSZ((*var)->data.multaggr.constant, 1e-06) )
11811 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?
11817 assert(
EPSEQ((*var)->data.multaggr.scalars[0], -1.0, 1e-06));
11819 constant += (*negated) != orignegated ? -1.0 : 1.0;
11822 *negated = !(*negated);
11832 assert((*var)->data.aggregate.var != NULL);
11833 assert(
EPSEQ((*var)->data.aggregate.scalar, 1.0, 1e-06) ||
EPSEQ((*var)->data.aggregate.scalar, -1.0, 1e-06));
11834 assert(
EPSLE((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));
11836 constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;
11839 *negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);
11844 assert((*var)->negatedvar != NULL);
11846 constant += (*negated) != orignegated ? -1.0 : 1.0;
11849 *negated = !(*negated);
11858 assert(
active == (*var != NULL));
11863 assert(
EPSZ(constant, 1e-06) ||
EPSEQ(constant, 1.0, 1e-06));
11864 assert(
EPSZ(constant, 1e-06) == ((*negated) == orignegated));
11884 assert(var != NULL);
11885 assert(*var != NULL);
11886 assert(
bound != NULL);
11887 assert(boundtype != NULL);
11889 SCIPdebugMessage(
"get probvar bound %g of type %d of variable <%s>\n", *
bound, *boundtype, (*var)->name);
11894 if( (*var)->data.original.transvar == NULL )
11896 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
11910 if ( (*var)->data.multaggr.nvars == 1 )
11912 assert( (*var)->data.multaggr.vars != NULL );
11913 assert( (*var)->data.multaggr.scalars != NULL );
11914 assert( (*var)->data.multaggr.scalars[0] != 0.0 );
11916 (*bound) /= (*var)->data.multaggr.scalars[0];
11917 (*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];
11918 if ( (*var)->data.multaggr.scalars[0] < 0.0 )
11931 assert((*var)->data.aggregate.var != NULL);
11932 assert((*var)->data.aggregate.scalar != 0.0);
11934 (*bound) /= (*var)->data.aggregate.scalar;
11935 (*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
11936 if( (*var)->data.aggregate.scalar < 0.0 )
11948 assert((*var)->negatedvar != NULL);
11950 assert((*var)->negatedvar->negatedvar == *var);
11951 (*bound) = (*var)->data.negate.constant - *
bound;
11977 assert(var != NULL);
11978 assert(*var != NULL);
11979 assert(left != NULL);
11980 assert(right != NULL);
11982 SCIPdebugMessage(
"get probvar hole (%g,%g) of variable <%s>\n", *left, *right, (*var)->name);
11987 if( (*var)->data.original.transvar == NULL )
11989 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12003 assert((*var)->data.aggregate.var != NULL);
12004 assert((*var)->data.aggregate.scalar != 0.0);
12007 (*left) /= (*var)->data.aggregate.scalar;
12008 (*right) /= (*var)->data.aggregate.scalar;
12011 (*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12012 (*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;
12017 if( (*var)->data.aggregate.scalar < 0.0 )
12028 assert((*var)->negatedvar != NULL);
12030 assert((*var)->negatedvar->negatedvar == *var);
12033 (*left) = (*var)->data.negate.constant - (*left);
12034 (*right) = (*var)->data.negate.constant - (*right);
12063 assert(var != NULL);
12064 assert(scalar != NULL);
12065 assert(constant != NULL);
12067 while( *var != NULL )
12072 if( (*var)->data.original.transvar == NULL )
12074 SCIPerrorMessage(
"original variable has no transformed variable attached\n");
12089 assert(*scalar != 0.0);
12090 if( (*scalar) * (*var)->glbdom.lb > 0.0 )
12096 (*constant) += *scalar * (*var)->glbdom.lb;
12101 assert(!
SCIPsetIsInfinity(
set, (*constant)) || !((*scalar) * (*var)->glbdom.lb < 0.0 &&
12103 assert(!
SCIPsetIsInfinity(
set, -(*constant)) || !((*scalar) * (*var)->glbdom.lb > 0.0 &&
12112 if ( (*var)->data.multaggr.nvars == 1 )
12114 assert((*var)->data.multaggr.vars != NULL);
12115 assert((*var)->data.multaggr.scalars != NULL);
12116 assert((*var)->data.multaggr.vars[0] != NULL);
12126 if( (*scalar) * (*var)->data.multaggr.constant > 0 )
12139 (*constant) += *scalar * (*var)->data.multaggr.constant;
12141 (*scalar) *= (*var)->data.multaggr.scalars[0];
12148 assert((*var)->data.aggregate.var != NULL);
12152 (*constant) += *scalar * (*var)->data.aggregate.constant;
12153 (*scalar) *= (*var)->data.aggregate.scalar;
12158 assert((*var)->negatedvar != NULL);
12160 assert((*var)->negatedvar->negatedvar == *var);
12164 (*constant) += *scalar * (*var)->data.negate.constant;
12191 assert(var != NULL);
12192 assert(*var != NULL);
12193 assert(scalar != NULL);
12194 assert(constant != NULL);
12201 if( (*var)->nparentvars == 0 )
12207 ((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *var) )
12210 *constant -= (*var)->data.negate.constant * (*scalar);
12228 assert(parentvar != NULL);
12239 SCIPerrorMessage(
"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n");
12262 assert( parentvar != NULL );
12275 assert(var != NULL);
12282 assert(parentvar != NULL);
12287 assert( parentvar != NULL );
12299 assert(var != NULL);
12309 assert(var->
data.
col != NULL);
12321 SCIPerrorMessage(
"cannot get the objective value of a multiple aggregated variable\n");
12346 assert(var != NULL);
12347 assert(
set != NULL);
12348 assert(var->
scip == set->scip);
12358 assert(var->
data.
col != NULL);
12391 SCIPerrorMessage(
"getting the bounds of a multiple aggregated variable is not implemented yet\n");
12416 assert(var != NULL);
12417 assert(
set != NULL);
12418 assert(var->
scip == set->scip);
12428 assert(var->
data.
col != NULL);
12460 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
12482 assert(var != NULL);
12495 assert(var->
data.
col != NULL);
12557 assert(var != NULL);
12605 assert(var != NULL);
12681 assert(var != NULL);
12695 assert(var != NULL);
12696 assert(
set != NULL);
12697 assert(var->
scip == set->scip);
12723 if( rootredcost > 0.0 )
12728 cutoffbound = (bound - rootsol) * rootredcost + rootlpobjval;
12731 if( cutoffbound > currcutoffbound )
12733 SCIPsetDebugMsg(
set,
"-> <%s> update potential cutoff bound <%g> -> <%g>\n",
12764 assert(var != NULL);
12837 assert(col != NULL);
12870 #define MAX_CLIQUELENGTH 50 12893 #ifdef SCIP_MORE_DEBUG 12919 assert(prob != NULL);
12929 assert(cliques != NULL);
12931 for( c = ncliques - 1; c >= 0; --c )
12933 clique = cliques[c];
12934 assert(clique != NULL);
12936 assert(nclqvars > 0);
12943 assert(clqvars != NULL);
12944 assert(clqvalues != NULL);
12948 for( v = nclqvars - 1; v >= 0; --v )
12950 clqvar = clqvars[v];
12951 assert(clqvar != NULL);
12958 assert(0 < probindex && probindex < nentries);
12964 assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));
12966 if( entries[probindex] == 0 )
12968 ids[nids] = probindex;
12972 entries[probindex] = (clqvalues[v] ? probindex : -probindex);
12979 assert(probvars != NULL);
12982 for( v = nids - 1; v >= 0; --v )
12985 assert(0 <
id &&
id < nentries);
12986 assert(entries[
id] != 0);
12987 assert(probvars[
id - 1] != NULL);
12992 if( (entries[
id] > 0) != varfixing )
12993 redcost =
getImplVarRedcost(probvars[
id - 1],
set, (entries[
id] < 0), stat, lp);
12995 redcost = -
getImplVarRedcost(probvars[
id - 1],
set, (entries[
id] < 0), stat, lp);
12998 implredcost += redcost;
13008 #ifdef SCIP_MORE_DEBUG 13034 for( v = nvars - 1; v >= 0; --v )
13037 assert(implvar != NULL);
13047 assert(col != NULL);
13062 redcost *= (lb - bounds[v]);
13064 redcost *= (bounds[v] - lb);
13072 redcost *= (bounds[v] - ub);
13074 redcost *= (ub - bounds[v]);
13088 redcost *= (lb - bounds[v]);
13090 redcost *= (bounds[v] - lb);
13098 redcost *= (bounds[v] - ub);
13100 redcost *= (ub - bounds[v]);
13106 implredcost += redcost;
13110 #ifdef SCIP_MORE_DEBUG 13111 SCIPsetDebugMsg(
set,
"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n",
13115 return implredcost;
13128 assert(var != NULL);
13191 assert(var != NULL);
13225 assert(var != NULL);
13259 assert(var != NULL);
13275 assert(var != NULL);
13276 assert(relaxation != NULL);
13277 assert(
set != NULL);
13278 assert(var->
scip == set->scip);
13297 SCIPerrorMessage(
"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13309 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13337 assert(var != NULL);
13338 assert(
set != NULL);
13339 assert(var->
scip == set->scip);
13404 assert(var != NULL);
13417 assert(var != NULL);
13418 assert(
set != NULL);
13419 assert(var->
scip == set->scip);
13436 SCIPerrorMessage(
"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n",
13449 SCIPerrorMessage(
"cannot set solution value for multiple aggregated variable\n");
13474 assert(var != NULL);
13487 avgsol = MIN(avgsol, var->
glbdom.
ub);
13538 assert(var != NULL);
13539 assert(stat != NULL);
13540 assert(
set != NULL);
13541 assert(var->
scip == set->scip);
13542 assert(closestvlb != NULL);
13543 assert(closestvlbidx != NULL);
13545 *closestvlbidx = -1;
13564 assert(0 <= i && i < nvlbs);
13566 *closestvlbidx = i;
13567 *closestvlb = vlbcoefs[i] *
SCIPvarGetLPSol(vlbvars[i]) + vlbconsts[i];
13572 for( i = 0; i < nvlbs; i++ )
13579 if( vlbsol > *closestvlb )
13581 *closestvlb = vlbsol;
13582 *closestvlbidx = i;
13613 assert(var != NULL);
13614 assert(
set != NULL);
13615 assert(var->
scip == set->scip);
13616 assert(closestvub != NULL);
13617 assert(closestvubidx != NULL);
13619 *closestvubidx = -1;
13638 assert(0 <= i && i < nvubs);
13640 *closestvubidx = i;
13641 *closestvub = vubcoefs[i] *
SCIPvarGetLPSol(vubvars[i]) + vubconsts[i];
13646 for( i = 0; i < nvubs; i++ )
13653 if( vubsol < *closestvub )
13655 *closestvub = vubsol;
13656 *closestvubidx = i;
13688 assert(var != NULL);
13689 assert(
set != NULL);
13690 assert(var->
scip == set->scip);
13691 assert(row != NULL);
13723 assert(var->
data.
col != NULL);
13773 #ifdef SCIP_HISTORYTOFILE 13775 const char* historypath=
".";
13792 assert(var != NULL);
13793 assert(
set != NULL);
13794 assert(var->
scip == set->scip);
13795 assert(stat != NULL);
13806 SCIPerrorMessage(
"cannot update pseudo costs of original untransformed variable\n");
13827 #ifdef SCIP_HISTORYTOFILE 13830 char filename[256];
13836 sprintf(filename,
"%s/%s.pse", historypath,
SCIPgetProbName(set->scip));
13837 f = fopen(filename,
"a");
13840 fprintf(f,
"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n",
13856 SCIPerrorMessage(
"cannot update pseudo cost values of a fixed variable\n");
13866 SCIPerrorMessage(
"cannot update pseudo cost values of a multi-aggregated variable\n");
13888 assert(var != NULL);
13889 assert(stat != NULL);
13937 assert(var != NULL);
13938 assert(stat != NULL);
13981 assert(var != NULL);
14026 assert(var != NULL);
14085 solvaldeltaup =
SCIPsetCeil(
set, solval) - solval;
14092 return MIN(upscore, downscore);
14102 assert(var != NULL);
14115 if( onlycurrentrun )
14165 if( onlycurrentrun )
14170 assert(count >= 1.9);
14172 confidencebound /= count;
14173 confidencebound =
sqrt(confidencebound);
14180 confidencebound = 0.0;
14182 return confidencebound;
14206 size = MIN(downsize, upsize);
14216 if( downsize >= 1.9 )
14222 normval =
MAX(1.0, normval);
14224 relerrordown /= normval;
14227 relerrordown = 0.0;
14229 if( upsize >= 1.9 )
14235 normval =
MAX(1.0, normval);
14236 relerrorup /= normval;
14242 relerror =
MAX(relerrorup, relerrordown);
14244 return (relerror <= threshold);
14294 if( countx <= 1.9 || county <= 1.9 )
14391 SCIPerrorMessage(
"Confidence level set to unknown value <%d>", (
int)clevel);
14396 return (probability >= problimit);
14409 assert(var != NULL);
14410 assert(blkmem != NULL);
14411 assert(
set != NULL);
14412 assert(history != NULL);
14438 assert(
set != NULL);
14441 if( !set->history_valuebased )
14466 assert(var != NULL);
14481 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
14498 assert(history != NULL);
14530 value = 1.0 - value;
14547 assert(var != NULL);
14554 SCIPerrorMessage(
"cannot update VSIDS of original untransformed variable\n");
14602 assert(var != NULL);
14614 SCIPerrorMessage(
"cannot update conflict score of original untransformed variable\n");
14631 assert(history != NULL);
14657 SCIPerrorMessage(
"cannot update conflict score of a multi-aggregated variable\n");
14661 value = 1.0 - value;
14679 assert(var != NULL);
14680 assert(stat != NULL);
14726 assert(var != NULL);
14727 assert(stat != NULL);
14770 assert(var != NULL);
14814 assert(var != NULL);
14862 assert(var != NULL);
14863 assert(stat != NULL);
14875 SCIPerrorMessage(
"cannot update branching counter of original untransformed variable\n");
14894 assert(history != NULL);
14902 SCIPerrorMessage(
"cannot update branching counter of a fixed variable\n");
14920 SCIPerrorMessage(
"cannot update branching counter of a multi-aggregated variable\n");
14924 value = 1.0 - value;
14946 assert(var != NULL);
14947 assert(stat != NULL);
14959 SCIPerrorMessage(
"cannot update inference counter of original untransformed variable\n");
14978 assert(history != NULL);
14986 SCIPerrorMessage(
"cannot update inference counter of a fixed variable\n");
15004 SCIPerrorMessage(
"cannot update inference counter of a multi-aggregated variable\n");
15008 value = 1.0 - value;
15030 assert(var != NULL);
15031 assert(stat != NULL);
15043 SCIPerrorMessage(
"cannot update cutoff sum of original untransformed variable\n");
15062 assert(history != NULL);
15088 SCIPerrorMessage(
"cannot update cutoff sum of a multi-aggregated variable\n");
15092 value = 1.0 - value;
15109 assert(var != NULL);
15154 assert(var != NULL);
15197 assert(var != NULL);
15242 assert(var != NULL);
15288 assert(var != NULL);
15289 assert(stat != NULL);
15337 assert(var != NULL);
15338 assert(stat != NULL);
15343 SCIPerrorMessage(
"invalid branching direction %d when asking for VSIDS value\n", dir);
15387 assert(var != NULL);
15432 assert(var != NULL);
15476 assert(var != NULL);
15477 assert(stat != NULL);
15533 assert(var != NULL);
15534 assert(stat != NULL);
15587 assert(var != NULL);
15630 assert(var != NULL);
15674 assert(var != NULL);
15675 assert(stat != NULL);
15721 assert(var != NULL);
15722 assert(stat != NULL);
15778 assert(bdchginfo != NULL);
15781 (*bdchginfo)->oldbound = oldbound;
15782 (*bdchginfo)->newbound = newbound;
15783 (*bdchginfo)->var = var;
15784 (*bdchginfo)->inferencedata.var = var;
15785 (*bdchginfo)->inferencedata.reason.prop = NULL;
15786 (*bdchginfo)->inferencedata.info = 0;
15787 (*bdchginfo)->bdchgidx.depth = INT_MAX;
15788 (*bdchginfo)->bdchgidx.pos = -1;
15789 (*bdchginfo)->pos = 0;
15791 (*bdchginfo)->boundtype = boundtype;
15792 (*bdchginfo)->inferboundtype = boundtype;
15793 (*bdchginfo)->redundant =
FALSE;
15804 assert(bdchginfo != NULL);
15821 assert(var != NULL);
15877 assert(var != NULL);
15953 assert(var != NULL);
15959 if( bdchgidx == NULL )
15966 if( bdchginfo != NULL )
15974 switch( varstatus )
16046 SCIPerrorMessage(
"cannot get the bounds of a multi-aggregated variable.\n");
16077 assert(var != NULL);
16083 if( bdchgidx == NULL )
16090 if( bdchginfo != NULL )
16098 switch( varstatus )
16170 SCIPerrorMessage(
"cannot get the bounds of a multiple aggregated variable.\n");
16220 assert(var != NULL);
16244 assert(var != NULL);
16281 assert(bdchgidx != NULL);
16283 return bdchgidx->
depth;
16298 assert(var != NULL);
16299 assert(
set != NULL);
16300 assert(var->
scip == set->scip);
16370 assert(var1 != NULL);
16371 assert(var2 != NULL);
16377 assert(var1 != NULL);
16378 assert(var2 != NULL);
16425 assert(var != NULL);
16442 #undef SCIPboundchgGetNewbound 16443 #undef SCIPboundchgGetVar 16444 #undef SCIPboundchgGetBoundchgtype 16445 #undef SCIPboundchgGetBoundtype 16446 #undef SCIPboundchgIsRedundant 16447 #undef SCIPdomchgGetNBoundchgs 16448 #undef SCIPdomchgGetBoundchg 16449 #undef SCIPholelistGetLeft 16450 #undef SCIPholelistGetRight 16451 #undef SCIPholelistGetNext 16452 #undef SCIPvarGetName 16453 #undef SCIPvarGetNUses 16454 #undef SCIPvarGetData 16455 #undef SCIPvarSetData 16456 #undef SCIPvarSetDelorigData 16457 #undef SCIPvarSetTransData 16458 #undef SCIPvarSetDeltransData 16459 #undef SCIPvarGetStatus 16460 #undef SCIPvarIsOriginal 16461 #undef SCIPvarIsTransformed 16462 #undef SCIPvarIsNegated 16463 #undef SCIPvarGetType 16464 #undef SCIPvarIsBinary 16465 #undef SCIPvarIsIntegral 16466 #undef SCIPvarIsInitial 16467 #undef SCIPvarIsRemovable 16468 #undef SCIPvarIsDeleted 16469 #undef SCIPvarIsDeletable 16470 #undef SCIPvarMarkDeletable 16471 #undef SCIPvarMarkNotDeletable 16472 #undef SCIPvarIsActive 16473 #undef SCIPvarGetIndex 16474 #undef SCIPvarGetProbindex 16475 #undef SCIPvarGetTransVar 16476 #undef SCIPvarGetCol 16477 #undef SCIPvarIsInLP 16478 #undef SCIPvarGetAggrVar 16479 #undef SCIPvarGetAggrScalar 16480 #undef SCIPvarGetAggrConstant 16481 #undef SCIPvarGetMultaggrNVars 16482 #undef SCIPvarGetMultaggrVars 16483 #undef SCIPvarGetMultaggrScalars 16484 #undef SCIPvarGetMultaggrConstant 16485 #undef SCIPvarGetNegatedVar 16486 #undef SCIPvarGetNegationVar 16487 #undef SCIPvarGetNegationConstant 16488 #undef SCIPvarGetObj 16489 #undef SCIPvarGetLbOriginal 16490 #undef SCIPvarGetUbOriginal 16491 #undef SCIPvarGetHolelistOriginal 16492 #undef SCIPvarGetLbGlobal 16493 #undef SCIPvarGetUbGlobal 16494 #undef SCIPvarGetHolelistGlobal 16495 #undef SCIPvarGetBestBoundGlobal 16496 #undef SCIPvarGetWorstBoundGlobal 16497 #undef SCIPvarGetLbLocal 16498 #undef SCIPvarGetUbLocal 16499 #undef SCIPvarGetHolelistLocal 16500 #undef SCIPvarGetBestBoundLocal 16501 #undef SCIPvarGetWorstBoundLocal 16502 #undef SCIPvarGetBestBoundType 16503 #undef SCIPvarGetWorstBoundType 16504 #undef SCIPvarGetLbLazy 16505 #undef SCIPvarGetUbLazy 16506 #undef SCIPvarGetBranchFactor 16507 #undef SCIPvarGetBranchPriority 16508 #undef SCIPvarGetBranchDirection 16509 #undef SCIPvarGetNVlbs 16510 #undef SCIPvarGetVlbVars 16511 #undef SCIPvarGetVlbCoefs 16512 #undef SCIPvarGetVlbConstants 16513 #undef SCIPvarGetNVubs 16514 #undef SCIPvarGetVubVars 16515 #undef SCIPvarGetVubCoefs 16516 #undef SCIPvarGetVubConstants 16517 #undef SCIPvarGetNImpls 16518 #undef SCIPvarGetImplVars 16519 #undef SCIPvarGetImplTypes 16520 #undef SCIPvarGetImplBounds 16521 #undef SCIPvarGetImplIds 16522 #undef SCIPvarGetNCliques 16523 #undef SCIPvarGetCliques 16524 #undef SCIPvarGetLPSol 16525 #undef SCIPvarGetNLPSol 16526 #undef SCIPvarGetBdchgInfoLb 16527 #undef SCIPvarGetNBdchgInfosLb 16528 #undef SCIPvarGetBdchgInfoUb 16529 #undef SCIPvarGetNBdchgInfosUb 16530 #undef SCIPvarGetValuehistory 16531 #undef SCIPvarGetPseudoSol 16532 #undef SCIPvarCatchEvent 16533 #undef SCIPvarDropEvent 16534 #undef SCIPvarGetVSIDS 16535 #undef SCIPvarGetCliqueComponentIdx 16536 #undef SCIPbdchgidxGetPos 16537 #undef SCIPbdchgidxIsEarlierNonNull 16538 #undef SCIPbdchgidxIsEarlier 16539 #undef SCIPbdchginfoGetOldbound 16540 #undef SCIPbdchginfoGetNewbound 16541 #undef SCIPbdchginfoGetVar 16542 #undef SCIPbdchginfoGetChgtype 16543 #undef SCIPbdchginfoGetBoundtype 16544 #undef SCIPbdchginfoGetDepth 16545 #undef SCIPbdchginfoGetPos 16546 #undef SCIPbdchginfoGetIdx 16547 #undef SCIPbdchginfoGetInferVar 16548 #undef SCIPbdchginfoGetInferCons 16549 #undef SCIPbdchginfoGetInferProp 16550 #undef SCIPbdchginfoGetInferInfo 16551 #undef SCIPbdchginfoGetInferBoundtype 16552 #undef SCIPbdchginfoIsRedundant 16553 #undef SCIPbdchginfoHasInferenceReason 16554 #undef SCIPbdchginfoIsTighter 16562 assert(boundchg != NULL);
16572 assert(boundchg != NULL);
16574 return boundchg->
var;
16582 assert(boundchg != NULL);
16592 assert(boundchg != NULL);
16602 assert(boundchg != NULL);
16621 assert(domchg != NULL);
16632 assert(holelist != NULL);
16642 assert(holelist != NULL);
16652 assert(holelist != NULL);
16654 return holelist->
next;
16665 assert(var != NULL);
16675 assert(var != NULL);
16685 assert(var != NULL);
16696 assert(var != NULL);
16707 assert(var != NULL);
16710 var->vardelorig = vardelorig;
16719 assert(var != NULL);
16722 var->vartrans = vartrans;
16731 assert(var != NULL);
16733 var->vardeltrans = vardeltrans;
16742 assert(var != NULL);
16744 var->varcopy = varcopy;
16753 assert(var != NULL);
16769 assert(var != NULL);
16784 assert(var != NULL);
16794 assert(var != NULL);
16807 assert(var != NULL);
16820 assert(var != NULL);
16830 assert(var != NULL);
16845 assert(var != NULL);
16856 assert(var != NULL);
16866 assert(var != NULL);
16876 assert(var != NULL);
16886 assert(var != NULL);
16898 assert(var != NULL);
16909 assert(var != NULL);
16922 assert(var != NULL);
16932 assert(var != NULL);
16942 assert(var != NULL);
16952 assert(var != NULL);
16962 assert(var != NULL);
16972 assert(var != NULL);
16982 assert(var != NULL);
16993 assert(var != NULL);
17004 assert(var != NULL);
17014 assert(var != NULL);
17025 assert(var != NULL);
17036 assert(var != NULL);
17047 assert(var != NULL);
17059 assert(var != NULL);
17071 assert(var != NULL);
17083 assert(var != NULL);
17095 assert(var != NULL);
17105 assert(var != NULL);
17116 assert(var != NULL);
17127 assert(var != NULL);
17137 assert(var != NULL);
17153 assert(probvar != NULL);
17154 assert(aggrobj != NULL);
17156 while( probvar != NULL )
17225 assert(var != NULL);
17245 assert(var != NULL);
17265 assert(var != NULL);
17279 assert(var != NULL);
17289 assert(var != NULL);
17299 assert(var != NULL);
17309 assert(var != NULL);
17311 if( var->
obj >= 0.0 )
17322 assert(var != NULL);
17324 if( var->
obj >= 0.0 )
17335 assert(var != NULL);
17345 assert(var != NULL);
17355 assert(var != NULL);
17365 assert(var != NULL);
17367 if( var->
obj >= 0.0 )
17378 assert(var != NULL);
17380 if( var->
obj >= 0.0 )
17391 assert(var != NULL);
17393 if( var->
obj >= 0.0 )
17404 assert(var != NULL);
17406 if( var->
obj >= 0.0 )
17417 assert(var != NULL);
17427 assert(var != NULL);
17439 assert(var != NULL);
17451 assert(var != NULL);
17461 assert(var != NULL);
17471 assert(var != NULL);
17483 assert(var != NULL);
17493 assert(var != NULL);
17503 assert(var != NULL);
17513 assert(var != NULL);
17525 assert(var != NULL);
17535 assert(var != NULL);
17545 assert(var != NULL);
17558 assert(var != NULL);
17575 assert(var != NULL);
17590 assert(var != NULL);
17604 assert(var != NULL);
17620 assert(var != NULL);
17632 assert(var != NULL);
17643 assert(var != NULL);
17653 assert(var != NULL);
17666 assert(var != NULL);
17681 assert(pos < var->nlbchginfos);
17701 assert(pos < var->nubchginfos);
17711 assert(var != NULL);
17721 assert(var != NULL);
17731 assert(var != NULL);
17746 assert(var != NULL);
17765 assert(var != NULL);
17766 assert(
set != NULL);
17767 assert(var->
scip == set->scip);
17774 eventtype, var->
name, (
void*)eventhdlr, (
void*)eventdata);
17792 assert(var != NULL);
17793 assert(
set != NULL);
17794 assert(var->
scip == set->scip);
17798 SCIPsetDebugMsg(
set,
"drop event of variable <%s> with handler %p and data %p\n", var->
name, (
void*)eventhdlr,
17811 assert(bdchgidx != NULL);
17813 return bdchgidx->
pos;
17822 assert(bdchgidx1 != NULL);
17823 assert(bdchgidx1->
depth >= -2);
17824 assert(bdchgidx1->
pos >= 0);
17825 assert(bdchgidx2 != NULL);
17826 assert(bdchgidx2->
depth >= -2);
17827 assert(bdchgidx2->
pos >= 0);
17829 return (bdchgidx1->
depth < bdchgidx2->
depth)
17830 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
17842 assert(bdchgidx1 == NULL || bdchgidx1->
depth >= -2);
17843 assert(bdchgidx1 == NULL || bdchgidx1->
pos >= 0);
17844 assert(bdchgidx2 == NULL || bdchgidx2->
depth >= -2);
17845 assert(bdchgidx2 == NULL || bdchgidx2->
pos >= 0);
17847 if( bdchgidx1 == NULL )
17849 else if( bdchgidx2 == NULL )
17852 return (bdchgidx1->
depth < bdchgidx2->
depth)
17853 || (bdchgidx1->
depth == bdchgidx2->
depth && (bdchgidx1->
pos < bdchgidx2->
pos));
17861 assert(bdchginfo != NULL);
17871 assert(bdchginfo != NULL);
17881 assert(bdchginfo != NULL);
17883 return bdchginfo->
var;
17891 assert(bdchginfo != NULL);
17901 assert(bdchginfo != NULL);
17911 assert(bdchginfo != NULL);
17921 assert(bdchginfo != NULL);
17931 assert(bdchginfo != NULL);
17941 assert(bdchginfo != NULL);
17953 assert(bdchginfo != NULL);
17965 assert(bdchginfo != NULL);
17976 assert(bdchginfo != NULL);
17988 assert(bdchginfo != NULL);
18009 assert(bdchginfo != NULL);
18020 assert(bdchginfo != NULL);
18035 assert(bdchginfo1 != NULL);
18036 assert(bdchginfo2 != NULL);
18037 assert(bdchginfo1->
var == bdchginfo2->
var);
enum SCIP_Result SCIP_RESULT
SCIP_Real SCIPhistoryGetAvgConflictlength(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)
void SCIPcliquelistRemoveFromCliques(SCIP_CLIQUELIST *cliquelist, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool irrelevantvar)
static SCIP_Real adjustedUb(SCIP_SET *set, SCIP_VARTYPE vartype, SCIP_Real ub)
SCIP_Real SCIPvarGetAvgConflictlengthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real SCIPvarGetWorstBoundLocal(SCIP_VAR *var)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
void SCIPvarGetClosestVlb(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvlb, int *closestvlbidx)
internal methods for managing events
static SCIP_RETCODE boundchgReleaseData(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_BOUNDTYPE SCIPvarGetWorstBoundType(SCIP_VAR *var)
static void checkImplic(SCIP_SET *set, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *redundant, SCIP_Bool *infeasible)
SCIP_RETCODE SCIPvarIncInferenceSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
SCIP_Bool SCIPvarsHaveCommonClique(SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
SCIP_BRANCHINGDATA branchingdata
void SCIPhistoryIncNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, int depth)
SCIP_VAR ** SCIPcliqueGetVars(SCIP_CLIQUE *clique)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
internal methods for storing primal CIP solutions
void SCIPhistoryIncVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
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 varEventImplAdded(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
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)
SCIP_Real SCIPvarGetBdAtIndex(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)
void SCIPvarMarkNotDeletable(SCIP_VAR *var)
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
SCIP_RETCODE SCIPvarSetNLPSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real solval)
public methods for branching and inference history structure
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
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_EVENTQUEUE *eventqueue, SCIP_Real addobj)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)
SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)
union SCIP_BoundChg::@12 data
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
void SCIPhistoryIncCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
SCIP_Real SCIPvarGetAvgCutoffsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvaluehistoryCreate(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
SCIP_Real SCIPsetFeastol(SCIP_SET *set)
SCIP_Real SCIPvarGetBranchFactor(SCIP_VAR *var)
unsigned int inferboundtype
SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)
static SCIP_RETCODE domchgCreate(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem)
unsigned int boundchgtype
SCIP_BRANCHDIR SCIPvarGetBranchDirection(SCIP_VAR *var)
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_Real SCIPvarGetUbLazy(SCIP_VAR *var)
SCIP_Real SCIPsetFloor(SCIP_SET *set, SCIP_Real val)
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)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
int SCIPvarGetNVlbs(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
#define SCIPsetDuplicateBufferArray(set, ptr, source, num)
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
#define SCIP_DECL_VARTRANS(x)
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)
enum SCIP_BaseStat SCIP_BASESTAT
SCIP_Bool SCIPvarDoNotMultaggr(SCIP_VAR *var)
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)
SCIP_Real SCIPvarGetPseudocostCountCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
methods for implications, variable bounds, and cliques
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_EVENTQUEUE *eventqueue, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
int SCIPvarGetLastBdchgDepth(SCIP_VAR *var)
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_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Real SCIPvarGetAvgBranchdepth(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarGetProbvarBinary(SCIP_VAR **var, SCIP_Bool *negated)
SCIP_RETCODE SCIPdomchgAddHolechg(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST **ptr, SCIP_HOLELIST *newlist, SCIP_HOLELIST *oldlist)
SCIP_Bool SCIPvarIsPscostRelerrorReliable(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
SCIP_Bool SCIPvarIsInitial(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateImplAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_VAR ** SCIPimplicsGetVars(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_RETCODE SCIPvarChgLbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
SCIP_BOUNDCHG * boundchgs
void SCIPhistoryIncInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)
SCIP_Real lastbranchvalue
static SCIP_RETCODE domchgMakeDynamic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
#define SCIPdebugCheckImplic(set, var, varfixing, implvar, impltype, implbound)
#define SCIPsetAllocCleanBufferArray(set, ptr, num)
static SCIP_Real getImplVarRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_RETCODE SCIPeventfilterDel(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPvarChgLbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazylb)
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, int addnlocksdown, int addnlocksup)
SCIP_CLIQUE ** SCIPvarGetCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_RETCODE SCIPprobVarChangedStatus(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
SCIP_Real bestrootredcost
SCIP_Real SCIPvarGetMultaggrLbGlobal(SCIP_VAR *var, SCIP_SET *set)
SCIP_HISTORY * historycrun
SCIP_BRANCHDIR lastbranchdir
SCIP_VALUEHISTORY * SCIPvarGetValuehistory(SCIP_VAR *var)
int SCIPcliquelistGetNCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)
void SCIPvarSetTransData(SCIP_VAR *var, SCIP_DECL_VARTRANS((*vartrans)))
SCIP_RETCODE SCIPvarChgUbOriginal(SCIP_VAR *var, SCIP_SET *set, SCIP_Real newbound)
SCIP_Longint closestvblpcount
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_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)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
static SCIP_RETCODE varEventGholeAdded(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_Real left, SCIP_Real right)
SCIP_VAR ** SCIPvboundsGetVars(SCIP_VBOUNDS *vbounds)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_DOMCHGBOTH domchgboth
SCIP_RETCODE SCIPcolChgObj(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_BDCHGINFO * ubchginfos
SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
SCIP_Bool SCIPvarWasFixedAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Real SCIPvarGetBestBoundLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetRootSol(SCIP_VAR *var)
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_RETCODE SCIPvarMarkDoNotMultaggr(SCIP_VAR *var)
SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)
SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)
static SCIP_RETCODE holelistDuplicate(SCIP_HOLELIST **target, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HOLELIST *source)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
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 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)
void SCIPvaluehistoryScaleVSIDS(SCIP_VALUEHISTORY *valuehistory, SCIP_Real scalar)
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
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_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *aggvar, SCIP_Real scalar, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_HOLELIST * SCIPholelistGetNext(SCIP_HOLELIST *holelist)
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
int SCIPvarGetNBdchgInfosLb(SCIP_VAR *var)
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)
struct SCIP_VarData SCIP_VARDATA
SCIP_RETCODE SCIPdomchgUndo(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
SCIP_RETCODE SCIPboundchgUndo(SCIP_BOUNDCHG *boundchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
void SCIPhistoryReset(SCIP_HISTORY *history)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
static SCIP_RETCODE varEventVarUnlocked(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPvboundsDel(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, SCIP_VAR *vbdvar, SCIP_Bool negativecoef)
static SCIP_Bool useValuehistory(SCIP_VAR *var, SCIP_Real value, SCIP_SET *set)
SCIP_Bool SCIPvarHasImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
static void varSetProbindex(SCIP_VAR *var, int probindex)
SCIP_Real SCIPvarGetAvgConflictlength(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_INFERENCEDATA inferencedata
enum SCIP_Retcode SCIP_RETCODE
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
int SCIPvarGetNVubs(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateUbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)
static SCIP_BDCHGIDX presolvebdchgidx
static void printHolelist(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_HOLELIST *holelist, const char *name)
enum SCIP_Varstatus SCIP_VARSTATUS
#define SCIPsetAllocBufferArray(set, ptr, num)
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)
int SCIPvarGetProbindex(SCIP_VAR *var)
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)
#define SCIP_DECL_VARCOPY(x)
SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
void SCIPvarSetNamePointer(SCIP_VAR *var, const char *name)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
#define SCIP_EVENTTYPE_GLBCHANGED
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_Real SCIPvarGetAggrScalar(SCIP_VAR *var)
void SCIPvarInitSolve(SCIP_VAR *var)
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 GRAPHNODE ** active
SCIP_Real SCIPvarGetInferenceSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
void SCIPvarMarkDeletable(SCIP_VAR *var)
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 SCIPimplicsDel(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetVSIDS(SCIP_HISTORY *history, 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)
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
void SCIPprobUpdateNObjVars(SCIP_PROB *prob, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
SCIP_RETCODE SCIPvarsGetActiveVars(SCIP_SET *set, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)
SCIP_CLIQUE ** SCIPcliquelistGetCliques(SCIP_CLIQUELIST *cliquelist, SCIP_Bool value)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPcliquelistAdd(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_Bool SCIPvarIsDeletable(SCIP_VAR *var)
int SCIPvarGetConflictingBdchgDepth(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real bound)
SCIP_RETCODE SCIPvarUpdatePseudocost(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
#define SCIPsetFreeBufferArray(set, ptr)
SCIP_Longint SCIPvarGetNBranchingsCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarIsRemovable(SCIP_VAR *var)
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
static SCIP_RETCODE domchgEnsureBoundchgsSize(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
#define SCIPdebugCheckVbound(set, var, vbtype, vbvar, vbcoef, vbconstant)
SCIP_RETCODE SCIPvarChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
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_RETCODE SCIPvarRemoveCliquesImplicsVbs(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool irrelevantvar, SCIP_Bool onlyredundant, SCIP_Bool removefromvar)
static SCIP_RETCODE boundchgCaptureData(SCIP_BOUNDCHG *boundchg)
SCIP_Real SCIPsetCeil(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPvarGetRelaxSolTransVar(SCIP_VAR *var)
#define SCIPstatIncrement(stat, set, field)
SCIP_Real SCIPsetGetHugeValue(SCIP_SET *set)
internal methods for LP management
SCIP_BDCHGIDX * SCIPvarGetLastBdchgIndex(SCIP_VAR *var)
int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_Real SCIPvarGetLPSol_rec(SCIP_VAR *var)
SCIP_Real SCIPhistoryGetPseudocost(SCIP_HISTORY *history, SCIP_Real solvaldelta)
static void domMerge(SCIP_DOM *dom, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real *newlb, SCIP_Real *newub)
internal methods for branching and inference history
SCIP_Real SCIPvarGetCutoffSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
int * SCIPvarGetImplIds(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_HOLELIST * SCIPvarGetHolelistOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateObjChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldobj, SCIP_Real newobj)
internal methods for collecting primal CIP solutions and primal informations
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
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 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)
SCIP_DECL_HASHKEYVAL(SCIPvarGetHashkeyVal)
#define SCIP_EVENTTYPE_LBCHANGED
SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)
#define SCIP_DECL_VARDELTRANS(x)
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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_HISTORY * glbhistorycrun
internal methods for propagators
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
const char * SCIPgetProbName(SCIP *scip)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
SCIP_Real SCIPvarGetVSIDSCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
void SCIPhistoryScaleVSIDS(SCIP_HISTORY *history, SCIP_Real scalar)
enum SCIP_BranchDir SCIP_BRANCHDIR
SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *nominator, SCIP_Longint *denominator)
SCIP_Real SCIPvarGetNLPSol_rec(SCIP_VAR *var)
int SCIPvarGetNBdchgInfosUb(SCIP_VAR *var)
void SCIPcliquelistFree(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem)
SCIP_Real conflictrelaxedub
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)
unsigned int inferboundtype
SCIP_RETCODE SCIPeventCreateVarFixed(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
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_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)
SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)
SCIP_RETCODE SCIPvaluehistoryFind(SCIP_VALUEHISTORY *valuehistory, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real value, SCIP_HISTORY **history)
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, SCIP_VARTYPE vartype)
SCIP_Real SCIPvarGetBestRootLPObjval(SCIP_VAR *var)
void SCIPvarSetHistory(SCIP_VAR *var, SCIP_HISTORY *history, SCIP_STAT *stat)
static SCIP_RETCODE varProcessChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
SCIP_Real SCIPhistoryGetPseudocostVariance(SCIP_HISTORY *history, SCIP_BRANCHDIR direction)
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
SCIP_RETCODE SCIPstatUpdateVarRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_VAR *var, SCIP_Real oldrootpscostscore)
void SCIPvaluehistoryFree(SCIP_VALUEHISTORY **valuehistory, BMS_BLKMEM *blkmem)
SCIP_Real conflictrelaxedlb
void SCIPvarSetDelorigData(SCIP_VAR *var, SCIP_DECL_VARDELORIG((*vardelorig)))
enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
SCIP_RETCODE SCIPvarChgBranchPriority(SCIP_VAR *var, int branchpriority)
SCIP_Real SCIPvarGetPseudocost(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
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 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 SCIPeventfilterAdd(SCIP_EVENTFILTER *eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
void SCIPvarSetDeltransData(SCIP_VAR *var, SCIP_DECL_VARDELTRANS((*vardeltrans)))
SCIP_RETCODE SCIPvarChgUbLazy(SCIP_VAR *var, SCIP_SET *set, SCIP_Real lazyub)
SCIP_Real SCIPvarGetBestBoundGlobal(SCIP_VAR *var)
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)
void SCIPvarMergeHistories(SCIP_VAR *targetvar, SCIP_VAR *othervar, SCIP_STAT *stat)
void SCIPhistoryIncNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real length)
SCIP_BOUNDTYPE * SCIPimplicsGetTypes(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
internal methods for storing and manipulating the main problem
SCIP_Bool SCIPboundchgIsRedundant(SCIP_BOUNDCHG *boundchg)
void SCIPlpDecNLoosevars(SCIP_LP *lp)
SCIP_Real SCIPvarGetLbOriginal(SCIP_VAR *var)
void SCIPcliqueDelVar(SCIP_CLIQUE *clique, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Bool value)
SCIP_RETCODE SCIPdomchgMakeStatic(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPdomchgFree(SCIP_DOMCHG **domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
static SCIP_BDCHGIDX initbdchgidx
SCIP_Bool SCIPvarPscostThresholdProbabilityTest(SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
static SCIP_RETCODE varEnsureUbchginfosSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Bool SCIPimplicsContainsImpl(SCIP_IMPLICS *implics, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype)
SCIP_Bool SCIPbdchgidxIsEarlierNonNull(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)
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 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)
int SCIPvarCompareActiveAndNegated(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Real SCIPvarGetAvgBranchdepthCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Real SCIPvarGetUbOriginal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_Real SCIPhistoryGetAvgBranchdepth(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real bestrootlpobjval
SCIPInterval sqrt(const SCIPInterval &x)
SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)
SCIP_DECL_SORTPTRCOMP(SCIPvarCompActiveAndNegated)
SCIP_Real SCIPvarGetPseudocostCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_Real solvaldelta)
SCIP_Real SCIPvarGetUbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPsortedvecFindPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), void *val, int len, int *pos)
void SCIPstrCopySection(const char *str, char startchar, char endchar, char *token, int size, char **endptr)
SCIP_Bool SCIPvarHasBinaryImplic(SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_Bool implvarfixing)
SCIP_RETCODE SCIPvarGetTransformed(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **transvar)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)
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)
static SCIP_RETCODE varSetName(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_STAT *stat, const char *name)
SCIP_Real SCIPvarGetAggrConstant(SCIP_VAR *var)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
struct SCIP_EventData SCIP_EVENTDATA
const char * SCIPvarGetName(SCIP_VAR *var)
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_Real SCIPsetFeasCeil(SCIP_SET *set, SCIP_Real val)
void SCIPhistoryUnite(SCIP_HISTORY *history, SCIP_HISTORY *addhistory, SCIP_Bool switcheddirs)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
#define SCIPsetReallocBufferArray(set, ptr, num)
SCIP_Longint SCIPhistoryGetNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPeventCreateLbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
SCIP_DECL_HASHGETKEY(SCIPvarGetHashkey)
void SCIPvarGetClosestVub(SCIP_VAR *var, SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *closestvub, int *closestvubidx)
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set)
static SCIP_RETCODE holelistCreate(SCIP_HOLELIST **holelist, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
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)
SCIP_RETCODE SCIPvarSetRelaxSol(SCIP_VAR *var, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_Real solval, SCIP_Bool updateobj)
SCIP_HISTORY * glbhistory
SCIP_Real SCIPboundchgGetNewbound(SCIP_BOUNDCHG *boundchg)
SCIP_Real * SCIPvboundsGetCoefs(SCIP_VBOUNDS *vbounds)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
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_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_HOLELIST * SCIPvarGetHolelistGlobal(SCIP_VAR *var)
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_Longint SCIPvarGetNActiveConflicts(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
internal methods for global SCIP settings
SCIP_RETCODE SCIPvarGetAggregatedObj(SCIP_VAR *var, SCIP_Real *aggrobj)
SCIP_Real SCIPvarCalcPscostConfidenceBound(SCIP_VAR *var, SCIP_SET *set, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetLbLazy(SCIP_VAR *var)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)
SCIP_RETCODE SCIPvarIncNBranchings(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, int depth)
SCIP_Real SCIPvarGetMultaggrConstant(SCIP_VAR *var)
int SCIPprobGetNContVars(SCIP_PROB *prob)
SCIP_Real SCIPvarGetPseudocostCount(SCIP_VAR *var, SCIP_BRANCHDIR dir)
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)
static SCIP_VAR * varGetActiveVar(SCIP_VAR *var)
SCIP_Real * SCIPvboundsGetConstants(SCIP_VBOUNDS *vbounds)
SCIP_Real SCIPvarGetCutoffSum(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)
internal methods for relaxators
SCIP_Real SCIPvarGetMinPseudocostScore(SCIP_VAR *var, SCIP_STAT *stat, SCIP_SET *set, SCIP_Real solval)
SCIP_Real SCIPhistoryGetPseudocostCount(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE varProcessChgBranchPriority(SCIP_VAR *var, int branchpriority)
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)
#define SCIPdebugCheckLbGlobal(scip, var, lb)
SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)
SCIP_Longint SCIPvarGetNActiveConflictsCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarPrint(SCIP_VAR *var, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
unsigned int branchdirection
SCIP_Bool SCIPcliquelistsHaveCommonClique(SCIP_CLIQUELIST *cliquelist1, SCIP_Bool value1, SCIP_CLIQUELIST *cliquelist2, SCIP_Bool value2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
#define SCIP_EVENTTYPE_UBCHANGED
void SCIPvboundsShrink(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem, int newnvbds)
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
void SCIPvarAdjustBd(SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_Real *bd)
#define BMSfreeBlockMemory(mem, ptr)
data structures and methods for collecting reoptimization information
internal methods for problem variables
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
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)
SCIP_RETCODE SCIPvarChgBranchFactor(SCIP_VAR *var, SCIP_SET *set, SCIP_Real branchfactor)
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_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_BOUNDTYPE * SCIPvarGetImplTypes(SCIP_VAR *var, SCIP_Bool varfixing)
unsigned int boundchgtype
#define BMSfreeBlockMemorySize(mem, ptr, size)
SCIP_RETCODE SCIPvarIncCutoffSum(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)
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)
SCIP_INFERENCEDATA inferencedata
SCIP_Real SCIPholelistGetRight(SCIP_HOLELIST *holelist)
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)
void SCIPvarCapture(SCIP_VAR *var)
#define BMSreallocBlockMemorySize(mem, ptr, oldsize, newsize)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)
enum SCIP_Objsense SCIP_OBJSENSE
SCIP_Bool SCIPvarWasFixedEarlier(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Real SCIPvarGetInferenceSumCurrentRun(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
int SCIPvarGetBranchPriority(SCIP_VAR *var)
int SCIPgetDepth(SCIP *scip)
SCIP_Real SCIPvarGetLbAtIndex(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvarGetNImpls(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
SCIP_RETCODE SCIPeventCreateGlbChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
int * SCIPimplicsGetIds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_VARDATA * SCIPvarGetData(SCIP_VAR *var)
SCIP_RETCODE SCIPcolChgLb(SCIP_COL *col, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newlb)
int SCIPvarGetNLocksUp(SCIP_VAR *var)
SCIP_Bool SCIPstrToRealValue(const char *str, SCIP_Real *value, char **endptr)
int SCIPimplicsGetNImpls(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
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_VAR * SCIPboundchgGetVar(SCIP_BOUNDCHG *boundchg)
int SCIPvarCompare(SCIP_VAR *var1, SCIP_VAR *var2)
SCIP_Bool * SCIPcliqueGetValues(SCIP_CLIQUE *clique)
SCIP_BOUNDCHG * SCIPdomchgGetBoundchg(SCIP_DOMCHG *domchg, int pos)
SCIP_Real SCIPvarGetUnchangedObj(SCIP_VAR *var)
static SCIP_RETCODE varAddParent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *parentvar)
SCIP_Real SCIPvarGetMultaggrUbGlobal(SCIP_VAR *var, SCIP_SET *set)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_RETCODE SCIPvarAddCliqueToList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetBestRootRedcost(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetAggrVar(SCIP_VAR *var)
SCIP_Real SCIPvarGetAvgInferencesCurrentRun(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
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_Real SCIPcomputeTwoSampleTTestValue(SCIP_Real meanx, SCIP_Real meany, SCIP_Real variancex, SCIP_Real variancey, SCIP_Real countx, SCIP_Real county)
SCIP_RETCODE SCIPvarDelClique(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool value, SCIP_CLIQUE *clique)
#define SCIP_EVENTTYPE_GHOLEADDED
#define BMScopyMemoryArray(ptr, source, num)
void SCIPhistoryUpdatePseudocost(SCIP_HISTORY *history, SCIP_SET *set, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
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)
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 SCIPvarGetRelaxSol(SCIP_VAR *var, SCIP_SET *set)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_Longint SCIPhistoryGetNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real * SCIPvarGetImplBounds(SCIP_VAR *var, SCIP_Bool varfixing)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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)
static SCIP_Real adjustedLb(SCIP_SET *set, SCIP_VARTYPE vartype, SCIP_Real lb)
SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)
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)
SCIP_NODE * SCIPgetFocusNode(SCIP *scip)
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_EVENTFILTER * eventfilter
static SCIP_Real SCIPvarGetPseudoSol_rec(SCIP_VAR *var)
SCIP_BDCHGINFO * SCIPvarGetLbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_BDCHGINFO * SCIPvarGetUbchgInfo(SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
int SCIPvboundsGetNVbds(SCIP_VBOUNDS *vbounds)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
static SCIP_RETCODE parseValue(SCIP_SET *set, const char *str, SCIP_Real *value, char **endptr)
SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)
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_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_VALUEHISTORY * valuehistory
static void printBounds(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file, SCIP_Real lb, SCIP_Real ub, const char *name)
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)
#define SCIP_DECL_VARDELORIG(x)
SCIP_Real SCIPhistoryGetCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
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_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
static SCIP_RETCODE varEventVarFixed(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, int fixeventtype)
SCIP_BRANCHDIR SCIPbranchdirOpposite(SCIP_BRANCHDIR dir)
SCIP_VAR ** SCIPvarGetImplVars(SCIP_VAR *var, SCIP_Bool varfixing)
static SCIP_RETCODE varFreeParents(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
SCIP_DOMCHGBOUND domchgbound
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)
#define SCIP_DEFAULT_INFINITY
static SCIP_RETCODE domchgEnsureHolechgsSize(SCIP_DOMCHG *domchg, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
int SCIPvarGetNLocksDown(SCIP_VAR *var)
SCIP_Real SCIPstudentTGetCriticalValue(SCIP_CONFIDENCELEVEL clevel, int df)
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_Real SCIPhistoryGetInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
#define BMSallocBlockMemorySize(mem, ptr, size)
#define SCIPsetFreeCleanBufferArray(set, ptr)
void SCIPrelaxationSolObjAdd(SCIP_RELAXATION *relaxation, SCIP_Real val)
static const SCIP_Real scalars[]
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)
SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)
int SCIPdomchgGetNBoundchgs(SCIP_DOMCHG *domchg)
SCIP_RETCODE SCIPvarColumn(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
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)
int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
#define SCIP_EVENTTYPE_FORMAT
SCIP_MESSAGEHDLR * messagehdlr
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_Real SCIPnormalCDF(SCIP_Real mean, SCIP_Real variance, SCIP_Real value)
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)
SCIP_DECL_HASHKEYEQ(SCIPvarIsHashkeyEq)
SCIP_Real SCIPvarGetBestRootSol(SCIP_VAR *var)
public methods for message output
void SCIPcliquelistCheck(SCIP_CLIQUELIST *cliquelist, SCIP_VAR *var)
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
void SCIPvarSetCopyData(SCIP_VAR *var, SCIP_DECL_VARCOPY((*varcopy)))
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_Real SCIPholelistGetLeft(SCIP_HOLELIST *holelist)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
static void holelistFree(SCIP_HOLELIST **holelist, BMS_BLKMEM *blkmem)
static SCIP_RETCODE varEnsureLbchginfosSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
static SCIP_RETCODE domAddHole(SCIP_DOM *dom, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right, SCIP_Bool *added)
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)
internal methods for problem statistics
#define SCIP_EVENTTYPE_VARCHANGED
static SCIP_RETCODE varFree(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
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_Longint SCIPvarGetNBranchings(SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarsGetProbvarBinary(SCIP_VAR ***vars, SCIP_Bool **negatedarr, int nvars)
SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPsetIsFeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_CLIQUELIST * cliquelist
SCIP_RETCODE SCIPvarSetInitial(SCIP_VAR *var, SCIP_Bool initial)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPvarGetProbvarHole(SCIP_VAR **var, SCIP_Real *left, SCIP_Real *right)
SCIP_RETCODE SCIPlpUpdateVarLoose(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_Real SCIPvarGetVSIDS(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
internal methods for constraints and constraint handlers
SCIP_RETCODE SCIPeventCreateGholeAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real left, SCIP_Real right)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
int SCIPvarGetNUses(SCIP_VAR *var)
void SCIPvarsGetProbvar(SCIP_VAR **vars, int nvars)
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)
static SCIP_RETCODE parseBounds(SCIP_SET *set, const char *str, char *type, SCIP_Real *lb, SCIP_Real *ub, char **endptr)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateVarUnlocked(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPprimalUpdateObjoffset(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
unsigned int donotmultaggr
SCIP_BOUNDTYPE SCIPvarGetBestBoundType(SCIP_VAR *var)
SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPsetIsDualfeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPvarGetAvgSol(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
static SCIP_RETCODE varEnsureParentvarsSize(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)
SCIP_Real SCIPvarGetAvgCutoffs(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
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_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetMultaggrUbLocal(SCIP_VAR *var, SCIP_SET *set)
SCIP_RETCODE SCIPvarChgName(SCIP_VAR *var, BMS_BLKMEM *blkmem, const char *name)
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
enum SCIP_Vartype SCIP_VARTYPE
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_Bool collectvarhistory
SCIP_Bool SCIPvarIsMarkedDeleteGlobalStructures(SCIP_VAR *var)
SCIP_Bool SCIPcliqueIsCleanedUp(SCIP_CLIQUE *clique)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
int SCIPcliqueGetNVars(SCIP_CLIQUE *clique)
SCIP_RETCODE SCIPvarAddHoleOriginal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_Real left, SCIP_Real right)
void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
static void varIncRootboundchgs(SCIP_VAR *var, SCIP_SET *set, SCIP_STAT *stat)
#define BMSallocBlockMemory(mem, ptr)
SCIP_HOLELIST * SCIPvarGetHolelistLocal(SCIP_VAR *var)
unsigned int delglobalstructs
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPvarDropEvent(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Bool SCIPeventqueueIsDelayed(SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPhashmapInsert(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPlpUpdateVarColumn(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPvarSetRemovable(SCIP_VAR *var, SCIP_Bool removable)
SCIP_Real SCIPvarGetVSIDS_rec(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
struct BMS_BlkMem BMS_BLKMEM
SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)
#define SCIP_EVENTTYPE_GUBCHANGED
#define SCIP_CALL_ABORT(x)
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
enum SCIP_BoundchgType SCIP_BOUNDCHGTYPE
SCIP_Real * SCIPimplicsGetBounds(SCIP_IMPLICS *implics, SCIP_Bool varfixing)
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateGubChanged(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real oldbound, SCIP_Real newbound)
void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
SCIP_Real SCIPvarGetMultaggrLbLocal(SCIP_VAR *var, SCIP_SET *set)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
void SCIPvboundsFree(SCIP_VBOUNDS **vbounds, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPvarsAddClique(SCIP_VAR **vars, SCIP_Bool *values, int nvars, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CLIQUE *clique)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
SCIP_BOUNDCHG * boundchgs
void SCIPvarMarkDeleted(SCIP_VAR *var)
void SCIPvarSetData(SCIP_VAR *var, SCIP_VARDATA *vardata)
SCIP_Bool SCIPcolIsInLP(SCIP_COL *col)
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
SCIP_Longint SCIPcalcSmaComMul(SCIP_Longint val1, SCIP_Longint val2)
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_Bool SCIPvarMayRoundUp(SCIP_VAR *var)
void SCIPimplicsFree(SCIP_IMPLICS **implics, BMS_BLKMEM *blkmem)
static SCIP_RETCODE varProcessChgBranchDirection(SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
SCIP_Bool SCIPvarMayRoundDown(SCIP_VAR *var)
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_Bool SCIPsetIsFeasNegative(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPvarGetPseudocostVariance(SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_BDCHGINFO * lbchginfos
static SCIP_RETCODE findValuehistoryEntry(SCIP_VAR *var, SCIP_Real value, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_HISTORY **history)
SCIP_RETCODE SCIPcliquelistDel(SCIP_CLIQUELIST **cliquelist, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_RETCODE SCIProwAddConstant(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real addval)
void SCIPvarMarkDeleteGlobalStructures(SCIP_VAR *var)
SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_RETCODE SCIPvarDelCliqueFromList(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_Bool value, SCIP_CLIQUE *clique)