RetroSearch Browse

)

115 for

( i = 1; i < size; ++i )

124 char

* closepar =

;

125#ifndef DEBUGUSES_NOADDR2LINE 126

openpar = strchr(strings[i],

'('

);

127 if

( openpar !=

&& openpar[1] ==

'+'

)

128

closepar = strchr(openpar+2,

')'

);

130 if

( closepar !=

)

133

(void)

SCIPsnprintf

(cmd,

SCIP_MAXSTRLEN

"addr2line -f -p -e \"%.*s\" %.*s"

, openpar - strings[i], strings[i], closepar-openpar-1, openpar+1);

139

printf(

" %s\n"

, strings[i]);

160

assert(holelist !=

);

161

assert(blkmem !=

);

164 SCIPsetDebugMsg

(

"create hole list element (%.15g,%.15g) in blkmem %p\n"

, left, right, (

void

*)blkmem);

167

(*holelist)->hole.left = left;

168

(*holelist)->hole.right = right;

169

(*holelist)->next =

;

181

assert(holelist !=

);

182

assert(blkmem !=

);

184 while

( *holelist !=

)

189

(*holelist)->hole.left, (*holelist)->hole.right, (

void

*)blkmem);

191

next = (*holelist)->

;

193

assert(*holelist ==

);

197

assert(*holelist ==

);

209

assert(target !=

);

211 while

( source !=

)

215

source = source->

;

216

target = &(*target)->

;

236

assert(dom !=

);

237

assert(added !=

);

241 while

( *insertpos !=

&& (*insertpos)->hole.left < left )

242

insertpos = &(*insertpos)->

;

245 if

( *insertpos !=

&& (*insertpos)->hole.left == left && (*insertpos)->hole.right >= right )

247 SCIPsetDebugMsg

(

"new hole (%.15g,%.15g) is redundant through known hole (%.15g,%.15g)\n"

248

left, right, (*insertpos)->hole.left, (*insertpos)->hole.right);

258

(*insertpos)->next = next;

280

assert(dom !=

);

292 while

( *holelistptr !=

)

294 if

( (*holelistptr)->next !=

)

296

assert(

SCIPsetIsLE

(

, lastleft, (*holelistptr)->hole.left) );

297

lastleft = (*holelistptr)->hole.left;

300

holelistptr = &(*holelistptr)->

;

308

lastrightptr = &dom->

;

309

lastnextptr = holelistptr;

311 while

( *holelistptr !=

)

313 SCIPsetDebugMsg

(

"check hole (%.15g,%.15g) last right interval was <%.15g>\n"

, (*holelistptr)->hole.left, (*holelistptr)->hole.right, *lastrightptr);

316

assert(

SCIPsetIsLT

(

, (*holelistptr)->hole.left, (*holelistptr)->hole.right));

321 SCIPsetDebugMsg

(

"remove remaining hole since upper bound <%.15g> is less then the left hand side of the current hole\n"

, dom->

);

323

assert(*holelistptr ==

);

326

*lastnextptr =

;

331 SCIPsetDebugMsg

(

"upper bound <%.15g> lays in current hole; store new upper bound and remove this and all remaining holes\n"

, dom->

);

336

dom->

= (*holelistptr)->hole.left;

339

*newub = (*holelistptr)->hole.left;

343

assert(*holelistptr ==

);

346

*lastnextptr =

;

348 else if

(

SCIPsetIsGT

(

, *lastrightptr, (*holelistptr)->hole.left) )

358 SCIPsetDebugMsg

(

"lower bound <%.15g> lays in current hole; store new lower bound and remove hole\n"

, dom->

);

359

*lastrightptr =

(*lastrightptr, (*holelistptr)->hole.right);

362

dom->

= *lastrightptr;

365

*newlb = *lastrightptr;

369 SCIPsetDebugMsg

(

"current hole overlaps with the previous one (...,%.15g); merge to (...,%.15g)\n"

370

*lastrightptr,

(*lastrightptr, (*holelistptr)->hole.right) );

371

*lastrightptr =

(*lastrightptr, (*holelistptr)->hole.right);

373

nextholelist = (*holelistptr)->

;

378

*lastnextptr = nextholelist;

381

*holelistptr = nextholelist;

386

lastrightptr = &(*holelistptr)->

hole

right

;

387

lastnextptr = &(*holelistptr)->

;

390

holelistptr = &(*holelistptr)->

;

399

lastright = dom->

;

402 while

( *holelistptr !=

)

405

assert(

SCIPsetIsLE

(

, lastright, (*holelistptr)->hole.left) );

408

assert(

SCIPsetIsLT

(

, (*holelistptr)->hole.left, (*holelistptr)->hole.right) );

409

lastright = (*holelistptr)->hole.right;

412

holelistptr = &(*holelistptr)->

;

434

assert(var !=

);

446

assert(num <= var->lbchginfossize);

460

assert(var !=

);

472

assert(num <= var->ubchginfossize);

495

assert(var !=

);

505 SCIPsetDebugMsg

(

"adding lower bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n"

527 switch

( boundchgtype )

532

assert(infercons !=

);

570

assert(var !=

);

580 SCIPsetDebugMsg

(

"adding upper bound change info to var <%s>[%g,%g]: depth=%d, pos=%d, infer%s=<%s>, inferinfo=%d, %g -> %g\n"

602 switch

( boundchgtype )

607

assert(infercons !=

);

643

assert(boundchg !=

);

644

assert(stat !=

);

647

assert(cutoff !=

);

655

var = boundchg->

;

656

assert(var !=

);

684 SCIPsetDebugMsg

(

" -> constraint <%s> inference: new lower bound of <%s>[%g,%g]: %g\n"

694 SCIPsetDebugMsg

(

" -> propagator <%s> inference: new lower bound of <%s>[%g,%g]: %g\n"

751 SCIPsetDebugMsg

(

" -> constraint <%s> inference: new upper bound of <%s>[%g,%g]: %g\n"

761 SCIPsetDebugMsg

(

" -> propagator <%s> inference: new upper bound of <%s>[%g,%g]: %g\n"

805

assert(var == boundchg->

);

837

assert(boundchg !=

);

838

assert(stat !=

);

844

var = boundchg->

;

845

assert(var !=

);

858 SCIPsetDebugMsg

(

"removed lower bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n"

879 SCIPsetDebugMsg

(

"removed upper bound change info of var <%s>[%g,%g]: depth=%d, pos=%d, %g -> %g\n"

926

assert(boundchg !=

);

927

assert(cutoff !=

);

974

assert(boundchg !=

);

977

assert(boundchg->

);

1011

assert(boundchg !=

);

1031

assert(boundchg->

);

1044

assert(domchg !=

);

1045

assert(blkmem !=

);

1049

(*domchg)->domchgdyn.nboundchgs = 0;

1050

(*domchg)->domchgdyn.boundchgs =

;

1051

(*domchg)->domchgdyn.nholechgs = 0;

1052

(*domchg)->domchgdyn.holechgs =

;

1053

(*domchg)->domchgdyn.boundchgssize = 0;

1054

(*domchg)->domchgdyn.holechgssize = 0;

1068

assert(domchg !=

);

1069

assert(blkmem !=

);

1071 if

( *domchg !=

)

1076 for

( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )

1082 switch

( (*domchg)->domchgdyn.domchgtype )

1114

assert(domchg !=

);

1115

assert(blkmem !=

);

1117 SCIPdebugMessage

(

"making domain change data %p pointing to %p dynamic\n"

, (

void

*)domchg, (

void

*)*domchg);

1119 if

( *domchg ==

)

1125 switch

( (*domchg)->domchgdyn.domchgtype )

1129

(*domchg)->domchgdyn.nholechgs = 0;

1130

(*domchg)->domchgdyn.holechgs =

;

1131

(*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;

1132

(*domchg)->domchgdyn.holechgssize = 0;

1137

(*domchg)->domchgdyn.boundchgssize = (int) (*domchg)->domchgdyn.nboundchgs;

1138

(*domchg)->domchgdyn.holechgssize = (*domchg)->domchgdyn.nholechgs;

1151 for

( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )

1153

EPSISINT

((*domchg)->domchgbound.boundchgs[i].newbound, 1e-06));

1169

assert(domchg !=

);

1170

assert(blkmem !=

);

1172 SCIPsetDebugMsg

(

"making domain change data %p pointing to %p static\n"

, (

void

*)domchg, (

void

*)*domchg);

1174 if

( *domchg !=

)

1176 switch

( (*domchg)->domchgdyn.domchgtype )

1179 if

( (*domchg)->domchgbound.nboundchgs == 0 )

1185 if

( (*domchg)->domchgboth.nholechgs == 0 )

1187 if

( (*domchg)->domchgbound.nboundchgs == 0 )

1199 if

( (*domchg)->domchgboth.nholechgs == 0 )

1201 if

( (*domchg)->domchgbound.nboundchgs == 0 )

1209

(*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );

1221

(*domchg)->domchgdyn.boundchgssize, (*domchg)->domchgdyn.nboundchgs) );

1223

(*domchg)->domchgdyn.holechgssize, (*domchg)->domchgdyn.nholechgs) );

1235 if

( *domchg !=

)

1238 for

( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )

1257

assert(domchg !=

);

1268

assert(num <= domchg->domchgdyn.boundchgssize);

1282

assert(domchg !=

);

1293

assert(num <= domchg->domchgdyn.holechgssize);

1313

assert(cutoff !=

);

1317 SCIPsetDebugMsg

(

"applying domain changes at %p in depth %d\n"

, (

void

*)domchg, depth);

1319 if

( domchg ==

)

1326

branchcand, eventqueue, depth, i, cutoff) );

1361 if

( domchg ==

)

1397

assert(cutoff !=

);

1401 if

( domchg ==

)

1404 SCIPsetDebugMsg

(

"applying domain changes at %p to the global problem\n"

, (

void

*)domchg);

1410

branchcand, eventqueue, cliquetable, cutoff) );

1440

assert(domchg !=

);

1441

assert(var !=

);

1449 SCIPsetDebugMsg

(

"adding %s bound change <%s: %g> of variable <%s> to domain change at %p pointing to %p\n"

1451

newbound, var->

, (

void

*)domchg, (

void

*)*domchg);

1456 if

( *domchg ==

)

1470

boundchg = &(*domchg)->domchgdyn.boundchgs[(*domchg)->domchgdyn.nboundchgs];

1471

boundchg->

= var;

1472 switch

( boundchgtype )

1478

assert(infercons !=

);

1499

(*domchg)->domchgdyn.nboundchgs++;

1504#ifdef SCIP_DISABLED_CODE 1505#ifdef SCIP_MORE_DEBUG 1508 for

( i = 0; i < (int)(*domchg)->domchgbound.nboundchgs; ++i )

1530

assert(domchg !=

);

1531

assert(ptr !=

);

1536 if

( *domchg ==

)

1550

holechg = &(*domchg)->domchgdyn.holechgs[(*domchg)->domchgdyn.nholechgs];

1551

holechg->

ptr

= ptr;

1554

(*domchg)->domchgdyn.nholechgs++;

1622

assert(var !=

);

1630

onlyredundant ?

"redundant"

"all"

, irrelevantvar ?

"irrelevant "

""

SCIPvarGetName

(var), lb, ub);

1633 if

( var->

implics

&& (!onlyredundant || lb > 0.5 || ub < 0.5) )

1651 for

( i = 0; i < nimpls; i++ )

1656

implvar = implvars[i];

1657

impltype = impltypes[i];

1658

assert(implvar != var);

1690

varfixing = !varfixing;

1692 while

( varfixing ==

);

1694 if

( removefromvar )

1721 for

( i = 0; i < nvbds; i++ )

1726

assert(newnvbds <= i);

1729

assert(implvar !=

);

1735 if

( onlyredundant )

1743 if

( removefromvar )

1747

vars[newnvbds] = implvar;

1748

coefs[newnvbds] = coef;

1749

constants[newnvbds] = constants[i];

1764 if

( coef > 0.0 && implvar->

vubs

)

1766 SCIPsetDebugMsg

(

"deleting variable upper bound from <%s> involving variable %s\n"

1772 else if

( coef < 0.0 && implvar->vlbs !=

)

1774 SCIPsetDebugMsg

(

"deleting variable lower bound from <%s> involving variable %s\n"

1782 if

( removefromvar )

1815 for

( i = 0; i < nvbds; i++ )

1820

assert(newnvbds <= i);

1823

assert(implvar !=

);

1829 if

( onlyredundant )

1837 if

( removefromvar )

1841

vars[newnvbds] = implvar;

1842

coefs[newnvbds] = coefs[i];

1843

constants[newnvbds] = constants[i];

1858 if

( coef < 0.0 && implvar->vubs !=

)

1860 SCIPsetDebugMsg

(

"deleting variable upper bound from <%s> involving variable %s\n"

1866 else if

( coef > 0.0 && implvar->

vlbs

)

1868 SCIPsetDebugMsg

(

"deleting variable lower bound from <%s> involving variable %s\n"

1876 if

( removefromvar )

1904

assert(blkmem !=

);

1905

assert(var !=

);

1911

assert(stat !=

);

1950

assert(var !=

);

1951

assert(blkmem !=

);

1952

assert(stat !=

);

1969 SCIPerrorMessage

(

"invalid bounds [%.2g,%.2g] for binary variable <%s>\n"

, lb, ub, name);

1983

(*var)->scip =

->scip;

1986

(*var)->unchangedobj = obj;

1987

(*var)->branchfactor = 1.0;

1988

(*var)->rootsol = 0.0;

1989

(*var)->bestrootsol = 0.0;

1990

(*var)->bestrootredcost = 0.0;

1992

(*var)->relaxsol = 0.0;

1993

(*var)->nlpsol = 0.0;

1994

(*var)->primsolavg = 0.5 * (lb + ub);

1997

(*var)->conflictrelaxedlb = (*var)->conflictlb;

1998

(*var)->conflictrelaxedub = (*var)->conflictub;

2001

(*var)->glbdom.holelist =

;

2002

(*var)->glbdom.lb = lb;

2003

(*var)->glbdom.ub = ub;

2004

(*var)->locdom.holelist =

;

2005

(*var)->locdom.lb = lb;

2006

(*var)->locdom.ub = ub;

2007

(*var)->varcopy = varcopy;

2008

(*var)->vardelorig = vardelorig;

2009

(*var)->vartrans = vartrans;

2010

(*var)->vardeltrans = vardeltrans;

2011

(*var)->vardata = vardata;

2012

(*var)->parentvars =

;

2013

(*var)->negatedvar =

;

2014

(*var)->vlbs =

;

2015

(*var)->vubs =

;

2016

(*var)->implics =

;

2017

(*var)->cliquelist =

;

2018

(*var)->eventfilter =

;

2019

(*var)->lbchginfos =

;

2020

(*var)->ubchginfos =

;

2021

(*var)->index = stat->

nvaridx

;

2022

(*var)->probindex = -1;

2023

(*var)->pseudocandindex = -1;

2024

(*var)->eventqueueindexobj = -1;

2025

(*var)->eventqueueindexlb = -1;

2026

(*var)->eventqueueindexub = -1;

2027

(*var)->parentvarssize = 0;

2028

(*var)->nparentvars = 0;

2030

(*var)->branchpriority = 0;

2032

(*var)->lbchginfossize = 0;

2033

(*var)->nlbchginfos = 0;

2034

(*var)->ubchginfossize = 0;

2035

(*var)->nubchginfos = 0;

2036

(*var)->conflictlbcount = 0;

2037

(*var)->conflictubcount = 0;

2038

(*var)->closestvlbidx = -1;

2039

(*var)->closestvubidx = -1;

2040

(*var)->closestvblpcount = -1;

2041

(*var)->initial = initial;

2042

(*var)->removable = removable;

2043

(*var)->deleted =

;

2044

(*var)->donotaggr =

;

2045

(*var)->donotmultaggr =

;

2046

(*var)->vartype = vartype;

2047

(*var)->pseudocostflag =

;

2048

(*var)->eventqueueimpl =

;

2049

(*var)->deletable =

;

2050

(*var)->delglobalstructs =

;

2051

(*var)->relaxationonly =

;

2055

(*var)->nlocksdown[i] = 0;

2056

(*var)->nlocksup[i] = 0;

2066

(*var)->valuehistory =

;

2093

assert(var !=

);

2094

assert(blkmem !=

);

2095

assert(stat !=

);

2098 SCIP_CALL

(

(var, blkmem,

, stat, name, lb, ub, obj, vartype, initial, removable,

2099

varcopy, vardelorig, vartrans, vardeltrans, vardata) );

2103

(*var)->data.original.origdom.holelist =

;

2104

(*var)->data.original.origdom.lb = lb;

2105

(*var)->data.original.origdom.ub = ub;

2106

(*var)->data.original.transvar =

;

2136

assert(var !=

);

2137

assert(blkmem !=

);

2140 SCIP_CALL

(

(var, blkmem,

, stat, name, lb, ub, obj, vartype, initial, removable,

2141

varcopy, vardelorig, vartrans, vardeltrans, vardata) );

2179

assert(blkmem !=

);

2180

assert(stat !=

);

2181

assert(sourcescip !=

);

2182

assert(sourcevar !=

);

2183

assert(var !=

);

2185

assert(varmap !=

);

2186

assert(consmap !=

);

2211

assert(*var !=

);

2214

(*var)->donotaggr = sourcevar->

donotaggr

;

2225

varmap, consmap, (*var), &targetdata, &result) );

2230 SCIPerrorMessage

(

"variable data copying method returned invalid result <%d>\n"

, result);

2239

(*var)->varcopy = sourcevar->varcopy;

2240

(*var)->vardelorig = sourcevar->vardelorig;

2241

(*var)->vartrans = sourcevar->vartrans;

2242

(*var)->vardeltrans = sourcevar->vardeltrans;

2243

(*var)->

vardata

= targetdata;

2248 if

(

->history_allowtransfer )

2258

(*var)->varcopy = sourcevar->varcopy;

2259

(*var)->vardelorig = sourcevar->vardelorig;

2260

(*var)->vartrans = sourcevar->vartrans;

2261

(*var)->vardeltrans = sourcevar->vardeltrans;

2262

(*var)->

vardata

= targetdata;

2280 if

( strncmp(str,

"+inf"

, 4) == 0 )

2283

(*endptr) = (

char

*)str + 4;

2285 else if

( strncmp(str,

"-inf"

, 4) == 0 )

2288

(*endptr) = (

char

*)str + 4;

2321

|| ( strncmp(type,

"original"

, 8) != 0 && strncmp(type,

"global"

, 6) != 0 && strncmp(type,

"local"

, 5) != 0 && strncmp(type,

"lazy"

, 4) != 0 ) )

2341 while

( **endptr !=

'\0'

&& (**endptr ==

']'

|| **endptr ==

','

) )

2371

assert(lb !=

);

2372

assert(ub !=

);

2373

assert(obj !=

);

2374

assert(vartype !=

);

2375

assert(lazylb !=

);

2376

assert(lazyub !=

);

2377

assert(success !=

);

2383

assert(*endptr != str);

2387 if

( strncmp(token,

"binary"

, 3) == 0 )

2389 else if

( strncmp(token,

"integer"

, 3) == 0 )

2391 else if

( strncmp(token,

"implicit"

, 3) == 0 )

2393 else if

( strncmp(token,

"continuous"

, 3) == 0 )

2398

(*success) =

;

2407

assert(*endptr != str);

2430 if

( *endptr ==

)

2435

assert(strncmp(token,

"global"

, 6) == 0 || strncmp(token,

"original"

, 8) == 0);

2445 for

( i = 0; i < 2 && *endptr !=

&& **endptr !=

'\0'

; ++i )

2454 if

( *endptr ==

)

2457 if

( strncmp(token,

"local"

, 5) == 0 && local )

2462 else if

( strncmp(token,

"lazy"

, 4) == 0 )

2470 if

( *endptr ==

)

2478 SCIPerrorMessage

(

"Parsed invalid bounds for binary variable <%s>: [%f, %f].\n"

, name, *lb, *ub);

2484 SCIPerrorMessage

(

"Parsed invalid lazy bounds for binary variable <%s>: [%f, %f].\n"

, name, *lazylb, *lazyub);

2522

assert(var !=

);

2523

assert(blkmem !=

);

2524

assert(stat !=

);

2525

assert(endptr !=

);

2526

assert(success !=

);

2529 SCIP_CALL

(

varParse

(

, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub,

, endptr, success) );

2534 SCIP_CALL

(

(var, blkmem,

, stat, name, lb, ub, obj, vartype, initial, removable,

2535

varcopy, vardelorig, vartrans, vardeltrans, vardata) );

2539

(*var)->data.original.origdom.holelist =

;

2540

(*var)->data.original.origdom.lb = lb;

2541

(*var)->data.original.origdom.ub = ub;

2542

(*var)->data.original.transvar =

;

2545

(*var)->lazylb = lazylb;

2546

(*var)->lazyub = lazyub;

2586

assert(var !=

);

2587

assert(blkmem !=

);

2588

assert(endptr !=

);

2589

assert(success !=

);

2592 SCIP_CALL

(

varParse

(

, messagehdlr, str, name, &lb, &ub, &obj, &vartype, &lazylb, &lazyub,

, endptr, success) );

2597 SCIP_CALL

(

(var, blkmem,

, stat, name, lb, ub, obj, vartype, initial, removable,

2598

varcopy, vardelorig, vartrans, vardeltrans, vardata) );

2607

(*var)->lazylb = lazylb;

2608

(*var)->lazyub = lazyub;

2636

assert(num <= var->parentvarssize);

2650

assert(var !=

);

2651

assert(parentvar !=

);

2685 for

( i = 0; i < (*var)->nparentvars; ++i )

2687

assert((*var)->parentvars !=

);

2689

assert(parentvar !=

);

2705#ifdef SCIP_DISABLED_CODE 2711

assert(v < parentvar->data.multaggr.nvars && parentvar->

multaggr

vars

[v] == *var);

2712 if

( v < parentvar->data.multaggr.nvars-1 )

2723

assert((*var)->negatedvar == parentvar);

2725

(*var)->negatedvar =

;

2729 SCIPerrorMessage

(

"parent variable is neither ORIGINAL, AGGREGATED nor NEGATED\n"

);

2752

assert(var !=

);

2753

assert(*var !=

);

2755

assert((*var)->nuses == 0);

2756

assert((*var)->probindex == -1);

2765

assert((*var)->data.original.transvar ==

);

2766 holelistFree

(&(*var)->data.original.origdom.holelist, blkmem);

2767

assert((*var)->data.original.origdom.holelist ==

);

2794 if

( (*var)->vardelorig !=

)

2801 if

( (*var)->vardeltrans !=

)

2808 if

( (*var)->eventfilter !=

)

2812

assert((*var)->eventfilter ==

);

2817

assert((*var)->glbdom.holelist ==

);

2818

assert((*var)->locdom.holelist ==

);

2851

assert(var !=

);

2852

assert(var->

nuses

>= 0);

2857#ifdef DEBUGUSES_VARNAME 2858 if

( strcmp(var->

, DEBUGUSES_VARNAME) == 0

2859

#ifdef DEBUGUSES_PROBNAME

2865

printf(

"Captured variable "

DEBUGUSES_VARNAME

" in SCIP %p, now %d uses; captured at\n"

, (

void

*)var->

, var->

nuses

);

2880

assert(var !=

);

2881

assert(*var !=

);

2882

assert((*var)->nuses >= 1);

2883

assert(blkmem !=

);

2884

assert((*var)->scip ==

->scip);

2886 SCIPsetDebugMsg

(

"release variable <%s> with nuses=%d\n"

, (*var)->name, (*var)->nuses);

2889#ifdef DEBUGUSES_VARNAME 2890 if

( strcmp((*var)->name, DEBUGUSES_VARNAME) == 0

2891

#ifdef DEBUGUSES_PROBNAME

2892

&& (((*var)->scip->transprob !=

&& strcmp(

SCIPprobGetName

((*var)->scip->transprob), DEBUGUSES_PROBNAME) == 0) ||

2893

strcmp(

SCIPprobGetName

((*var)->scip->origprob), DEBUGUSES_PROBNAME) == 0)

2897

printf(

"Released variable "

DEBUGUSES_VARNAME

" in SCIP %p, now %d uses; released at\n"

, (

void

*)(*var)->scip, (*var)->nuses);

2902 if

( (*var)->nuses == 0 )

2919

assert(name !=

);

2935

assert(var !=

);

2982 if

( holelist ==

)

2992 while

(holelist !=

)

3018

assert(var !=

);

3019

assert(var->

->scip);

3054 printBounds

(

, messagehdlr, file, lb, ub,

"original bounds"

);

3065 printHolelist

(messagehdlr, file, holelist,

"original holes"

);

3072 printBounds

(

, messagehdlr, file, lb, ub,

"global bounds"

);

3089 printHolelist

(messagehdlr, file, holelist,

"global holes"

);

3093 printHolelist

(messagehdlr, file, holelist,

"local holes"

);

3155

assert(var !=

);

3157

assert(var->

->scip);

3179

assert(var !=

);

3180

assert((

int

)locktype >= 0 && (

int

)locktype < (

int

)

NLOCKTYPES

);

3181

assert(var->

[locktype] >= 0);

3183

assert(var->

->scip);

3185 if

( addnlocksdown == 0 && addnlocksup == 0 )

3189 SCIPsetDebugMsg

(

"add rounding locks %d/%d to variable <%s> (locks=%d/%d, type=%u)\n"

3190

addnlocksdown, addnlocksup, var->

, var->

[locktype], var->

[locktype], locktype);

3197

assert(lockvar !=

);

3209

lockvar->

[locktype] += addnlocksdown;

3210

lockvar->

[locktype] += addnlocksup;

3212

assert(lockvar->

[locktype] >= 0);

3213

assert(lockvar->

[locktype] >= 0);

3220

lockvar->

[locktype] += addnlocksdown;

3221

lockvar->

[locktype] += addnlocksup;

3223

assert(lockvar->

[locktype] >= 0);

3224

assert(lockvar->

[locktype] >= 0);

3227

&& lockvar->

[locktype] <= 1 )

3238 int

tmp = addnlocksup;

3240

addnlocksup = addnlocksdown;

3241

addnlocksdown = tmp;

3252

lockvar->

[locktype] += addnlocksdown;

3253

lockvar->

[locktype] += addnlocksup;

3255

assert(lockvar->

[locktype] >= 0);

3256

assert(lockvar->

[locktype] >= 0);

3275 int

tmp = addnlocksup;

3281

addnlocksup = addnlocksdown;

3282

addnlocksdown = tmp;

3303

assert(var !=

);

3304

assert((

int

)locktype >= 0 && (

int

)locktype < (

int

)

NLOCKTYPES

);

3361

assert(var !=

);

3362

assert((

int

)locktype >= 0 && (

int

)locktype < (

int

)

NLOCKTYPES

);

3363

assert(var->

[locktype] >= 0);

3472

assert(origvar !=

);

3473

assert(origvar->

->scip);

3479

assert(transvar !=

);

3496

origvar->vardelorig, origvar->vartrans, origvar->vardeltrans, origvar->varcopy,

) );

3514

(*transvar)->nlocksdown[i] = origvar->

[i];

3515

(*transvar)->nlocksup[i] = origvar->

[i];

3516

assert((*transvar)->nlocksdown[i] >= 0);

3517

assert((*transvar)->nlocksup[i] >= 0);

3521

(*transvar)->donotaggr = origvar->

donotaggr

;

3525

(*transvar)->lazylb = origvar->

lazylb

;

3526

(*transvar)->lazyub = origvar->

lazyub

;

3534 if

( origvar->vartrans !=

)

3539

(*transvar)->vardata = origvar->

vardata

;

3542 SCIPsetDebugMsg

(

"transformed variable: <%s>[%p] -> <%s>[%p]\n"

, origvar->

, (

void

*)origvar, (*transvar)->

, (

void

*)*transvar);

3556

assert(origvar !=

);

3558

assert(origvar->

->scip);

3588

assert(var !=

);

3590

assert(var->

->scip);

3622

assert(var !=

);

3624

assert(var->

->scip);

3668

assert(var !=

);

3669

assert(var->

->scip);

3670

assert(0 <= fixeventtype && fixeventtype <= 2);

3683 switch

( fixeventtype )

3772

assert(var !=

);

3773

assert(var->

->scip);

3776

assert(infeasible !=

);

3777

assert(fixed !=

);

3781

*infeasible =

;

3787 SCIPsetDebugMsg

(

" -> variable already fixed to %g (fixedval=%g): infeasible=%u\n"

, var->

, fixedval, *infeasible);

3795

*infeasible =

;

3808

lp, branchcand, eventfilter, eventqueue, cliquetable, fixedval, infeasible, fixed) );

3865 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue, obj) );

3890 SCIP_CALL

(

(var->

aggregate

, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

3891

branchcand, eventfilter, eventqueue, cliquetable, childfixedval, infeasible, fixed) );

3905 SCIP_CALL

(

(var->

, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

3906

branchcand, eventfilter, eventqueue, cliquetable, var->

negate

constant

- fixedval, infeasible, fixed) );

3972

assert(nvars !=

);

3974

assert(constant !=

);

3975

assert(requiredsize !=

);

3976

assert(*nvars <= varssize);

3983

assert(vars !=

);

3994

activeconstant = 0.0;

3995

activeconstantinf =

;

3996

activevarssize = (*nvars) * 2;

3998

tmpvarssize = *nvars;

4013 for

( v = ntmpvars - 1; v >= 0; --v )

4016

scalar = tmpscalars[v];

4018

assert(var !=

);

4024

assert(var !=

);

4037

tmpscalars[v] = scalar;

4039

noldtmpvars = ntmpvars;

4042 SCIPsortPtrReal

((

void

**)tmpvars, tmpscalars, SCIPvarComp, noldtmpvars);

4044 for

( v = 1; v < noldtmpvars; ++v )

4049

tmpscalars[ntmpvars] += tmpscalars[v];

4056

tmpscalars[ntmpvars] = tmpscalars[v];

4057

tmpvars[ntmpvars] = tmpvars[v];

4063#ifdef SCIP_MORE_DEBUG 4064 for

( v = 1; v < ntmpvars; ++v )

4069 while

( ntmpvars >= 1 )

4073

var = tmpvars[ntmpvars];

4074

scalar = tmpscalars[ntmpvars];

4076

assert(var !=

);

4079 if

( scalar == 0.0 )

4092 if

( nactivevars >= activevarssize )

4094

activevarssize *= 2;

4097

assert(nactivevars < activevarssize);

4099

activevars[nactivevars] = var;

4100

activescalars[nactivevars] = scalar;

4111 if

( nmultvars + ntmpvars > tmpvarssize )

4113 while

( nmultvars + ntmpvars > tmpvarssize )

4117

assert(nmultvars + ntmpvars <= tmpvarssize);

4120 if

( nmultvars > tmpvarssize2 )

4122 while

( nmultvars > tmpvarssize2 )

4126

assert(nmultvars <= tmpvarssize2);

4131 for

( ; nmultvars >= 0; --nmultvars )

4133

multvar = multvars[nmultvars];

4134

multscalar = multscalars[nmultvars];

4137

assert(multvar !=

);

4139

assert(multvar !=

);

4146 if

( !activeconstantinf )

4152

assert(scalar != 0.0);

4153 if

( scalar * multconstant > 0.0 )

4156

activeconstantinf =

;

4161

activeconstantinf =

;

4165

activeconstant += scalar * multconstant;

4180

tmpscalars[pos] += scalar * multscalar;

4184

tmpvars2[ntmpvars2] = multvar;

4185

tmpscalars2[ntmpvars2] = scalar * multscalar;

4187

assert(ntmpvars2 <= tmpvarssize2);

4191 if

( ntmpvars2 > 0 )

4194 SCIPsortPtrReal

((

void

**)tmpvars2, tmpscalars2, SCIPvarComp, ntmpvars2);

4196 for

( v = 1; v < ntmpvars2; ++v )

4201

tmpscalars2[pos] += tmpscalars2[v];

4208

tmpscalars2[pos] = tmpscalars2[v];

4209

tmpvars2[pos] = tmpvars2[v];

4213

ntmpvars2 = pos + 1;

4214#ifdef SCIP_MORE_DEBUG 4215 for

( v = 1; v < ntmpvars2; ++v )

4219 for

( v = 1; v < ntmpvars; ++v )

4226

pos = ntmpvars + ntmpvars2 - 1;

4227

ntmpvars += ntmpvars2;

4229 while

( v >= 0 && k >= 0 )

4235

tmpvars[pos] = tmpvars[v];

4236

tmpscalars[pos] = tmpscalars[v];

4241

tmpvars[pos] = tmpvars2[k];

4242

tmpscalars[pos] = tmpscalars2[k];

4251

tmpvars[pos] = tmpvars[v];

4252

tmpscalars[pos] = tmpscalars[v];

4259

tmpvars[pos] = tmpvars2[k];

4260

tmpscalars[pos] = tmpscalars2[k];

4265#ifdef SCIP_MORE_DEBUG 4266 for

( v = 1; v < ntmpvars; ++v )

4272 if

( !activeconstantinf )

4280

assert(scalar != 0.0);

4281 if

( scalar * multconstant > 0.0 )

4284

activeconstantinf =

;

4289

activeconstantinf =

;

4293

activeconstant += scalar * multconstant;

4320 if

( mergemultiples )

4325 SCIPsortPtrReal

((

void

**)activevars, activescalars, SCIPvarComp, nactivevars);

4328

v = nactivevars - 1;

4334 if

( activescalars[v - 1] + activescalars[v] != 0.0 )

4336

activescalars[v - 1] += activescalars[v];

4338

activevars[v] = activevars[nactivevars];

4339

activescalars[v] = activescalars[nactivevars];

4344

activevars[v] = activevars[nactivevars];

4345

activescalars[v] = activescalars[nactivevars];

4348

activevars[v] = activevars[nactivevars];

4349

activescalars[v] = activescalars[nactivevars];

4363 for

( v = 0; v < nactivevars / 2; ++v )

4365

tmpvar = activevars[v];

4366

tmpscalar = activescalars[v];

4367

activevars[v] = activevars[nactivevars - 1 - v];

4368

activescalars[v] = activescalars[nactivevars - 1 - v];

4369

activevars[nactivevars - 1 - v] = tmpvar;

4370

activescalars[nactivevars - 1 - v] = tmpscalar;

4374

*requiredsize = nactivevars;

4376 if

( varssize >= *requiredsize )

4378

assert(vars !=

);

4380

*nvars = *requiredsize;

4385 if

( activeconstantinf )

4386

(*constant) = activeconstant;

4388

(*constant) += activeconstant;

4399 for

( v = 0; v < *nvars; ++v )

4401

vars[v] = activevars[v];

4402 scalars

[v] = activescalars[v];

4433 int

multrequiredsize;

4436

assert( var !=

);

4438

assert(var->

->scip);

4474 if

( multrequiredsize > multvarssize )

4478

multvarssize = multrequiredsize;

4480

assert( multrequiredsize <= multvarssize );

4575

assert(var !=

);

4576

assert(var->

->scip);

4577

assert(aggvar !=

);

4579

assert(infeasible !=

);

4580

assert(fixed !=

);

4582

*infeasible =

;

4585 SCIPsetDebugMsg

(

"updating bounds of variables in aggregation <%s> == %g*<%s> %+g\n"

, var->

, scalar, aggvar->

, constant);

4592

aggvarbdschanged =

;

4600

varlb = aggvar->

* scalar + constant;

4604

varub = aggvar->

* scalar + constant;

4611

varub = aggvar->

* scalar + constant;

4615

varlb = aggvar->

* scalar + constant;

4626

*infeasible =

;

4632 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

4633

eventfilter, eventqueue, cliquetable, varlb, infeasible, fixed) );

4634 if

( !(*infeasible) )

4638 SCIP_CALL

(

(aggvar, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

4639

eventfilter, eventqueue, cliquetable, (varlb-constant)/scalar, infeasible, &aggfixed) );

4640

assert(*fixed == aggfixed);

4665

aggvarlb = (var->

- constant) / scalar;

4669

aggvarub = (var->

- constant) / scalar;

4676

aggvarub = (var->

- constant) / scalar;

4680

aggvarlb = (var->

- constant) / scalar;

4691

*infeasible =

;

4697 SCIP_CALL

(

(aggvar, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

4698

eventfilter, eventqueue, cliquetable, aggvarlb, infeasible, fixed) );

4699 if

( !(*infeasible) )

4703 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

4704

eventfilter, eventqueue, cliquetable, aggvarlb * scalar + constant, infeasible, &varfixed) );

4705

assert(*fixed == varfixed);

4729 while

( aggvarbdschanged );

4773

assert(var !=

);

4774

assert(aggvar !=

);

4775

assert(var->

->scip);

4780

assert(infeasible !=

);

4781

assert(aggregated !=

);

4783

*infeasible =

;

4784

*aggregated =

;

4792 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand, eventfilter,

4793

eventqueue, cliquetable, constant, infeasible, aggregated) );

4822 if

( var == aggvar )

4828 SCIP_CALL

(

(var, blkmem,

varUpdateAggregationBounds

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

4829

eventfilter, eventqueue, cliquetable, constant/(1.0-scalar), infeasible, aggregated) );

4835 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

4836

branchcand, eventfilter, eventqueue, cliquetable, aggvar, scalar, constant, infeasible, &fixed) );

4837 if

( *infeasible || fixed )

4839

*aggregated = fixed;

4917 for

( i = 0; i < nvbds && !(*infeasible); ++i )

4919 SCIP_CALL

(

SCIPvarAddVlb

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,

4920

eventqueue, vars[i], coefs[i], constants[i],

, infeasible,

) );

4929 for

( i = 0; i < nvbds && !(*infeasible); ++i )

4931 SCIP_CALL

(

SCIPvarAddVub

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,

4932

eventqueue, vars[i], coefs[i], constants[i],

, infeasible,

) );

4945 for

( i = 0; i < 2; ++i )

4957 for

( j = 0; j < nimpls && !(*infeasible); ++j )

4962 SCIP_CALL

(

SCIPvarAddImplic

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

4963

branchcand, eventqueue, (

SCIP_Bool

)i, implvars[j], impltypes[j], implbounds[j],

, infeasible,

4989 if

( scalar >= 0.0 )

5029 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue, obj) );

5034

*aggregated =

;

5038 if

( *infeasible || *aggregated )

5092#define MAXDNOM 1000000LL 5095

assert(blkmem !=

);

5096

assert(stat !=

);

5097

assert(transprob !=

);

5098

assert(origprob !=

);

5099

assert(tree !=

);

5100

assert(lp !=

);

5101

