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;
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);
932 assert(boundchg !=
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);
1591 SCIPsetDebugMsg(
set,
"deleting variable bound: <%s> == %u ==> <%s> <= %g\n",
1603 SCIPsetDebugMsg(
set,
"deleting variable bound: <%s> == %u ==> <%s> >= %g\n",
1612 varfixing = !varfixing;
1614 while( varfixing ==
TRUE );
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];
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",
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];
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;
1975 (*var)->clqcomponentidx = -1;
1984 (*var)->valuehistory =
NULL;
2011 assert(var !=
NULL);
2012 assert(blkmem !=
NULL);
2013 assert(stat !=
NULL);
2016 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2017 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2021 (*var)->data.original.origdom.holelist =
NULL;
2022 (*var)->data.original.origdom.lb = lb;
2023 (*var)->data.original.origdom.ub = ub;
2024 (*var)->data.original.transvar =
NULL;
2054 assert(var !=
NULL);
2055 assert(blkmem !=
NULL);
2058 SCIP_CALL(
varCreate(var, blkmem,
set, stat, name, lb, ub, obj, vartype, initial, removable,
2059 varcopy, vardelorig, vartrans, vardeltrans, vardata) );
2096 assert(
set !=
NULL);
2097 assert(blkmem !=
NULL);
2098 assert(stat !=
NULL);
2099 assert(sourcescip !=
NULL);
2100 assert(sourcevar !=
NULL);
2101 assert(var !=
NULL);
2103 assert(varmap !=
NULL);
2104 assert(consmap !=
NULL);
2129 assert(*var !=
NULL);
2141 SCIP_CALL( sourcevar->varcopy(set->scip, sourcescip, sourcevar, sourcevar->
vardata,
2142 varmap, consmap, (*var), &targetdata, &result) );
2147 SCIPerrorMessage(
"variable data copying method returned invalid result <%d>\n", result);
2156 (*var)->varcopy = sourcevar->varcopy;
2157 (*var)->vardelorig = sourcevar->vardelorig;
2158 (*var)->vartrans = sourcevar->vartrans;
2159 (*var)->vardeltrans = sourcevar->vardeltrans;
2165 if( set->history_allowtransfer )
2175 (*var)->varcopy = sourcevar->varcopy;
2176 (*var)->vardelorig = sourcevar->vardelorig;
2177 (*var)->vartrans = sourcevar->vartrans;
2178 (*var)->vardeltrans = sourcevar->vardeltrans;
2197 if( strncmp(str,
"+inf", 4) == 0 )
2200 (*endptr) = (
char*)str + 4;
2202 else if( strncmp(str,
"-inf", 4) == 0 )
2205 (*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);
2632 (*var)->negatedvar =
NULL;
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);
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);
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) );
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) );
3782 assert(
set !=
NULL);
3783 assert(nvars !=
NULL);
3784 assert(scalars !=
NULL || *nvars == 0);
3785 assert(constant !=
NULL);
3786 assert(requiredsize !=
NULL);
3787 assert(*nvars <= varssize);
3794 assert(vars !=
NULL);
3805 activeconstant = 0.0;
3806 activeconstantinf =
FALSE;
3807 activevarssize = (*nvars) * 2;
3809 tmpvarssize = *nvars;
3824 for( v = ntmpvars - 1; v >= 0; --v )
3827 scalar = tmpscalars[v];
3829 assert(var !=
NULL);
3835 assert(var !=
NULL);
3848 tmpscalars[v] = scalar;
3850 noldtmpvars = ntmpvars;
3854 for( v = ntmpvars - 1; v > 0; --v )
3859 tmpscalars[v - 1] += tmpscalars[v];
3861 tmpvars[v] = tmpvars[ntmpvars];
3862 tmpscalars[v] = tmpscalars[ntmpvars];
3866 if( noldtmpvars > ntmpvars )
3870 while( ntmpvars >= 1 )
3874 var = tmpvars[ntmpvars];
3875 scalar = tmpscalars[ntmpvars];
3877 assert(var !=
NULL);
3893 if( nactivevars >= activevarssize )
3895 activevarssize *= 2;
3898 assert(nactivevars < activevarssize);
3900 activevars[nactivevars] = var;
3901 activescalars[nactivevars] = scalar;
3911 if( nmultvars + ntmpvars > tmpvarssize )
3913 while( nmultvars + ntmpvars > tmpvarssize )
3917 assert(nmultvars + ntmpvars <= tmpvarssize);
3920 if( nmultvars > tmpvarssize2 )
3922 while( nmultvars > tmpvarssize2 )
3926 assert(nmultvars <= tmpvarssize2);
3931 for( ; nmultvars >= 0; --nmultvars )
3933 multvar = multvars[nmultvars];
3934 multscalar = multscalars[nmultvars];
3937 assert(multvar !=
NULL);
3939 assert(multvar !=
NULL);
3946 if( !activeconstantinf )
3952 assert(scalar != 0.0);
3953 if( scalar * multconstant > 0.0 )
3956 activeconstantinf =
TRUE;
3961 activeconstantinf =
TRUE;
3965 activeconstant += scalar * multconstant;
3970 assert(!
SCIPsetIsInfinity(
set, activeconstant) || !(scalar * multconstant < 0.0 &&
3972 assert(!
SCIPsetIsInfinity(
set, -activeconstant) || !(scalar * multconstant > 0.0 &&
3980 tmpscalars[pos] += scalar * multscalar;
3984 tmpvars2[ntmpvars2] = multvar;
3985 tmpscalars2[ntmpvars2] = scalar * multscalar;
3987 assert(ntmpvars2 <= tmpvarssize2);
3992 SCIPsortPtrReal((
void**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);
3993 for( v = ntmpvars2 - 1; v > 0; --v )
3998 tmpscalars2[v - 1] += tmpscalars2[v];
4000 tmpvars2[v] = tmpvars2[ntmpvars2];
4001 tmpscalars2[v] = tmpscalars2[ntmpvars2];
4005 for( v = 0; v < ntmpvars2; ++v )
4007 tmpvars[ntmpvars] = tmpvars2[v];
4008 tmpscalars[ntmpvars] = tmpscalars2[v];
4010 assert(ntmpvars <= tmpvarssize);
4014 if( !activeconstantinf )
4022 assert(scalar != 0.0);
4023 if( scalar * multconstant > 0.0 )
4026 activeconstantinf =
TRUE;
4031 activeconstantinf =
TRUE;
4035 activeconstant += scalar * multconstant;
4041 assert(!
SCIPsetIsInfinity(
set, activeconstant) || !(scalar * multconstant < 0.0 &&
4043 assert(!
SCIPsetIsInfinity(
set, -activeconstant) || !(scalar * multconstant > 0.0 &&
4062 if( mergemultiples )
4065 SCIPsortPtrReal((
void**)activevars, activescalars, SCIPvarComp, nactivevars);
4068 v = nactivevars - 1;
4074 if( activescalars[v - 1] + activescalars[v] != 0.0 )
4076 activescalars[v - 1] += activescalars[v];
4078 activevars[v] = activevars[nactivevars];
4079 activescalars[v] = activescalars[nactivevars];
4084 activevars[v] = activevars[nactivevars];
4085 activescalars[v] = activescalars[nactivevars];
4088 activevars[v] = activevars[nactivevars];
4089 activescalars[v] = activescalars[nactivevars];
4095 *requiredsize = nactivevars;
4097 if( varssize >= *requiredsize )
4099 assert(vars !=
NULL);
4101 *nvars = *requiredsize;
4106 if( activeconstantinf )
4107 (*constant) = activeconstant;
4109 (*constant) += activeconstant;
4120 for( v = 0; v < *nvars; ++v )
4122 vars[v] = activevars[v];
4123 scalars[v] = activescalars[v];
4151 int multrequiredsize;
4153 assert( var !=
NULL );
4155 assert(var->
scip == set->scip);
4163 if( multrequiredsize > multvarssize )
4167 multvarssize = multrequiredsize;
4169 assert( multrequiredsize <= multvarssize );
4258 assert(var !=
NULL);
4259 assert(var->
scip == set->scip);
4260 assert(aggvar !=
NULL);
4262 assert(infeasible !=
NULL);
4263 assert(fixed !=
NULL);
4265 *infeasible =
FALSE;
4268 SCIPsetDebugMsg(
set,
"updating bounds of variables in aggregation <%s> == %g*<%s> %+g\n", var->
name, scalar, aggvar->
name, constant);
4275 aggvarbdschanged =
FALSE;
4283 varlb = aggvar->
glbdom.
lb * scalar + constant;
4287 varub = aggvar->
glbdom.
ub * scalar + constant;
4294 varub = aggvar->
glbdom.
lb * scalar + constant;
4298 varlb = aggvar->
glbdom.
ub * scalar + constant;
4315 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4316 eventqueue, cliquetable, varlb, infeasible, fixed) );
4317 if( !(*infeasible) )
4321 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4322 eventqueue, cliquetable, (varlb-constant)/scalar, infeasible, &aggfixed) );
4323 assert(*fixed == aggfixed);
4348 aggvarlb = (var->
glbdom.
lb - constant) / scalar;
4352 aggvarub = (var->
glbdom.
ub - constant) / scalar;
4359 aggvarub = (var->
glbdom.
lb - constant) / scalar;
4363 aggvarlb = (var->
glbdom.
ub - constant) / scalar;
4380 SCIP_CALL(
SCIPvarFix(aggvar, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4381 eventqueue, cliquetable, aggvarlb, infeasible, fixed) );
4382 if( !(*infeasible) )
4386 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4387 eventqueue, cliquetable, aggvarlb * scalar + constant, infeasible, &varfixed) );
4388 assert(*fixed == varfixed);
4412 while( aggvarbdschanged );
4455 assert(var !=
NULL);
4456 assert(aggvar !=
NULL);
4457 assert(var->
scip == set->scip);
4462 assert(infeasible !=
NULL);
4463 assert(aggregated !=
NULL);
4465 *infeasible =
FALSE;
4466 *aggregated =
FALSE;
4474 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventqueue,
4475 cliquetable, constant, infeasible, aggregated) );
4503 SCIP_CALL(
SCIPvarFix(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,
4504 eventqueue, cliquetable, constant/(1.0-scalar), infeasible, aggregated) );
4510 SCIP_CALL(
varUpdateAggregationBounds(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp,
4511 branchcand, eventqueue, cliquetable, aggvar, scalar, constant, infeasible, &fixed) );
4512 if( *infeasible || fixed )
4514 *aggregated = fixed;
4584 for( i = 0; i < nvbds && !(*infeasible); ++i )
4586 SCIP_CALL(
SCIPvarAddVlb(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4587 eventqueue, vars[i], coefs[i], constants[i],
FALSE, infeasible,
NULL) );
4596 for( i = 0; i < nvbds && !(*infeasible); ++i )
4598 SCIP_CALL(
SCIPvarAddVub(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,
4599 eventqueue, vars[i], coefs[i], constants[i],
FALSE, infeasible,
NULL) );
4612 for( i = 0; i < 2; ++i )
4624 for( j = 0; j < nimpls && !(*infeasible); ++j )
4629 SCIP_CALL(
SCIPvarAddImplic(var, blkmem,
set, stat, transprob, origprob, tree, reopt, lp, cliquetable,
4630 branchcand, eventqueue, (
SCIP_Bool)i, implvars[j], impltypes[j], implbounds[j],
FALSE, infeasible,
4696 SCIP_CALL(
SCIPvarAddObj(var, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, eventqueue, obj) );
4754 #define MAXDNOM 1000000LL 4756 assert(
set !=
NULL);
4757 assert(blkmem !=
NULL);
4758 assert(stat !=
NULL);
4759 assert(transprob !=
NULL);
4760 assert(origprob !=
NULL);
4761 assert(tree !=
NULL);
4763 assert(cliquetable !=
NULL);
4764 assert(branchcand !=
NULL);
4765 assert(eventqueue !=
NULL);
4766 assert(varx !=
NULL);
4767 assert(vary !=
NULL);
4768 assert(varx != vary);
4769 assert(infeasible !=
NULL);
4770 assert(aggregated !=
NULL);
4779 *infeasible =
FALSE;
4780 *aggregated =
FALSE;
4788 assert(scalarxd >= 1);
4789 assert(scalaryd >= 1);
4793 a = (scm/scalarxd)*scalarxn;
4794 b = (scm/scalaryd)*scalaryn;
4818 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4819 branchcand, eventqueue, vary, (
SCIP_Real)(-b/a), (
SCIP_Real)(c/a), infeasible, aggregated) );
4820 assert(*aggregated);
4827 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4828 branchcand, eventqueue, varx, (
SCIP_Real)(-a/b), (
SCIP_Real)(c/b), infeasible, aggregated) );
4829 assert(*aggregated);
4860 if( currentclass < 0 )
4862 assert(0 <= currentclass && currentclass < a);
4868 assert(0 <= classstep && classstep < a);
4870 while( currentclass != 0 )
4872 assert(0 <= currentclass && currentclass < a);
4873 currentclass += classstep;
4874 if( currentclass >= a )
4879 assert(((c - b*ysol)%a) == 0);
4881 xsol = (c - b*ysol)/a;
4906 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4907 branchcand, eventqueue, aggvar, (
SCIP_Real)(-b), (
SCIP_Real)xsol, infeasible, aggregated) );
4908 assert(*aggregated || *infeasible);
4910 if( !(*infeasible) )
4912 SCIP_CALL(
SCIPvarAggregate(vary, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
4913 branchcand, eventqueue, aggvar, (
SCIP_Real)a, (
SCIP_Real)ysol, infeasible, aggregated) );
4914 assert(*aggregated || *infeasible);
4963 assert(
set !=
NULL);
4964 assert(blkmem !=
NULL);
4965 assert(stat !=
NULL);
4966 assert(transprob !=
NULL);
4967 assert(origprob !=
NULL);
4968 assert(tree !=
NULL);
4970 assert(cliquetable !=
NULL);
4971 assert(branchcand !=
NULL);
4972 assert(eventqueue !=
NULL);
4973 assert(varx !=
NULL);
4974 assert(vary !=
NULL);
4975 assert(varx != vary);
4976 assert(infeasible !=
NULL);
4977 assert(aggregated !=
NULL);
4984 *infeasible =
FALSE;
4985 *aggregated =
FALSE;
4987 absquot =
REALABS(scalarx / scalary);
4989 maxscalar =
MAX(maxscalar, 1.0);
4991 if( absquot > maxscalar || absquot < 1 / maxscalar )
5065 scalar = -scalary/scalarx;
5066 constant = rhs/scalarx;
5083 SCIP_CALL(
SCIPvarAggregate(varx, blkmem,
set, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5084 branchcand, eventqueue, vary, scalar, constant, infeasible, aggregated) );
5085 assert(*aggregated || *infeasible);
5091 SCIP_CALL(
tryAggregateIntVars(
set, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,
5092 branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );