RetroSearch Browse

);

160

assert(vars !=

);

161

assert(conss !=

);

162

assert(varlabels !=

);

163

assert(conslabels !=

);

170

newlabel = varlabels[nvars - 1];

171

assert(newlabel >= 0);

172 for

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

193 if

( nlinkvars >= 1 )

198 for

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

225

assert(subscip !=

);

288

assert(subscip !=

);

289

assert(vars !=

);

290

assert(conss !=

);

291

assert(varsmap !=

);

292

assert(conssmap !=

);

293

assert(success !=

);

301 for

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

316 for

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

318

assert(conss[i] !=

);

378

assert(blockproblem !=

);

379

assert(conss !=

);

380

assert(vars !=

);

395

nvars, nconss, success) );

410 for

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

424 for

( c = 0; c < nlinking; c++ )

426 const char

* conshdlrname;

436

assert(linkingconss[c] !=

);

440#ifdef SCIP_MORE_DEBUG 449 if

( !( (strcmp(conshdlrname,

"linear"

) == 0) || (strcmp(conshdlrname,

"setppc"

) == 0)

450

|| (strcmp(conshdlrname,

"logicor"

) == 0) || (strcmp(conshdlrname,

"knapsack"

) == 0)

451

|| (strcmp(conshdlrname,

"varbound"

) == 0) ) )

463 if

( nconsvars > maxnconsvars )

472

maxnconsvars = newsize;

485 for

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

490

blockvals[nblockvars] = consvals[v];

502

blockvars[nblockvars] = negblockvar;

503

blockvals[nblockvars] = consvals[v];

510 if

( nblockvars == 0 )

539 if

( linkings[c]->

)

546

blockvals[nblockvars] = -1.0;

548#ifdef SCIP_MORE_DEBUG 551

linkings[c]->

[linkings[c]->

nslacks

] = blockvars[nblockvars];

559 if

( linkings[c]->

)

566

blockvals[nblockvars] = 1.0;

568#ifdef SCIP_MORE_DEBUG 571

linkings[c]->

[linkings[c]->

nslacks

] = blockvars[nblockvars];

582#ifdef SCIP_MORE_DEBUG 595

mininfinite =

;

596

maxinfinite =

;

597 for

( v = 0; v < nblockvars - linkings[c]->

nslacksperblock

&& (!mininfinite || !maxinfinite); v++ )

604 if

( blockvals[v] >= 0.0 )

609

minact += blockvals[v] * lb;

611

maxact += blockvals[v] * ub;

618

minact += blockvals[v] * ub;

620

maxact += blockvals[v] * lb;

644

assert(blockproblem->

nlinking

<= nlinking);

678

assert(heurdata !=

);

679

assert(vars !=

);

680

assert(conss !=

);

686

assert(0 == nvarsblock[0]);

691 for

( i = 0; i < heurdata->nblocks; i++)

693

conssoffset += nconssblock[i];

694

varsoffset += nvarsblock[i];

697

heurdata->linkingconss, heurdata->nlinking, i, success) );

733

assert(linking !=

);

734

assert(blockproblem !=

);

773 for

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

808 for

( i = 0; i < linking->

- nnonintblocks; i++ )

809

sumafter += 1 - fracPart[nnonintblocks + i];

811 for

( i = 0; i < linking->

- nnonintblocks; i++ )

813

sumbefor += fracPart[nnonintblocks + i];

814

sumafter -= 1 - fracPart[nnonintblocks + i];

816 if

( sumbefor >= sumafter )

818 for

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

819

fracPart[nnonintblocks + k] = -fracPart[nnonintblocks + k];

821 for

( k = i + 1; k < linking->

- nnonintblocks; k++ )

822

fracPart[nnonintblocks + k] = 1 - fracPart[nnonintblocks + k];

828

diff = sumbefor - sumafter;

832 for

( i = nnonintblocks - 1; i >= 0; i-- )

846

assert(nnonintblocks == 0);

847

fracPart[idx] += diff;

893

assert(linkings !=

);

894

assert(blockproblem !=

);

895

assert(nlinking > 0);

900 for

( c = 0; c < nlinking; c++ )

902

linking = linkings[c];

941 if

( origvar ==

)

947

lpvalue += varlpvalue * consvals[i];

977

residual = goalvalue - part;

995

residual = goalvalue - part;

1009

goalvalue = residualrhs / (linking->

);

1020

goalvalue = residuallhs / (linking->

);

1042#ifdef SCIP_MORE_DEBUG 1051#ifdef SCIP_MORE_DEBUG 1069 int

* nviolatedblocksrhs,

1070 int

* nviolatedblockslhs,

1074 int

* nonviolatedblocksrhs;

1075 int

* nonviolatedblockslhs;

1089 for

( v = 0; v < linking->

; v++ )

1108

(*nviolatedblocksrhs)++;

1110

(*shift)[v] += slackval;

1111

sumviols += slackval;

1115

nonviolatedblocksrhs[v - *nviolatedblocksrhs] = v;

1125

(*nviolatedblockslhs)++;

1127

(*shift)[v] -= slackval;

1128

sumviols -= slackval;

1132

nonviolatedblockslhs[v - *nviolatedblockslhs] = v;

1138 if

( *nviolatedblocksrhs + *nviolatedblockslhs == 0 ||

1139

linking->

== *nviolatedblocksrhs || linking->

== *nviolatedblockslhs )

1158

assert(linking->

);

1159

assert(*nviolatedblocksrhs != 0);

1164 for

( v = 0; v < linking->

- *nviolatedblocksrhs; v++ )

1167

part = linking->

currentrhs

[nonviolatedblocksrhs[v]] - residual/(linking->

- *nviolatedblocksrhs - v);

1169

shift_tmp = part - linking->

currentrhs

[nonviolatedblocksrhs[v]];

1170

residual += shift_tmp;

1171

(*shift)[nonviolatedblocksrhs[v]] += shift_tmp;

1176 if

( linking->

- *nviolatedblocksrhs == 1 )

1177

(*shift)[nonviolatedblocksrhs[0] == 0 ? 1 : 0] -= residual;

1179

(*shift)[nonviolatedblocksrhs[0]] -= residual;

1189

assert(linking->

);

1190

assert(*nviolatedblockslhs != 0);

1195 for

( v = 0; v < linking->

- *nviolatedblockslhs; v++ )

1198

part = linking->

currentlhs

[nonviolatedblockslhs[v]] - residual/(linking->

- *nviolatedblockslhs - v);

1200

shift_tmp = part - linking->

currentlhs

[nonviolatedblockslhs[v]];

1201

residual += shift_tmp;

1202

(*shift)[nonviolatedblockslhs[v]] += shift_tmp;

1207 if

( linking->

- *nviolatedblockslhs == 1 )

1208

(*shift)[nonviolatedblockslhs[0] == 0 ? 1 : 0] -= residual;

1210

(*shift)[nonviolatedblockslhs[0]] -= residual;

1231 int

** nviolatedblocksrhs,

1232 int

** nviolatedblockslhs,

1245

assert(linkings !=

);

1246

assert(blockproblem !=

);

1247

assert(iteration >= 0);

1248

assert(!*oneupdate);

1252 for

( c = 0; c < nlinking; c++ )

1256

linking = linkings[c];

1257

(*nviolatedblocksrhs)[c] = 0;

1258

(*nviolatedblockslhs)[c] = 0;

1263 SCIP_CALL

(

calculateShift

(

, blockproblem, linking, &shift, &(*nviolatedblocksrhs)[c], &(*nviolatedblockslhs)[c], &update) );

1273 for

( v = 0; v < linking->

; v++ )

1279 for

( v = 0; v < linking->

; v++)

1291 for

( v = 0; v < linking->

; v++ )

1323 int

* nviolatedblocksrhs,

1324 int

* nviolatedblockslhs,

1335

assert(linkings !=

);

1336

assert(blockproblem !=

);

1338 for

( c = 0; c < nlinking; c++ )

1340

assert(nviolatedblocksrhs[c] >= 0);

1341

assert(nviolatedblockslhs[c] >= 0);

1344 if

( nviolatedblocksrhs[c] + nviolatedblockslhs[c] == 0 )

1351 for

(

= 0;

< linkings[c]->

;

++ )

1355

assert(subscip !=

);

1357 if

( linkings[c]->

&& (nviolatedblocksrhs[c] >= 1) && (linkings[c]->

lastviolations

>= 1) )

1361

new_obj = old_obj + heurdata->penalty * nviolatedblocksrhs[c];

1365 if

( linkings[c]->

&& (nviolatedblockslhs[c] >= 1) && (linkings[c]->

lastviolations

>= 1) )

1369

new_obj = old_obj + heurdata->penalty * nviolatedblockslhs[c];

1402

assert(linkings !=

);

1403

assert(blockproblem !=

);

1418

sol = sols[nsols - 1];

1432 for

( c = 0; c < blockproblem[

]->

nlinking

; c++ )

1447