assert(cliquetable !=

);

5102

assert(branchcand !=

);

5103

assert(eventqueue !=

);

5104

assert(varx !=

);

5105

assert(vary !=

);

5106

assert(varx != vary);

5107

assert(infeasible !=

);

5108

assert(aggregated !=

);

5117

*infeasible =

;

5118

*aggregated =

;

5133

assert(scalarxd >= 1);

5134

assert(scalaryd >= 1);

5138 a

= (scm/scalarxd)*scalarxn;

5139 b

= (scm/scalaryd)*scalaryn;

5153

*infeasible =

;

5171 SCIP_CALL

(

(varx, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5172

branchcand, eventfilter, eventqueue, vary, (

)(-

), (

)(c/

), infeasible, aggregated) );

5173

assert(*aggregated);

5180 SCIP_CALL

(

(vary, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5181

branchcand, eventfilter, eventqueue, varx, (

)(-

), (

)(c/

), infeasible, aggregated) );

5182

assert(*aggregated);

5212

currentclass = c %

;

5213 if

( currentclass < 0 )

5215

assert(0 <= currentclass && currentclass <

);

5217

classstep = (-

) %

;

5219 if

( classstep < 0 )

5221

assert(0 <= classstep && classstep <

);

5223 while

( currentclass != 0 )

5225

assert(0 <= currentclass && currentclass <

);

5226

currentclass += classstep;

5227 if

( currentclass >=

)

5232

assert(((c -

*ysol) %

) == 0);

5234

xsol = (c -

*ysol)/

;

5259 SCIP_CALL

(

(varx, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5260

branchcand, eventfilter, eventqueue, aggvar, (

)(-

), (

)xsol, infeasible, aggregated) );

5261

assert(*aggregated || *infeasible);

5263 if

( !(*infeasible) )

5265 SCIP_CALL

(

(vary, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5266

branchcand, eventfilter, eventqueue, aggvar, (

)

, (

)ysol, infeasible, aggregated) );

5267

assert(*aggregated || *infeasible);

5315

assert(blkmem !=

);

5316

assert(stat !=

);

5317

assert(transprob !=

);

5318

assert(origprob !=

);

5319

assert(tree !=

);

5320

assert(lp !=

);

5321

assert(cliquetable !=

);

5322

assert(branchcand !=

);

5323

assert(eventqueue !=

);

5324

assert(varx !=

);

5325

assert(vary !=

);

5326

assert(varx != vary);

5327

assert(infeasible !=

);

5328

assert(aggregated !=

);

5335

*infeasible =

;

5336

*aggregated =

;

5406

scalar = -scalary/scalarx;

5407

constant = rhs/scalarx;

5417

*infeasible =

;

5427 SCIP_CALL

(

(varx, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5428

branchcand, eventfilter, eventqueue, vary, scalar, constant, infeasible, aggregated) );

5435 SCIP_CALL

(

tryAggregateIntVars

(

, blkmem, stat, transprob, origprob, primal, tree, reopt, lp, cliquetable,

5436

branchcand, eventfilter, eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );

5479 int

tmprequiredsize;

5482

assert(var !=

);

5483

assert(var->

->scip);

5486

assert(naggvars == 0 || aggvars !=

);

5488

assert(infeasible !=

);

5489

assert(aggregated !=

);

5491 SCIPsetDebugMsg

(

"trying multi-aggregating variable <%s> == ...%d vars... %+g\n"

, var->

, naggvars, constant);

5493

*infeasible =

;

5494

*aggregated =

;

5501 SCIPerrorMessage

(

"cannot multi-aggregate an untransformed original variable\n"

);

5505

reopt, lp, cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,

scalars

, constant, infeasible, aggregated) );

5512

ntmpvars = naggvars;

5513

tmpvarssize = naggvars;

5514

tmpconstant = constant;

5520 if

( tmprequiredsize > tmpvarssize )

5524

tmpvarssize = tmprequiredsize;

5526

assert( tmprequiredsize <= tmpvarssize );

5534 for

( v = ntmpvars - 1; v >= 0; --v )

5536

assert(tmpvars[v] !=

);

5539 if

( tmpvars[v]->index == var->

index

)

5541

tmpscalar += tmpscalars[v];

5542

tmpvars[v] = tmpvars[ntmpvars - 1];

5543

tmpscalars[v] = tmpscalars[ntmpvars - 1];

5551 if

( ntmpvars == 0 )

5555 SCIPsetDebugMsg

(

"Possible multi-aggregation was completely resolved and detected to be redundant.\n"

);

5560 SCIPsetDebugMsg

(

"Multi-aggregation was completely resolved and led to infeasibility.\n"

);

5561

*infeasible =

;

5565 else if

( ntmpvars == 1 )

5567

assert(tmpscalars[0] != 0.0);

5568

assert(tmpvars[0] !=

);

5571 SCIP_CALL

(

(tmpvars[0], blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

5572

branchcand, eventfilter, eventqueue, cliquetable, -constant/tmpscalars[0], infeasible, aggregated) );

5575 else if

( ntmpvars == 2 )

5578 SCIPsetDebugMsg

(

"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n"

5582

cliquetable, branchcand, eventfilter, eventqueue, tmpvars[0], tmpvars[1], tmpscalars[0],

5583

tmpscalars[1], -tmpconstant, infeasible, aggregated) );

5596

tmpscalar = 1 - tmpscalar;

5597

tmpconstant /= tmpscalar;

5598 for

( v = ntmpvars - 1; v >= 0; --v )

5599

tmpscalars[v] /= tmpscalar;

5603 if

( ntmpvars == 0 )

5606 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, branchcand,

5607

eventfilter, eventqueue, cliquetable, tmpconstant, infeasible, aggregated) );

5612 if

( ntmpvars == 1 )

5614 SCIPsetDebugMsg

(

"Possible multi-aggregation led to aggregation of variables <%s> and <%s> with scalars %g and %g and constant %g.\n"

5618

cliquetable, branchcand, eventfilter, eventqueue, var, tmpvars[0], 1.0, -tmpscalars[0], tmpconstant,

5619

infeasible, aggregated) );

5690 for

( v = 0; v < ntmpvars; ++v )

5692

assert(tmpvars[v] !=

);

5694

branchfactor =

(tmpvars[v]->branchfactor, branchfactor);

5695

branchpriority =

(tmpvars[v]->branchpriority, branchpriority);

5700 for

( v = 0; v < ntmpvars; ++v )

5706 if

( tmpscalars[v] >= 0.0 )

5731 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp, eventfilter, eventqueue, obj) );

5733

*aggregated =

;

5754 SCIPerrorMessage

(

"cannot multi-aggregate a multiple aggregated variable again\n"

);

5767 for

( v = 0; v < naggvars; ++v )

5771 SCIP_CALL

(

SCIPvarMultiaggregate

(var->

, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

5772

cliquetable, branchcand, eventfilter, eventqueue, naggvars, aggvars,

scalars

5776 for

( v = 0; v < naggvars; ++v )

5786 if

( *infeasible || *aggregated )

5802

assert(var !=

);

5810

assert(retvar !=

);

5851

assert(var !=

);

5854

assert(retvar !=

);

5884

assert(var !=

);

5887

assert(retvar !=

);

5922

assert(var !=

);

5923

assert(var->

->scip);

5924

assert(negvar !=

);

5949

(*negvar)->data.negate.constant = 1.0;

5960

(*negvar)->glbdom.lb = (*negvar)->data.negate.constant - var->

;

5961

(*negvar)->glbdom.ub = (*negvar)->data.negate.constant - var->

;

5962

(*negvar)->locdom.lb = (*negvar)->data.negate.constant - var->

;

5963

(*negvar)->locdom.ub = (*negvar)->data.negate.constant - var->

;

5980

(*negvar)->donotaggr = var->

donotaggr

;

5984

(*negvar)->lazylb = (*negvar)->data.negate.constant - var->

lazyub

;

5985

(*negvar)->lazyub = (*negvar)->data.negate.constant - var->

lazylb

;

5989

assert((*negvar)->nuses == 1);

6009

assert(var !=

);

6010

assert(probindex >= 0 || var->

vlbs

);

6011

assert(probindex >= 0 || var->

vubs

);

6028

assert(var !=

);

6029

assert(probindex >= 0);

6043

assert(var !=

);

6044

assert(name !=

);

6046

var->

= (

char

*)name;

6065

assert(var->

->scip);

6096

assert(var !=

);

6109

assert(var !=

);

6112

assert(retvar !=

);

6124 SCIPerrorMessage

(

"cannot mark a multi-aggregated variable to not be aggregated.\n"

);

6145

assert(var !=

);

6148

assert(retvar !=

);

6160 SCIPerrorMessage

(

"cannot mark a multi-aggregated variable to not be multi-aggregated.\n"

);

6188

assert(var !=

);

6194 SCIPerrorMessage

(

"cannot change type of variable already in the problem\n"

);

6239

assert(var !=

);

6240

assert(var->

->scip);

6274

assert(var !=

);

6276

assert(var->

->scip);

6302

oldobj = var->

;

6323 SCIPerrorMessage

(

"cannot change objective value of a fixed, aggregated, multi-aggregated, or negated variable\n"

);

6352

assert(var !=

);

6354

assert(var->

->scip);

6375

var->

+= addobj;

6383

oldobj = var->

;

6384

var->

+= addobj;

6406 SCIP_CALL

(

(primal, blkmem,

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

6413 SCIP_CALL

(

(primal, blkmem,

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

6422 SCIP_CALL

(

(primal, blkmem,

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

6436 SCIP_CALL

(

(primal, blkmem,

, stat, eventfilter, eventqueue, transprob, origprob, tree, reopt, lp) );

6437 SCIP_CALL

(

(var->

, blkmem,

, stat, transprob, origprob, primal, tree, reopt, lp,

6438

eventfilter, eventqueue, -addobj) );

6458

assert(var !=

);

6460

assert(var->

->scip);

6461

assert(lp !=

);

6494 SCIPerrorMessage

(

"cannot change diving objective value of a multi-aggregated variable\n"

);

6520

assert(var !=

);

6522

assert(var->

->scip);

6523

assert(lb !=

);

6537

assert(var !=

);

6539

assert(var->

->scip);

6540

assert(ub !=

);

6572

assert(var !=

);

6576

assert(var->

->scip);

6611

assert(parentvar !=

);

6631

assert(var !=

);

6635

assert(var->

->scip);

6670

assert(parentvar !=

);

6694

assert(var !=

);

6697

assert(!

(

, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));

6699

assert(var->

->scip);

6710 SCIPsetDebugMsg

(

"issue GLBCHANGED event for variable <%s>: %g -> %g\n"

, var->

, oldbound, newbound);

6732

assert(var !=

);

6735

assert(!

(

, oldbound, newbound) || (newbound != oldbound && newbound * oldbound <= 0.0));

6737

assert(var->

->scip);

6748 SCIPsetDebugMsg

(

"issue GUBCHANGED event for variable <%s>: %g -> %g\n"

, var->

, oldbound, newbound);

6768

assert(var !=

);

6772

assert(var->

->scip);

6780 SCIPsetDebugMsg

(

"issue GHOLEADDED event for variable <%s>: (%.15g,%.15g)\n"

, var->

, left, right);

6797

assert(var !=

);

6799

assert(var->

->scip);

6800

assert(stat !=

);

6848

assert(var !=

);

6852

assert(blkmem !=

);

6854

assert(var->

->scip);

6855

assert(stat !=

);

6904 SCIPsetDebugMsg

(

" -> adjust lower bound change <%s>: %g -> %g due to new global lower bound %g\n"

6939

assert(parentvar !=

);

6951 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

6968

parentnewbound = newbound;

6984

parentnewbound = -newbound;

7024

assert(var !=

);

7028

assert(blkmem !=

);

7030

assert(var->

->scip);

7031

assert(stat !=

);

7079 SCIPsetDebugMsg

(

" -> adjust upper bound change <%s>: %g -> %g due to new global upper bound %g\n"

7114

assert(parentvar !=

);

7126 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

7142

parentnewbound = newbound;

7157

parentnewbound = -newbound;

7194

assert(var !=

);

7195

assert(blkmem !=

);

7197

assert(var->

->scip);

7237

cliquetable, newbound) );

7281

childnewbound = newbound;

7296

childnewbound = -newbound;

7308 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

7342

assert(var !=

);

7343

assert(blkmem !=

);

7345

assert(var->

->scip);

7429

childnewbound = newbound;

7444

childnewbound = -newbound;

7456 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

7482

assert(var !=

);

7487

assert(var->

->scip);

7505

assert(var !=

);

7510

assert(var->

->scip);

7539 switch

( boundtype )

7542 return SCIPvarChgLbGlobal

(var, blkmem,

, stat, lp, branchcand, eventqueue, cliquetable, newbound);

7544 return SCIPvarChgUbGlobal

(var, blkmem,

, stat, lp, branchcand, eventqueue, cliquetable, newbound);

7564

assert(var !=

);

7567

assert(!

(

, oldbound, newbound) || newbound == var->

|| (newbound != oldbound && newbound * oldbound <= 0.0));

7569

assert(var->

->scip);

7580 SCIPsetDebugMsg

(

"issue LBCHANGED event for variable <%s>: %g -> %g\n"

, var->

, oldbound, newbound);

7602

assert(var !=

);

7605

assert(!

(

, oldbound, newbound) || newbound == var->

|| (newbound != oldbound && newbound * oldbound <= 0.0));

7607

assert(var->

->scip);

7618 SCIPsetDebugMsg

(

"issue UBCHANGED event for variable <%s>: %g -> %g\n"

, var->

, oldbound, newbound);

7659

assert(var !=

);

7661

assert(var->

->scip);

7718

assert(parentvar !=

);

7730 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

7751 if

( parentnewbound > parentvar->

)

7755

parentnewbound = parentvar->

;

7759

parentnewbound = newbound;

7779 if

( parentnewbound < parentvar->glbdom.lb )

7783

parentnewbound = parentvar->

;

7787

parentnewbound = -newbound;

7826

assert(var !=

);

7828

assert(var->

->scip);

7885

assert(parentvar !=

);

7897 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

7917 if

( parentnewbound < parentvar->glbdom.lb )

7921

parentnewbound = parentvar->

;

7925

parentnewbound = newbound;

7944 if

( parentnewbound > parentvar->

)

7948

parentnewbound = parentvar->

;

7952

parentnewbound = -newbound;

7988

assert(var !=

);

7989

assert(blkmem !=

);

7991

assert(var->

->scip);

8014

&& !(newbound != var->

&& newbound * var->

<= 0.0) )

8055

childnewbound = newbound;

8070

childnewbound = -newbound;

8082 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

8115

assert(var !=

);

8116

assert(blkmem !=

);

8118

assert(var->

->scip);

8141

&& !(newbound != var->

&& newbound * var->

<= 0.0) )

8181

childnewbound = newbound;

8196

childnewbound = -newbound;

8208 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

8243 switch

( boundtype )

8263

assert(var !=

);

8265

assert(var->

->scip);

8266

assert(lp !=

);

8288 SCIPerrorMessage

(

"cannot change variable's bounds in dive for LOOSE variables\n"

);

8305

childnewbound = newbound;

8316

childnewbound = -newbound;

8327 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

8353

assert(var !=

);

8355

assert(var->

->scip);

8356

assert(lp !=

);

8378 SCIPerrorMessage

(

"cannot change variable's bounds in dive for LOOSE variables\n"

);

8395

childnewbound = newbound;

8406

childnewbound = -newbound;

8417 SCIPerrorMessage

(

"cannot change the bounds of a multi-aggregated variable.\n"

);

8453

assert(var !=

);

8455

assert(var->

->scip);

8519

assert(var !=

);

8521

assert(var->

->scip);

8585

assert(var !=

);

8587

assert(var->

->scip);

8651

assert(var !=

);

8653

assert(var->

->scip);

8710

assert(var !=

);

8715

assert(var->

->scip);

8768

assert(var !=

);

8769

assert(added !=

);

8770

assert(blkmem !=

);

8818

assert(parentvar !=

);

8823

parentnewleft = left;

8824

parentnewright = right;

8831 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

8870

assert(blkmem !=

);

8873

parentnewleft, parentnewright, &localadded) );

8895

assert(var !=

);

8897

assert(blkmem !=

);

8898

assert(added !=

);

8920

left, right, added) );

8971

childnewleft, childnewright, added) );

8975 SCIPerrorMessage

(

"cannot add a hole of a multi-aggregated variable.\n"

);

8987

childnewleft, childnewright, added) );

9016

assert(var !=

);

9017

assert(added !=

);

9018

assert(blkmem !=

);

9049#ifdef SCIP_DISABLED_CODE 9065

assert(parentvar !=

);

9070

parentnewleft = left;

9071

parentnewright = right;

9078 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

9117

assert(blkmem !=

);

9120

parentnewleft, parentnewright, &localadded) );

9142

assert(var !=

);

9147

assert(var->

->scip);

9149

assert(blkmem !=

);

9150

assert(added !=

);

9170

left, right, added) );

9210

childnewleft, childnewright, added) );

9214 SCIPerrorMessage

(

"cannot add domain hole to a multi-aggregated variable.\n"

);

9244

assert(var !=

);

9246

assert(var->

->scip);

9279

assert(var !=

);

9400

assert(redundant !=

);

9401

assert(infeasible !=

);

9441

assert(infeasible !=

);

9443

*infeasible =

;

9452

*infeasible =

;

9461

assert(tree !=

);

9462

assert(transprob !=

);

9473 if

( nbdchgs !=

)

9482

*infeasible =

;

9491

assert(tree !=

);

9492

assert(transprob !=

);

9503 if

( nbdchgs !=

)

9544

assert(var !=

);

9549

assert(infeasible !=

);

9550

assert(added !=

);

9555

*infeasible =

;

9559 checkImplic

(

, implvar, impltype, implbound, &redundant, &conflict);

9560

assert(!redundant || !conflict);

9564 if

( var == implvar )

9589 SCIP_CALL

(

applyImplic

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

9590

cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );

9612

vals[0] = varfixing;

9616 SCIP_CALL

(

SCIPcliquetableAdd

(cliquetable, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

9617

eventqueue, vars, vals, 2,

, &conflict, nbdchgs) );

9629

isshortcut, &conflict, added) );

9632

assert(!conflict || !(*added));

9644

assert(tree !=

);

9645

assert(transprob !=

);

9670 if

( nbdchgs !=

)

9708

varfixing ? implbound - ub : ub - implbound, varfixing ? ub : implbound) );

9716

varfixing ? implbound - lb : lb - implbound, varfixing ? lb : implbound) );

9752

*infeasible =

;

9769 while

( i >= 0 && !(*infeasible) )

9773

assert(implvars[i] != implvar);

9780 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,

9781

eventqueue, varfixing, implvars[i], impltypes[i], implbounds[i],

, infeasible, nbdchgs, &added) );

9784

i =

(i, nimpls);

9823

assert(var !=

);

9826

assert(implvar !=

);

9828

assert(infeasible !=

);

9831 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable, branchcand,

9832

eventqueue, varfixing, implvar, impltype, implbound,

, infeasible, nbdchgs, &added) );

9834 if

( *infeasible || var == implvar || !transitive || !added )

9848

cliquetable, branchcand, eventqueue, varfixing, implvar, implvarfixing, infeasible, nbdchgs) );

9851 if

( !(*infeasible) )

9854

cliquetable, branchcand, eventqueue, !implvarfixing, var, !varfixing, infeasible, nbdchgs) );

9880 while

( i >= 0 && !(*infeasible) )

9882

assert(vlbvars[i] != implvar);

9907

vbimplbound = (implbound - vlbconstants[i])/vlbcoefs[i];

9908 if

( vlbcoefs[i] >= 0.0 )

9911 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

9913

infeasible, nbdchgs, &added) );

9918 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

9920

infeasible, nbdchgs, &added) );

9923

i =

(i, nvlbvars);

9950 while

( i >= 0 && !(*infeasible) )

9952

assert(vubvars[i] != implvar);

9977

vbimplbound = (implbound - vubconstants[i])/vubcoefs[i];

9978 if

( vubcoefs[i] >= 0.0 )

9981 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

9983

infeasible, nbdchgs, &added) );

9988 SCIP_CALL

(

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

9990

infeasible, nbdchgs, &added) );

9993

i =

(i, nvubvars);

10028

assert(var !=

);

10030

assert(var->

->scip);

10032

assert(infeasible !=

);

10036

*infeasible =

;

10037 if

( nbdchgs !=

)

10045

cliquetable, branchcand, eventqueue, vlbvar, vlbcoef, vlbconstant, transitive, infeasible, nbdchgs) );

10053 SCIPsetDebugMsg

(

" -> transformed to variable lower bound <%s> >= %g<%s> + %g\n"

10057 if

( var == vlbvar )

10063

*infeasible =

;

10079

*infeasible =

;

10091

assert(tree !=

);

10092

assert(transprob !=

);

10103 if

( nbdchgs !=

)

10118

*infeasible =

;

10130

assert(tree !=

);

10131

assert(transprob !=

);

10142 if

( nbdchgs !=

)

10152

*infeasible =

;

10160

assert(tree !=

);

10161

assert(transprob !=

);

10172 if

( nbdchgs !=

)

10186

assert(vlbcoef != 0.0);

10197 if

( vlbcoef >= 0.0 )

10207

*infeasible =

;

10219

assert(tree !=

);

10220

assert(transprob !=

);

10232 if

( nbdchgs !=

)

10235

maxvlb = vlbcoef * zub + vlbconstant;

10237

minvlb = vlbcoef * zlb + vlbconstant;

10242

maxvlb = vlbcoef * zub + vlbconstant;

10244

minvlb = vlbcoef * zlb + vlbconstant;

10257

*infeasible =

;

10269

assert(tree !=

);

10270

assert(transprob !=

);

10282 if

( nbdchgs !=

)

10285

maxvlb = vlbcoef * zlb + vlbconstant;

10287

minvlb = vlbcoef * zub + vlbconstant;

10292

maxvlb = vlbcoef * zlb + vlbconstant;

10294

minvlb = vlbcoef * zub + vlbconstant;

10297 if

( maxvlb < minvlb )

10307

*infeasible =

;

10319

assert(tree !=

);

10320

assert(transprob !=

);

10332 if

( nbdchgs !=

)

10346 if

( vlbcoef >= 0.0 )

10348

vlbcoef = maxvlb - minvlb;

10349

vlbconstant = minvlb;

10353

vlbcoef = minvlb - maxvlb;

10354

vlbconstant = maxvlb;

10374

cliquetable, branchcand, eventqueue, (vlbcoef >= 0.0), var,

SCIP_BOUNDTYPE_LOWER

, maxvlb, transitive,

10375

infeasible, nbdchgs) );

10384

implbound = -vlbconstant/vlbcoef;

10389 if

( vlbcoef >= 0 )

10396

implbound, transitive, infeasible, nbdchgs) );

10419

*infeasible =

;

10451 SCIP_CALL

(

SCIPvarAddVub

(var->

, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

10452

branchcand, eventqueue, vlbvar, -vlbcoef, var->

negate

constant

- vlbconstant, transitive, infeasible,

10489

assert(var !=

);

10491

assert(var->

->scip);

10493

assert(infeasible !=

);

10497

*infeasible =

;

10498 if

( nbdchgs !=

)

10506

cliquetable, branchcand, eventqueue, vubvar, vubcoef, vubconstant, transitive, infeasible, nbdchgs) );

10514 SCIPsetDebugMsg

(

" -> transformed to variable upper bound <%s> <= %g<%s> + %g\n"

10518 if

( var == vubvar )

10524

*infeasible =

;

10540

*infeasible =

;

10552

assert(tree !=

);

10553

assert(transprob !=

);

10564 if

( nbdchgs !=

)

10579

*infeasible =

;

10591

assert(tree !=

);

10592

assert(transprob !=

);

10603 if

( nbdchgs !=

)

10613

*infeasible =

;

10621

assert(tree !=

);

10622

assert(transprob !=

);

10633 if

( nbdchgs !=

)

10647

assert(vubcoef != 0.0);

10658 if

( vubcoef >= 0.0 )

10668

*infeasible =

;

10680

assert(tree !=

);

10681

assert(transprob !=

);

10693 if

( nbdchgs !=

)

10696

minvub = vubcoef * zlb + vubconstant;

10698

maxvub = vubcoef * zub + vubconstant;

10703

maxvub = vubcoef * zub + vubconstant;

10705

minvub = vubcoef * zlb + vubconstant;

10718

*infeasible =

;

10730

assert(tree !=

);

10731

assert(transprob !=

);

10743 if

( nbdchgs !=

)

10746

minvub = vubcoef * zub + vubconstant;

10748

maxvub = vubcoef * zlb + vubconstant;

10753

minvub = vubcoef * zub + vubconstant;

10755

maxvub = vubcoef * zlb + vubconstant;

10758 if

( minvub > maxvub )

10768

*infeasible =

;

10780

assert(tree !=

);

10781

assert(transprob !=

);

10793 if

( nbdchgs !=

)

10807 if

( vubcoef >= 0.0 )

10809

vubcoef = maxvub - minvub;

10810

vubconstant = minvub;

10814

vubcoef = minvub - maxvub;

10815

vubconstant = maxvub;

10835

cliquetable, branchcand, eventqueue, (vubcoef < 0.0), var,

SCIP_BOUNDTYPE_UPPER

, minvub, transitive,

10836

infeasible, nbdchgs) );

10846

(1.0-vubconstant)/vubcoef, transitive, infeasible, nbdchgs) );

10869

*infeasible =

;

10901 SCIP_CALL