assert(

SCIPisGE

(subscip, rhs, lhs));

1454 for

( i = 0; i < linking->

; i++ )

1460

rvar = linking->

[2 * i];

1461

lvar = linking->

[2 * i + 1];

1464

activity = activitycons + rval - lval;

1468 else if

( linking->

)

1470

rvar = linking->

[i];

1472

activity = activitycons + rval;

1477

assert(linking->

);

1478

lvar = linking->

[i];

1480

activity = activitycons - lval;

1492 SCIPdebugMsg

(subscip,

"Correcting solution failed\n"

);

1494 SCIPdebugMsg

(subscip,

"Correcting solution successful\n"

);

1522

assert(heur !=

);

1523

assert(sol !=

);

1524

assert(blockproblem !=

);

1554 for

( v = 0; v < blockproblem[

]->

nblockvars

; v++ )

1560 for

( v = blockproblem[

]->nblockvars; v < nvars; v++ )

1604 if

( timesubscip < time - 1.0 )

1664 for

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

1690

assert(eventhdlr !=

);

1691

assert(eventdata !=

);

1693

assert(event !=

);

1717

assert(heur !=

);

1732

assert(heur !=

);

1737

assert(heurdata !=

);

1759 int

* sortedvarlabels;

1760 int

* sortedconslabels;

1779

assert( heur !=

);

1781

assert( result !=

);

1784

assert(heurdata !=

);

1786

assigneddecomp =

;

1787

blockproblem =

;

1808 if

( ndecomps == 0 )

1811

decomp = alldecomps[0];

1812

assert(decomp !=

);

1820 if

( nconss == 0 || nvars == 0 ||

<= 1 )

1822 SCIPdebugMsg

(

"problem has no constraints, no variables or less than two blocks\n"

);

1858 SCIPsortIntPtr

(sortedconslabels, (

void

**)sortedconss, nconss);

1867

decomp = assigneddecomp;

1892 if

( heurdata->maxlinkscore != 1.0 )

1901 if

( linkscore > heurdata->maxlinkscore )

1912 SCIPdebugMsg

(

"Problem has linking variables or no linking constraints or less than two blocks\n"

);

1917

heurdata->linkingconss = sortedconss;

1939 for

( c = 0; c < heurdata->nlinking; c++ )

1948

linkings[c]->

linkingcons

= heurdata->linkingconss[c];

1967 for

( c = 0; c < heurdata->nlinking; c++ )

1969 if

( linkings[c]->

)

1974 if

( linkings[c]->

)

1992 for

( k = 0; k < heurdata->maxit; k++ )

2001 for

(

= 0;

< heurdata->nblocks;

++ )

2013 if

( eventhdlr ==

)

2048 SCIPdebugMsg

(

"Subproblem reached timelimit without optimal solution\n"

);

2052

allslacksval += blocksolval;

2066 SCIPdebugMsg

(

"Feasible solution found after %i iterations\n"

, k);

2070 for

(

= 0;

< heurdata->nblocks;

++ )

2085 for

( c = 0; c < nblockvars; c++ )

2097 if

( heurdata->reoptimize )

2100 SCIP_CALL

(

reoptimize

(

, heur, newsol, blockproblem, heurdata->nblocks, heurdata->reoptlimits, &improvedsol, &success) );

2101

assert(improvedsol !=

|| success ==

);

2139 int

* nviolatedblocksrhs;

2140 int

* nviolatedblockslhs;

2161 for

(

= 0;

< heurdata->nblocks;

++ )

2169 if

( heurdata->reuse )

2184 if

( linkings !=

)

2186 for

( c = heurdata->nlinking - 1; c >= 0; c-- )

2195 for

( c = heurdata->nlinking - 1; c >= 0; c-- )

2208 if

( blockproblem !=

)

2222 if

( assigneddecomp !=

)

2225 if

( sortedconslabels !=

)

2228 if

( sortedvarlabels !=

)

2231 if

( sortedconss !=

)

2234 if

( sortedvars !=

)

2265

assert(heur !=

);

2276 "maximal linking score of used decomposition (equivalent to percentage of linking constraints)"

2277

&heurdata->maxlinkscore,

, 1.0, 0.0, 1.0,

) );

2280 "multiplier for absolute increase of penalty parameters (0: no increase)"

2284 "should the problem get reoptimized with the original objective function?"

, &heurdata->reoptimize,

) );

2287 "should solutions get reused in subproblems?"

, &heurdata->reuse,

) );

2290 "should strict limits for reoptimization be set?"

, &heurdata->reoptlimits,

TRUE