(

SCIPvarAddVlb

(var->

, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

10902

branchcand, eventqueue, vubvar, -vubcoef, var->

negate

constant

- vubconstant, transitive, infeasible,

10942

assert(var !=

);

10944

assert(var->

->scip);

10946

assert(infeasible !=

);

10948

*infeasible =

;

10949 if

( nbdchgs !=

)

10957

cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,

10971 SCIP_CALL

(

applyImplic

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

10972

cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );

10981 SCIP_CALL

(

varAddTransitiveImplic

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

10982

branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );

10991 SCIP_CALL

(

applyImplic

(blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand, eventqueue,

10992

cliquetable, implvar, impltype, implbound, infeasible, nbdchgs) );

11015

cliquetable, branchcand, eventqueue, varfixing, implvar, impltype, implbound, transitive, infeasible,

11021

cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible,

11045

cliquetable, branchcand, eventqueue, !varfixing, implvar, impltype, implbound, transitive, infeasible, nbdchgs) );

11053 SCIP_CALL

(

SCIPvarAddImplic

(implvar, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

11056

infeasible, nbdchgs) );

11071

cliquetable, branchcand, eventqueue, implvar, (impltype ==

SCIP_BOUNDTYPE_UPPER

) ? 1.0 : -1.0,

11080

cliquetable, branchcand, eventqueue, implvar, (impltype ==

SCIP_BOUNDTYPE_UPPER

) ? -1.0 : 1.0,

11090 SCIP_CALL

(

SCIPvarAddVub

(implvar, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

11091

branchcand, eventqueue, var->

, (varfixing) ? 1.0 : -1.0,

11092

(varfixing) ? 0.0 : 1.0, transitive, infeasible, nbdchgs) );

11099 SCIP_CALL

(

SCIPvarAddVlb

(implvar, blkmem,

, stat, transprob, origprob, tree, reopt, lp, cliquetable,

11100

branchcand, eventqueue, var->

, (varfixing) ? -1.0 : 1.0, (varfixing) ? 1.0 : 0.0,

11101

transitive, infeasible, nbdchgs) );

11126

assert(var !=

);

11127

assert(implvar !=

);

11166

assert(lb !=

);

11167

assert(ub !=

);

11178 if

( bounds ==

)

11181 if

( lowerpos >= 0 )

11182

*lb = bounds[lowerpos];

11184 if

( upperpos >= 0 )

11185

*ub = bounds[upperpos];

11208

assert(var !=

);

11210

assert(var->

->scip);

11211

assert(infeasible !=

);

11213

*infeasible =

;

11215 if

( value ==

)

11218

*infeasible =

;

11219 else if

( var->

> 0.5 )

11226

assert(tree !=

);

11227

assert(transprob !=

);

11238 if

( nbdchgs !=

)

11245

*infeasible =

;

11246 else if

( var->

< 0.5 )

11253

assert(tree !=

);

11254

assert(transprob !=

);

11265 if

( nbdchgs !=

)

11297

assert(var !=

);

11299

assert(var->

->scip);

11301

assert(infeasible !=

);

11303

*infeasible =

;

11331 SCIP_CALL

(

SCIPvarFixBinary

(var, blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

11332

eventqueue, cliquetable, !value, infeasible, nbdchgs) );

11338 if

( oppositeentry )

11348 for

( i = 0; i < nvars && !(*infeasible); ++i )

11350 if

( vars[i] == var )

11353 SCIP_CALL

(

SCIPvarFixBinary

(vars[i], blkmem,

, stat, transprob, origprob, tree, reopt, lp, branchcand,

11354

eventqueue, cliquetable, !values[i], infeasible, nbdchgs) );

11375

assert(vars !=

);

11376

assert(values !=

);

11379

assert(blkmem !=

);

11380

assert(clique !=

);

11382 for

( v = nvars - 1; v >= 0; --v )

11409

assert(var !=

);

11430

assert(var !=

);

11448

assert(var !=

);

11491

assert(var1 !=

);

11492

assert(var2 !=

);

11514

assert(var !=

);

11516

assert(var->

->scip);

11520

branchfactor =

(branchfactor,

eps

);

11534

assert(parentvar !=

);

11546 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

11576

assert(var !=

);

11578

assert(var->

->scip);

11579

assert(branchfactor >= 0.0);

11647

assert(var !=

);

11649 SCIPdebugMessage

(

"process changing branch priority of <%s> from %d to %d\n"

11662

assert(parentvar !=

);

11674 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

11702

assert(var !=

);

11767

assert(var !=

);

11769 SCIPdebugMessage

(

"process changing branch direction of <%s> from %u to %d\n"

11782

assert(parentvar !=

);

11794 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

11833

assert(var !=

);

11917

assert(var1 !=

);

11918

assert(var2 !=

);

11927

assert(var1 !=

);

11928

assert(var2 !=

);

11935

assert(var1 == var2);

11955

assert(var1 !=

);

11956

assert(var2 !=

);

11964

assert(var1 == var2);

11986 else if

( obj1 > obj2 )

12001 if

( key1 == key2 )

12028 int

activevarssize;

12041

assert(nvars !=

);

12042

assert(vars !=

|| *nvars == 0);

12043

assert(varssize >= *nvars);

12044

assert(requiredsize !=

);

12052

activevarssize = *nvars;

12054

tmpvarssize = *nvars;

12061

noldtmpvars = ntmpvars;

12064 SCIPsortPtr

((

void

**)tmpvars, SCIPvarComp, ntmpvars);

12065 for

( v = ntmpvars - 1; v > 0; --v )

12071

tmpvars[v] = tmpvars[ntmpvars];

12075 if

( noldtmpvars > ntmpvars )

12076 SCIPsortPtr

((

void

**)tmpvars, SCIPvarComp, ntmpvars);

12079 while

( ntmpvars >= 1 )

12082

var = tmpvars[ntmpvars];

12083

assert( var !=

);

12090 SCIPerrorMessage

(

"original variable has no transformed variable attached\n"

);

12111 if

( nactivevars >= activevarssize )

12113

activevarssize *= 2;

12115

assert(nactivevars < activevarssize);

12117

activevars[nactivevars] = var;

12127 if

( nmultvars + ntmpvars > tmpvarssize )

12129 while

( nmultvars + ntmpvars > tmpvarssize )

12132

assert(nmultvars + ntmpvars <= tmpvarssize);

12141

ntmpvars += nmultvars;

12142

noldtmpvars = ntmpvars;

12145 SCIPsortPtr

((

void

**)tmpvars, SCIPvarComp, ntmpvars);

12146 for

( v = ntmpvars - 1; v > 0; --v )

12152

tmpvars[v] = tmpvars[ntmpvars];

12156 if

( noldtmpvars > ntmpvars )

12157 SCIPsortPtr

((

void

**)tmpvars, SCIPvarComp, ntmpvars);

12173 SCIPsortPtr

((

void

**)activevars, SCIPvarComp, nactivevars);

12176

v = nactivevars - 1;

12183

activevars[v] = activevars[nactivevars];

12187

*requiredsize = nactivevars;

12189 if

( varssize >= *requiredsize )

12191

assert(vars !=

);

12193

*nvars = *requiredsize;

12213

assert(vars !=

|| nvars == 0);

12215 for

( v = nvars - 1; v >= 0; --v )

12217

assert(vars !=

);

12218

assert(vars[v] !=

);

12221

assert(vars[v] !=

);

12232

assert(var !=

);

12240

assert(retvar !=

);

12247 SCIPerrorMessage

(

"original variable has no transformed variable attached\n"

);

12296

assert(vars !=

);

12297

assert(*vars !=

|| nvars == 0);

12298

assert(negatedarr !=

);

12299

assert(*negatedarr !=

|| nvars == 0);

12301 for

( v = nvars - 1; v >= 0; --v )

12303

var = &((*vars)[v]);

12304

negated = &((*negatedarr)[v]);

12329

assert(var !=

);

12330

assert(*var !=

);

12331

assert(negated !=

);

12335

orignegated = *negated;

12343 if

( (*var)->data.original.transvar ==

)

12356 if

( (*var)->data.multaggr.nvars == 1 )

12358

assert( (*var)->data.multaggr.vars !=

);

12359

assert( (*var)->data.multaggr.scalars !=

);

12361

assert(!

((*var)->data.multaggr.scalars[0], 1e-06));

12371 if

(

((*var)->data.multaggr.constant, -1.0, 1e-06) || (

((*var)->data.multaggr.constant, 1.0, 1e-06) &&

((*var)->data.multaggr.scalars[0], 1.0, 1e-06)) )

12373

assert(

((*var)->data.multaggr.scalars[0], 1.0, 1e-06));

12382 if

( !

(

REALABS

((*var)->data.multaggr.scalars[0]), 1.0, 1e-06) )

12392

assert(

((*var)->data.multaggr.constant, 1e-06) ||

((*var)->data.multaggr.constant, 1.0, 1e-06)

12393

((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1e-06)

12394

((*var)->data.multaggr.constant + (*var)->data.multaggr.scalars[0], 1.0, 1e-06));

12396 if

( !

((*var)->data.multaggr.constant, 1e-06) && !

((*var)->data.multaggr.constant, 1.0, 1e-06) )

12402

assert(

((*var)->data.multaggr.scalars[0], 1.0, 1e-06) ||

((*var)->data.multaggr.scalars[0], -1.0, 1e-06));

12404 if

(

((*var)->data.multaggr.constant, 1e-06) )

12410

assert(

((*var)->data.multaggr.scalars[0], -1.0, 1e-06) ?

12416

assert(

((*var)->data.multaggr.scalars[0], -1.0, 1e-06));

12418

constant += (*negated) != orignegated ? -1.0 : 1.0;

12421

*negated = !(*negated);

12431

assert((*var)->data.aggregate.var !=

);

12432

assert(

((*var)->data.aggregate.scalar, 1.0, 1e-06) ||

((*var)->data.aggregate.scalar, -1.0, 1e-06));

12433

assert(

EPSLE

((*var)->data.aggregate.var->glbdom.ub - (*var)->data.aggregate.var->glbdom.lb, 1.0, 1e-06));

12435

constant += (*negated) != orignegated ? -(*var)->data.aggregate.constant : (*var)->data.aggregate.constant;

12438

*negated = ((*var)->data.aggregate.scalar > 0.0) ? *negated : !(*negated);

12443

assert((*var)->negatedvar !=

);

12445

constant += (*negated) != orignegated ? -1.0 : 1.0;

12448

*negated = !(*negated);

12462

assert(

(constant, 1e-06) ||

(constant, 1.0, 1e-06));

12463

assert(

(constant, 1e-06) == ((*negated) == orignegated));

12483

assert(var !=

);

12484

assert(*var !=

);

12486

assert(boundtype !=

);

12488 SCIPdebugMessage

(

"get probvar bound %g of type %d of variable <%s>\n"

, *

bound

, *boundtype, (*var)->name);

12493 if

( (*var)->data.original.transvar ==

)

12495 SCIPerrorMessage

(

"original variable has no transformed variable attached\n"

);

12509 if

( (*var)->data.multaggr.nvars == 1 )

12511

assert( (*var)->data.multaggr.vars !=

);

12512

assert( (*var)->data.multaggr.scalars !=

);

12513

assert( (*var)->data.multaggr.scalars[0] != 0.0 );

12515

(*bound) /= (*var)->data.multaggr.scalars[0];

12516

(*bound) -= (*var)->data.multaggr.constant/(*var)->data.multaggr.scalars[0];

12517 if

( (*var)->data.multaggr.scalars[0] < 0.0 )

12530

assert((*var)->data.aggregate.var !=

);

12531

assert((*var)->data.aggregate.scalar != 0.0);

12533

(*bound) /= (*var)->data.aggregate.scalar;

12534

(*bound) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;

12535 if

( (*var)->data.aggregate.scalar < 0.0 )

12547

assert((*var)->negatedvar !=

);

12549

assert((*var)->negatedvar->negatedvar == *var);

12550

(*bound) = (*var)->data.negate.constant - *

bound

;

12576

assert(var !=

);

12577

assert(*var !=

);

12578

assert(left !=

);

12579

assert(right !=

);

12581 SCIPdebugMessage

(

"get probvar hole (%g,%g) of variable <%s>\n"

, *left, *right, (*var)->name);

12586 if

( (*var)->data.original.transvar ==

)

12588 SCIPerrorMessage

(

"original variable has no transformed variable attached\n"

);

12602

assert((*var)->data.aggregate.var !=

);

12603

assert((*var)->data.aggregate.scalar != 0.0);

12606

(*left) /= (*var)->data.aggregate.scalar;

12607

(*right) /= (*var)->data.aggregate.scalar;

12610

(*left) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;

12611

(*right) -= (*var)->data.aggregate.constant/(*var)->data.aggregate.scalar;

12616 if

( (*var)->data.aggregate.scalar < 0.0 )

12627

assert((*var)->negatedvar !=

);

12629

assert((*var)->negatedvar->negatedvar == *var);

12632

(*left) = (*var)->data.negate.constant - (*left);

12633

(*right) = (*var)->data.negate.constant - (*right);

12662

assert(var !=

);

12663

assert(scalar !=

);

12664

assert(constant !=

);

12666 while

( *var !=

)

12671 if

( (*var)->data.original.transvar ==

)

12673 SCIPerrorMessage

(

"original variable has no transformed variable attached\n"

);

12688

assert(*scalar != 0.0);

12689 if

( (*scalar) * (*var)->glbdom.lb > 0.0 )

12695

(*constant) += *scalar * (*var)->glbdom.lb;

12711 if

( (*var)->data.multaggr.nvars == 1 )

12713

assert((*var)->data.multaggr.vars !=

);

12714

assert((*var)->data.multaggr.scalars !=

);

12715

assert((*var)->data.multaggr.vars[0] !=

);

12725 if

( (*scalar) * (*var)->data.multaggr.constant > 0 )

12738

(*constant) += *scalar * (*var)->data.multaggr.constant;

12740

(*scalar) *= (*var)->data.multaggr.scalars[0];

12747

assert((*var)->data.aggregate.var !=

);

12751

(*constant) += *scalar * (*var)->data.aggregate.constant;

12752

(*scalar) *= (*var)->data.aggregate.scalar;

12757

assert((*var)->negatedvar !=

);

12759

assert((*var)->negatedvar->negatedvar == *var);

12763

(*constant) += *scalar * (*var)->data.negate.constant;

12790

assert(var !=

);

12791

assert(*var !=

);

12792

assert(scalar !=

);

12793

assert(constant !=

);

12800 if

( (*var)->nparentvars == 0 )

12806

((*var)->negatedvar->nparentvars == 0 || (*var)->negatedvar->parentvars[0] != *var) )

12809

*constant -= (*var)->data.negate.constant * (*scalar);

12827

assert(parentvar !=

);

12838 SCIPerrorMessage

(

"column, loose, fixed or multi-aggregated variable cannot be the parent of a variable\n"

);

12861

assert( parentvar !=

);

12874

assert(var !=

);

12881

assert(parentvar !=

);

12886

assert( parentvar !=

);

12898

assert(var !=

);

12920 SCIPerrorMessage

(

"cannot get the objective value of a multiple aggregated variable\n"

);

12945

assert(var !=

);

12947

assert(var->

->scip);

12990 SCIPerrorMessage

(

"getting the bounds of a multiple aggregated variable is not implemented yet\n"

);

13015

assert(var !=

);

13017

assert(var->

->scip);

13059 SCIPerrorMessage

(

"cannot get the bounds of a multi-aggregated variable.\n"

);

13081

assert(var !=

);

13157

assert(var !=

);

13205

assert(var !=

);

13282

assert(var !=

);

13296

assert(var !=

);

13298

assert(var->

->scip);

13324 if

( rootredcost > 0.0 )

13329

cutoffbound = (

bound

- rootsol) * rootredcost + rootlpobjval;

13332 if

( cutoffbound > currcutoffbound )

13365

assert(var !=

);

13439

assert(col !=

);

13472#define MAX_CLIQUELENGTH 50 13495#ifdef SCIP_MORE_DEBUG 13502 if

( ncliques > 0 )

13521

assert(prob !=

);

13531

assert(cliques !=

);

13533 for

( c = ncliques - 1; c >= 0; --c )

13535

clique = cliques[c];

13536

assert(clique !=

);

13538

assert(nclqvars > 0);

13545

assert(clqvars !=

);

13546

assert(clqvalues !=

);

13550 for

( v = nclqvars - 1; v >= 0; --v )

13552

clqvar = clqvars[v];

13553

assert(clqvar !=

);

13560

assert(0 < probindex && probindex < nentries);

13562#ifdef SCIP_DISABLED_CODE 13566

assert(!entries[probindex] || entries[probindex] == (clqvalues[v] ? probindex : -probindex));

13568 if

( entries[probindex] == 0 )

13570

ids[nids] = probindex;

13574

entries[probindex] = (clqvalues[v] ? probindex : -probindex);

13581

assert(probvars !=

);

13584 for

( v = nids - 1; v >= 0; --v )

13587

assert(0 <

id

< nentries);

13588

assert(entries[

id

] != 0);

13589

assert(probvars[

id

- 1] !=

);

13594 if

( (entries[

id

] > 0) != varfixing )

13600

implredcost += redcost;

13610#ifdef SCIP_MORE_DEBUG 13636 for

( v = nvars - 1; v >= 0; --v )

13639

assert(implvar !=

);

13649

assert(col !=

);

13653 if

( lpissolbasic )

13664

redcost *= (lb - bounds[v]);

13666

redcost *= (bounds[v] - lb);

13674

redcost *= (bounds[v] - ub);

13676

redcost *= (ub - bounds[v]);

13690

redcost *= (lb - bounds[v]);

13692

redcost *= (bounds[v] - lb);

13700

redcost *= (bounds[v] - ub);

13702

redcost *= (ub - bounds[v]);

13708

implredcost += redcost;

13712#ifdef SCIP_MORE_DEBUG 13713 SCIPsetDebugMsg

(

"variable <%s> incl. cliques (%d) and implications (%d) has implied reduced cost of %g\n"

13717 return

implredcost;

13730

assert(var !=

);

13794

assert(var !=

);

13828

assert(var !=

);

13862

assert(var !=

);

13878

assert(var !=

);

13879

assert(relaxation !=

);

13881

assert(var->

->scip);

13900 SCIPerrorMessage

(

"cannot set relaxation solution value for variable <%s> fixed to %.15g to different value %.15g\n"

13912 SCIPerrorMessage

(

"cannot set solution value for multiple aggregated variable\n"

);

13940

assert(var !=

);

13942

assert(var->

->scip);

14007

assert(var !=

);

14020

assert(var !=

);

14022

assert(var->

->scip);

14039 SCIPerrorMessage

(

"cannot set NLP solution value for variable <%s> fixed to %.15g to different value %.15g\n"

14052 SCIPerrorMessage

(

"cannot set solution value for multiple aggregated variable\n"

);

14077

assert(var !=

);

14137 int

* closestvlbidx

14142

assert(var !=

);

14143

assert(stat !=

);

14145

assert(var->

->scip);

14146

assert(closestvlb !=

);

14147

assert(closestvlbidx !=

);

14149

*closestvlbidx = -1;

14168

assert(0 <= i && i < nvlbs);

14170

*closestvlbidx = i;

14171

*closestvlb = vlbcoefs[i] *

SCIPvarGetLPSol

(vlbvars[i]) + vlbconsts[i];

14176 for

( i = 0; i < nvlbs; i++ )

14183 if

( vlbsol > *closestvlb )

14185

*closestvlb = vlbsol;

14186

*closestvlbidx = i;

14212 int

* closestvubidx

14217

assert(var !=

);

14219

assert(var->

->scip);

14220

assert(closestvub !=

);

14221

assert(closestvubidx !=

);

14223

*closestvubidx = -1;

14242

assert(0 <= i && i < nvubs);

14244

*closestvubidx = i;

14245

*closestvub = vubcoefs[i] *

SCIPvarGetLPSol

(vubvars[i]) + vubconsts[i];

14250 for

( i = 0; i < nvubs; i++ )

14257 if

( vubsol < *closestvub )

14259

*closestvub = vubsol;

14260

*closestvubidx = i;

14292

assert(var !=

);

14294

assert(var->

->scip);

14295

assert(row !=

);

14308 SCIPerrorMessage

(

"cannot add untransformed original variable <%s> to LP row <%s>\n"

, var->

, row->

);

14378#ifdef SCIP_HISTORYTOFILE 14380const char

* historypath=

"."

;

14397

assert(var !=

);

14399

assert(var->

->scip);

14400

assert(stat !=

);

14411 SCIPerrorMessage

(

"cannot update pseudo costs of original untransformed variable\n"

);

14432#ifdef SCIP_HISTORYTOFILE 14435 char

filename[256];

14442

f = fopen(filename,

"a"

);

14445

fprintf(f,

"%lld %s \t %lld \t %lld \t %lld \t %d \t %15.9f \t %.3f\n"

14461 SCIPerrorMessage

(

"cannot update pseudo cost values of a fixed variable\n"

);

14471 SCIPerrorMessage

(

"cannot update pseudo cost values of a multi-aggregated variable\n"

);

14493

assert(var !=

);

14494

assert(stat !=

);

14542

assert(var !=

);

14543

assert(stat !=

);

14586

assert(var !=

);

14631

assert(var !=

);

14696 return MIN

(upscore, downscore);

14706

assert(var !=

);

14719 if

( onlycurrentrun )

14769 if

( onlycurrentrun )

14774

assert(count >= 1.9);

14776

confidencebound /= count;

14777

confidencebound = sqrt(confidencebound);

14784

confidencebound = 0.0;

14786 return

confidencebound;

14810

size =

(downsize, upsize);

14820 if

( downsize >= 1.9 )

14826

normval =

(1.0, normval);

14828

relerrordown /= normval;

14831

relerrordown = 0.0;

14833 if

( upsize >= 1.9 )

14839

normval =

(1.0, normval);

14840

relerrorup /= normval;

14846

relerror =

(relerrorup, relerrordown);

14848 return

(relerror <= threshold);

14890 if

( varx == vary )

14897 if

( countx <= 1.9 || county <= 1.9 )

14955 if

( count <= 1.9 )

14994 SCIPerrorMessage

(

"Confidence level set to unknown value <%d>"

, (

int

)clevel);

14999 return

(probability >= problimit);

15012

assert(var !=

);

15013

assert(blkmem !=

);

15015

assert(history !=

);

15017

(*history) =

;

15044 if

( !

->history_valuebased )

15069

assert(var !=

);

15084 SCIPerrorMessage

(

"cannot update VSIDS of original untransformed variable\n"

);

15101

assert(history !=

);

15129 SCIPerrorMessage

(

"cannot update VSIDS of a multi-aggregated variable\n"

);

15133

value = 1.0 - value;

15150

assert(var !=

);

15157 SCIPerrorMessage

(

"cannot update VSIDS of original untransformed variable\n"

);

15181 SCIPerrorMessage

(

"cannot update VSIDS of a multi-aggregated variable\n"

);

15205

assert(var !=

);

15217 SCIPerrorMessage

(

"cannot update conflict score of original untransformed variable\n"

);

15234

assert(history !=

);

15242 SCIPerrorMessage

(

"cannot update conflict score of a fixed variable\n"

);

15260 SCIPerrorMessage

(

"cannot update conflict score of a multi-aggregated variable\n"

);

15264

value = 1.0 - value;

15282

assert(var !=

);

15283

assert(stat !=

);

15329

assert(var !=

);

15330

assert(stat !=

);

15373

assert(var !=

);

15417

assert(var !=

);

15465

assert(var !=

);

15466

assert(stat !=

);

15478 SCIPerrorMessage

(

"cannot update branching counter of original untransformed variable\n"

);

15497

assert(history !=

);

15505 SCIPerrorMessage

(

"cannot update branching counter of a fixed variable\n"

);

15523 SCIPerrorMessage

(

"cannot update branching counter of a multi-aggregated variable\n"

);

15527

value = 1.0 - value;

15549

assert(var !=

);

15550

assert(stat !=

);

15562 SCIPerrorMessage

(

"cannot update inference counter of original untransformed variable\n"

);

15581

assert(history !=

);

15589 SCIPerrorMessage

(

"cannot update inference counter of a fixed variable\n"

);

15607 SCIPerrorMessage

(

"cannot update inference counter of a multi-aggregated variable\n"

);

15611

value = 1.0 - value;

15633

assert(var !=

);

15634

assert(stat !=

);

15646 SCIPerrorMessage

(

"cannot update cutoff sum of original untransformed variable\n"

);

15665

assert(history !=

);

15691 SCIPerrorMessage

(

"cannot update cutoff sum of a multi-aggregated variable\n"

);

15695

value = 1.0 - value;

15712

assert(var !=

);

15757

assert(var !=

);

15800

assert(var !=

);

15845

assert(var !=

);

15891

assert(var !=

);

15892

assert(stat !=

);

15942

assert(var !=

);

15943

assert(stat !=

);

15948 SCIPerrorMessage

(

"invalid branching direction %d when asking for VSIDS value\n"

, dir);

15992

assert(var !=

);

16037

assert(var !=

);

16081

assert(var !=

);

16082

assert(stat !=

);

16138

assert(var !=

);

16139

assert(stat !=

);

16192

assert(var !=

);

16235

assert(var !=

);

16279

assert(var !=

);

16280

assert(stat !=

);

16326

assert(var !=

);

16327

assert(stat !=

);

16372

assert(var !=

);

16373

assert(stat !=

);

16413

assert(var !=

);

16414

assert(stat !=

);

16415

assert(gmieff >= 0);

16456

assert(var !=

);

16457

assert(stat !=

);

16497

assert(var !=

);

16498

assert(stat !=

);

16499

assert(gmieff >= 0);

16550

assert(bdchginfo !=

);

16553

(*bdchginfo)->oldbound = oldbound;

16554

(*bdchginfo)->newbound = newbound;

16555

(*bdchginfo)->var = var;

16556

(*bdchginfo)->inferencedata.var = var;

16557

(*bdchginfo)->inferencedata.reason.prop =

;

16558

(*bdchginfo)->inferencedata.info = 0;

16559

(*bdchginfo)->bdchgidx.depth = INT_MAX;

16560

(*bdchginfo)->bdchgidx.pos = -1;

16561

(*bdchginfo)->pos = 0;

16563

(*bdchginfo)->boundtype = boundtype;

16564

(*bdchginfo)->inferboundtype = boundtype;

16565

(*bdchginfo)->redundant =

;

16576

assert(bdchginfo !=

);

16593

assert(var !=

);

16649

assert(var !=

);

16725

assert(var !=

);

16730 switch

( varstatus )

16738 if

( bdchgidx ==

)

16745 if

( bdchginfo !=

)

16816 SCIPerrorMessage

(

"cannot get the bounds of a multi-aggregated variable.\n"

);

16844

assert(var !=

);

16849 switch

( varstatus )

16857 if

( bdchgidx ==

)

16864 if

( bdchginfo !=

)

16936 SCIPerrorMessage

(

"cannot get the bounds of a multiple aggregated variable.\n"

);

16984

assert(var !=

);

17008

assert(var !=

);

17045

assert(bdchgidx !=

);

17047 return

bdchgidx->

;

17062

assert(var !=

);

17064

assert(var->

->scip);

17134

assert(var1 !=

);

17135

assert(var2 !=

);

17141

assert(var1 !=

);

17142

assert(var2 !=

);

17189

assert(var !=

);

17190 return

var->

;

17206#undef SCIPboundchgGetNewbound 17207#undef SCIPboundchgGetVar 17208#undef SCIPboundchgGetBoundchgtype 17209#undef SCIPboundchgGetBoundtype 17210#undef SCIPboundchgIsRedundant 17211#undef SCIPdomchgGetNBoundchgs 17212#undef SCIPdomchgGetBoundchg 17213#undef SCIPholelistGetLeft 17214#undef SCIPholelistGetRight 17215#undef SCIPholelistGetNext 17216#undef SCIPvarGetName 17217#undef SCIPvarGetNUses 17218#undef SCIPvarGetData 17219#undef SCIPvarSetData 17220#undef SCIPvarSetDelorigData 17221#undef SCIPvarSetTransData 17222#undef SCIPvarSetDeltransData 17223#undef SCIPvarGetStatus 17224#undef SCIPvarIsOriginal 17225#undef SCIPvarIsTransformed 17226#undef SCIPvarIsNegated 17227#undef SCIPvarGetType 17228#undef SCIPvarIsBinary 17229#undef SCIPvarIsIntegral 17230#undef SCIPvarIsInitial 17231#undef SCIPvarIsRemovable 17232#undef SCIPvarIsDeleted 17233#undef SCIPvarIsDeletable 17234#undef SCIPvarMarkDeletable 17235#undef SCIPvarMarkNotDeletable 17236#undef SCIPvarIsActive 17237#undef SCIPvarGetIndex 17238#undef SCIPvarGetProbindex 17239#undef SCIPvarGetTransVar 17240#undef SCIPvarGetCol 17241#undef SCIPvarIsInLP 17242#undef SCIPvarGetAggrVar 17243#undef SCIPvarGetAggrScalar 17244#undef SCIPvarGetAggrConstant 17245#undef SCIPvarGetMultaggrNVars 17246#undef SCIPvarGetMultaggrVars 17247#undef SCIPvarGetMultaggrScalars 17248#undef SCIPvarGetMultaggrConstant 17249#undef SCIPvarGetNegatedVar 17250#undef SCIPvarGetNegationVar 17251#undef SCIPvarGetNegationConstant 17252#undef SCIPvarGetObj 17253#undef SCIPvarGetLbOriginal 17254#undef SCIPvarGetUbOriginal 17255#undef SCIPvarGetHolelistOriginal 17256#undef SCIPvarGetLbGlobal 17257#undef SCIPvarGetUbGlobal 17258#undef SCIPvarGetHolelistGlobal 17259#undef SCIPvarGetBestBoundGlobal 17260#undef SCIPvarGetWorstBoundGlobal 17261#undef SCIPvarGetLbLocal 17262#undef SCIPvarGetUbLocal 17263#undef SCIPvarGetHolelistLocal 17264#undef SCIPvarGetBestBoundLocal 17265#undef SCIPvarGetWorstBoundLocal 17266#undef SCIPvarGetBestBoundType 17267#undef SCIPvarGetWorstBoundType 17268#undef SCIPvarGetLbLazy 17269#undef SCIPvarGetUbLazy 17270#undef SCIPvarGetBranchFactor 17271#undef SCIPvarGetBranchPriority 17272#undef SCIPvarGetBranchDirection 17273#undef SCIPvarGetNVlbs 17274#undef SCIPvarGetVlbVars 17275#undef SCIPvarGetVlbCoefs 17276#undef SCIPvarGetVlbConstants 17277#undef SCIPvarGetNVubs 17278#undef SCIPvarGetVubVars 17279#undef SCIPvarGetVubCoefs 17280#undef SCIPvarGetVubConstants 17281#undef SCIPvarGetNImpls 17282#undef SCIPvarGetImplVars 17283#undef SCIPvarGetImplTypes 17284#undef SCIPvarGetImplBounds 17285#undef SCIPvarGetImplIds 17286#undef SCIPvarGetNCliques 17287#undef SCIPvarGetCliques 17288#undef SCIPvarGetLPSol 17289#undef SCIPvarGetNLPSol 17290#undef SCIPvarGetBdchgInfoLb 17291#undef SCIPvarGetNBdchgInfosLb 17292#undef SCIPvarGetBdchgInfoUb 17293#undef SCIPvarGetNBdchgInfosUb 17294#undef SCIPvarGetValuehistory 17295#undef SCIPvarGetPseudoSol 17296#undef SCIPvarCatchEvent 17297#undef SCIPvarDropEvent 17298#undef SCIPvarGetVSIDS 17299#undef SCIPvarGetCliqueComponentIdx 17300#undef SCIPvarIsRelaxationOnly 17301#undef SCIPvarMarkRelaxationOnly 17302#undef SCIPbdchgidxGetPos 17303#undef SCIPbdchgidxIsEarlierNonNull 17304#undef SCIPbdchgidxIsEarlier 17305#undef SCIPbdchginfoGetOldbound 17306#undef SCIPbdchginfoGetNewbound 17307#undef SCIPbdchginfoGetVar 17308#undef SCIPbdchginfoGetChgtype 17309#undef SCIPbdchginfoGetBoundtype 17310#undef SCIPbdchginfoGetDepth 17311#undef SCIPbdchginfoGetPos 17312#undef SCIPbdchginfoGetIdx 17313#undef SCIPbdchginfoGetInferVar 17314#undef SCIPbdchginfoGetInferCons 17315#undef SCIPbdchginfoGetInferProp 17316#undef SCIPbdchginfoGetInferInfo 17317#undef SCIPbdchginfoGetInferBoundtype 17318#undef SCIPbdchginfoIsRedundant 17319#undef SCIPbdchginfoHasInferenceReason 17320#undef SCIPbdchginfoIsTighter 17328

assert(boundchg !=

);

17338

assert(boundchg !=

);

17340 return

boundchg->

;

17348

assert(boundchg !=

);

17358

assert(boundchg !=

);

17368

assert(boundchg !=

);

17387

assert(domchg !=

);

17398

assert(holelist !=

);

17408

assert(holelist !=

);

17418

assert(holelist !=

);

17420 return

holelist->

;

17431

assert(var !=

);

17433 return

var->

;

17441

assert(var !=

);

17443 return

var->

nuses

;

17451

assert(var !=

);

17462

assert(var !=

);

17473

assert(var !=

);

17476

var->vardelorig = vardelorig;

17485

assert(var !=

);

17488

var->vartrans = vartrans;

17497

assert(var !=

);

17499

var->vardeltrans = vardeltrans;

17508

assert(var !=

);

17510

var->varcopy = varcopy;

17519

assert(var !=

);

17535

assert(var !=

);

17550

assert(var !=

);

17560

assert(var !=

);

17573

assert(var !=

);

17586

assert(var !=

);

17596

assert(var !=

);

17611

assert(var !=

);

17622

assert(var !=

);

17632

assert(var !=

);

17642

assert(var !=

);

17652

assert(var !=

);

17664

assert(var !=

);

17675

assert(var !=

);

17688

assert(var !=

);

17698

assert(var !=

);

17718

assert(var !=

);

17736

assert(var !=

);

17750

assert(var !=

);

17760

assert(var !=

);

17770

assert(var !=

);

17772 return

var->

index

;

17780

assert(var !=

);

17790

assert(var !=

);

17801

assert(var !=

);

17812

assert(var !=

);

17822

assert(var !=

);

17834

assert(var !=

);

17846

assert(var !=

);

17858

assert(var !=

);

17870

assert(var !=

);

17882

assert(var !=

);

17894

assert(var !=

);

17906

assert(var !=

);

17916

assert(var !=

);

17927

assert(var !=

);

17938

assert(var !=

);

17948

assert(var !=

);

17964

assert(probvar !=

);

17965

assert(aggrobj !=

);

17967 while

( probvar !=

)

18036

assert(var !=

);

18056

assert(var !=

);

18076

assert(var !=

);

18090

assert(var !=

);

18100

assert(var !=

);

18110

assert(var !=

);

18120

assert(var !=

);

18122 if

( var->

>= 0.0 )

18133

assert(var !=

);

18135 if

( var->

>= 0.0 )

18146

assert(var !=

);

18156

assert(var !=

);

18166

assert(var !=

);

18176

assert(var !=

);

18178 if

( var->

>= 0.0 )

18189

assert(var !=

);

18191 if

( var->

>= 0.0 )

18202

assert(var !=

);

18204 if

( var->

>= 0.0 )

18215

assert(var !=

);

18217 if

( var->

>= 0.0 )

18228

assert(var !=

);

18238

assert(var !=

);

18250

assert(var !=

);

18262

assert(var !=

);

18272

assert(var !=

);

18282

assert(var !=

);

18294

assert(var !=

);

18304

assert(var !=

);

18314

assert(var !=

);

18324

assert(var !=

);

18336

assert(var !=

);

18346

assert(var !=

);

18356

assert(var !=

);

18369

assert(var !=

);

18386

assert(var !=

);

18401

assert(var !=

);

18415

assert(var !=

);

18431

assert(var !=

);

18443

assert(var !=

);

18454

assert(var !=

);

18464

assert(var !=

);

18477

assert(var !=

);

18492

assert(pos < var->nlbchginfos);

18512

assert(pos < var->nubchginfos);

18522

assert(var !=

);

18532

assert(var !=

);

18542

assert(var !=

);

18557

assert(var !=

);

18576

assert(var !=

);

18578

assert(var->

->scip);

18585

eventtype, var->

, (

void

*)eventhdlr, (

void

*)eventdata);

18603

assert(var !=

);

18605

assert(var->

->scip);

18609 SCIPsetDebugMsg

(

"drop event of variable <%s> with handler %p and data %p\n"

, var->

, (

void

*)eventhdlr,

18610

(

void

*)eventdata);

18622

assert(bdchgidx !=

);

18624 return

bdchgidx->

;

18633

assert(bdchgidx1 !=

);

18634

assert(bdchgidx1->

>= -2);

18635

assert(bdchgidx1->

>= 0);

18636

assert(bdchgidx2 !=

);

18637

assert(bdchgidx2->

>= -2);

18638

assert(bdchgidx2->

>= 0);

18640 return

(bdchgidx1->

< bdchgidx2->

)

18641

|| (bdchgidx1->

== bdchgidx2->

&& (bdchgidx1->

< bdchgidx2->

));

18653

assert(bdchgidx1 ==

|| bdchgidx1->

>= -2);

18654

assert(bdchgidx1 ==

|| bdchgidx1->

>= 0);

18655

assert(bdchgidx2 ==

|| bdchgidx2->

>= -2);

18656

assert(bdchgidx2 ==

|| bdchgidx2->

>= 0);

18658 if

( bdchgidx1 ==

)

18660 else if

( bdchgidx2 ==

)

18663 return

(bdchgidx1->

< bdchgidx2->

)

18664

|| (bdchgidx1->

== bdchgidx2->

&& (bdchgidx1->

< bdchgidx2->

));

18672

assert(bdchginfo !=

);

18682

assert(bdchginfo !=

);

18692

assert(bdchginfo !=

);

18694 return

bdchginfo->

;

18702

assert(bdchginfo !=

);

18712

assert(bdchginfo !=

);

18722

assert(bdchginfo !=

);

18732

assert(bdchginfo !=

);

18742

assert(bdchginfo !=

);

18752

assert(bdchginfo !=

);

18764

assert(bdchginfo !=

);

18776

assert(bdchginfo !=

);

18787

assert(bdchginfo !=

);

18799

assert(bdchginfo !=

);

18820

assert(bdchginfo !=

);

18831

assert(bdchginfo !=

);

18846

assert(bdchginfo1 !=

);

18847

assert(bdchginfo2 !=

);

18848

assert(bdchginfo1->

== bdchginfo2->