RetroSearch Browse

);

210

assert(cutoff !=

);

211

assert(ncuts !=

);

234 for

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

242 SCIPdebugMsg

(

" -> found potential %s cut <%s>: rhs=%f, eff=%f\n"

, cutclassname, cutname, cutrhs, cutefficacy);

257

makeintegral =

;

268 SCIPdebugMsg

(

" -> %s cut <%s> no longer efficacious: rhs=%f, eff=%f\n"

, cutclassname, cutname, cutrhs, cutefficacy);

277 SCIPdebugMsg

(

" -> found %s cut <%s>: rhs=%f, eff=%f, rank=%d, min=%f, max=%f (range=%g)\n"

348

firstcontvar = nvars - ncontvars;

350 for

( i = nbinvars + nintvars; i < nvars; ++i )

377 if

( bestvlbidx >= 0 )

378

bestlb =

(bestlb, bestvlb);

379 if

( bestvubidx >= 0 )

380

bestub =

(bestub, bestvub);

383

distlb = primsol - bestlb;

384

distub = bestub - primsol;

386

bounddist =

(distlb, distub);

387

bounddist =

(bounddist, 0.0);

390 if

( i < firstcontvar )

412 int

aggrrowsminsize = aggrdata->

naggrrows

+ ncolnonzeros;

422

assert(aggrdata->

aggrrowssize

> 0 || ncolnonzeros == 0);

424 for

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

466 for

( k = beg; k < end; ++k )

474 int

nextgoodrowpos = beg + ngoodrows;

475 if

( k > nextgoodrowpos )

551 return

aggrdata->

bounddist

[aggrdataidx];

585

assert( success !=

);

597 for

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

602 if

( inds[i] < firstcontvar )

607 if

( bounddist == 0.0 )

610

badvarinds[nbadvars] = inds[i];

611

badvarbddist[nbadvars] = bounddist;

627 for

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

637 if

( badvarbddist[i] > 0.0 )

641 if

( aggrfac == 0.0 )

642

minbddist = -badvarbddist[i] * (1.0 - sepadata->aggrtol);

645 if

( -badvarbddist[i] < minbddist )

648

probvaridx = badvarinds[i];

653

assert(ngoodrows > 0);

654

assert(ngoodrows <= nrows);

656 for

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

675

rowscore =

(rowlhsscores[lppos], rowrhsscores[lppos]);

678 if

( aggrfac == 0.0 || rowscore > bestrowscore )

680

bestrow = candrows[k];

681

aggrfac = rowaggrfac;

682

bestrowscore = rowscore;

689 if

( aggrfac != 0.0 )

697 for

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

707 if

( badvarbddist[i] < 0.0 )

711 if

( aggrfac == 0.0 )

712

minbddist = badvarbddist[i] * (1.0 - sepadata->aggrtol);

715 if

( badvarbddist[i] < minbddist )

718

probvaridx = badvarinds[i];

724

assert(ngoodrows == 0);

726 for

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

749

rowscore = rowlhsscores[lppos];

754

rowscore = rowrhsscores[lppos];

759 if

( aggrfac == 0.0 ||

SCIPisGT

(

, rowscore, bestrowscore) ||

762

bestrow = candrows[k];

763

aggrfac = rowaggrfac;

764

bestrowscore = rowscore;

765

bestrowside = rowside;

771 if

( aggrfac != 0.0 )

816

assert(aggrdata !=

);

818

assert(sepa !=

);

819

assert(rowlhsscores !=

);

820

assert(rowrhsscores !=

);

821

assert(wastried !=

);

822

assert(cutoff !=

);

823

assert(ncuts !=

);

826

assert(sepadata !=

);

832

assert(nrows == 0 || rows !=

);

834

maxtestdelta = sepadata->maxtestdelta == -1 ? INT_MAX : sepadata->maxtestdelta;

837

maxaggrnonzs = (int)(sepadata->maxaggdensity *

SCIPgetNLPCols

(

)) + sepadata->densityoffset;

863

assert(0 <= startrow && startrow < nrows);

881 while

( naggrs <= maxaggrs )

906 if

( sepadata->sepflowcover )

909

cutcoefs, &cutrhs, cutinds, &cutnnz, &flowcoverefficacy, &cutrank, &flowcovercutislocal, &flowcoversuccess) );

913

flowcoversuccess =

;

919

knapsackcoverefficacy = flowcoverefficacy;

921 if

( sepadata->sepknapsackcover )

924

cutcoefs, &cutrhs, cutinds, &cutnnz, &knapsackcoverefficacy, &cutrank, &knapsackcovercutislocal, &knapsackcoversuccess) );

928

knapsackcoversuccess =

SCIPcutGenerationHeuristicCMIR

;

935

cutefficacy = knapsackcoverefficacy;

937 if

( sepadata->sepcmir )

939 SCIP_CALL

(

(

, sol,

, allowlocal, maxtestdelta,

MINFRAC

MAXFRAC

940

aggrdata->

aggrrow

, cutcoefs, &cutrhs, cutinds, &cutnnz, &cutefficacy, &cutrank, &cmircutislocal, &cmirsuccess) );

944

cmirsuccess =

;

951

cmircutislocal, sepadata->dynamiccuts, cutrank, startrow < 0 ?

"objcmir"

"cmir"

, cutoff, ncuts, &cut) );

953 else if

( knapsackcoversuccess )

957

knapsackcovercutislocal, sepadata->dynamiccuts, cutrank, startrow < 0 ?

"objlci"

"lci"

, cutoff, ncuts, &cut) );

959 else if

( flowcoversuccess )

963

flowcovercutislocal, sepadata->dynamiccuts, cutrank, startrow < 0 ?

"objflowcover"

"flowcover"

, cutoff, ncuts, &cut) );

987 for

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

991

rowlhsscores[rowinds[i]] *= fac;

992

rowrhsscores[rowinds[i]] *= fac;

1006 if

( naggrs == maxaggrs )

1008 SCIPdebugMsg

(

" -> abort aggregation: maximal number of aggregations reached\n"

);

1013

&naggrs, &aggrsuccess) );

1021 SCIPdebugMsg

(

" -> current aggregation has %d/%d nonzeros and consists of %d/%d rows\n"

1047 for

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

1102

assert(result !=

);

1106

assert(sepadata !=

);

1111 if

( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)

1112

|| (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )

1119 int

knapsackcoverfreq;

1125

sepadata->sepcmir = cmirfreq > 0 ? (depth % cmirfreq) == 0 : cmirfreq == depth;

1126

sepadata->sepflowcover = flowcoverfreq > 0 ? (depth % flowcoverfreq) == 0 : flowcoverfreq == depth;

1127

sepadata->sepknapsackcover = knapsackcoverfreq > 0 ? (depth % knapsackcoverfreq) == 0 : knapsackcoverfreq == depth;

1130 if

( ! sepadata->sepcmir && ! sepadata->sepflowcover && ! sepadata->sepknapsackcover )

1135

assert(nrows == 0 || rows !=

);

1149#ifdef IMPLINTSARECONT 1152

nintvars = nvars - ncontvars;

1153

assert(nvars == 0 || vars !=

);

1179 for

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

1182

fractionalities[v] =

(fractionalities[v], 1.0 - fractionalities[v]);

1190 for

( ; v < nvars; ++v )

1209

fractionalities[v] = 0.0;

1210 if

( closestvlbidx != -1 &&

SCIPisEQ

(

, varsolvals[v], closestvlb) )

1217

assert(frac >= 0.0 && frac < 1.0);

1218

frac =

(frac, 1.0 - frac) * vlbcoefs[closestvlbidx];

1219

fractionalities[v] += frac;

1222 if

( closestvubidx != -1 &&

SCIPisEQ

(

, varsolvals[v], closestvub) )

1229

assert(frac >= 0.0 && frac < 1.0);

1230

frac =

(frac, 1.0 - frac) * vubcoefs[closestvubidx];

1231

fractionalities[v] += frac;

1238

maxtries = sepadata->maxtriesroot;

1239

maxfails = sepadata->maxfailsroot;

1240

maxaggrs = sepadata->maxaggrsroot;

1241

maxsepacuts = sepadata->maxsepacutsroot;

1242

maxslack = sepadata->maxslackroot;

1246

maxtries = sepadata->maxtries;

1247

maxfails = sepadata->maxfails;

1248

maxaggrs = sepadata->maxaggrs;

1249

maxsepacuts = sepadata->maxsepacuts;

1250

maxslack = sepadata->maxslack;

1259 for

(

= 0;

< nrows;

++ )

1269

rowlhsscores[

] = 0.0;

1270

rowrhsscores[

] = 0.0;

1287

objnorm =

(objnorm, 1.0);

1295

rownorm =

(rownorm, 0.1);

1298

fracscore = fracact / rownorm;

1300

slack = (activity - lhs)/rownorm;

1301

dualscore =

(fracscore * dualsol/objnorm, 0.0001);

1303

&& rowdensity <= sepadata->maxrowdensity

1304

&& rowdensity <= sepadata->maxaggdensity )

1306

rowlhsscores[

] = dualscore + sepadata->densityscore * (1.0-rowdensity) + sepadata->slackscore *

(1.0 - slack, 0.0);

1307

assert(rowlhsscores[

] > 0.0);

1310

rowlhsscores[

] = 0.0;

1312

slack = (rhs - activity)/rownorm;

1313

dualscore =

(-fracscore * dualsol/objnorm, 0.0001);

1315

&& rowdensity <= sepadata->maxrowdensity

1316

&& rowdensity <= sepadata->maxaggdensity )

1318

rowrhsscores[

] = dualscore + sepadata->densityscore * (1.0-rowdensity) + sepadata->slackscore *

(1.0 - slack, 0.0);

1319

assert(rowrhsscores[

] > 0.0);

1322

rowrhsscores[

] = 0.0;

1325 if

( fracscore != 0.0 )

1327

roworder[nnonzrows] =

;

1328

rowscores[nnonzrows] = fracscore;

1334

rowlhsscores[

], rowrhsscores[

], rowscores[

]);

1336

assert(nnonzrows <= nrows);

1360

-1, 2 * maxaggrs, &wastried, &cutoff, cutinds, cutcoefs,

, &ncuts) );

1366 for

(

= 0;

< nnonzrows && ntries < maxtries && ncuts < maxsepacuts && !

SCIPisStopped

(

);

++ )

1370

roworder[

], maxaggrs, &wastried, &cutoff, cutinds, cutcoefs,

, &ncuts) );

1375 if

( sepadata->trynegscaling && !cutoff )

1378

roworder[

], maxaggrs, &wastried, &cutoff, cutinds, cutcoefs,

TRUE

, &ncuts) );

1390 if

( ncuts == oldncuts )

1393 if

( nfails >= maxfails )

1418 else if

( ncuts > 0 )

1433

assert(sepa !=

);

1450

assert(sepadata !=

);

1463

assert( result !=

);

1488

assert( result !=

);

1501

assert( result !=

);

1512

assert( result !=

);

1538

assert(sepadata->flowcover !=

);

1543

assert(sepadata->cmir !=

);

1548

assert(sepadata->knapsackcover !=

);

1553

sepaExeclpAggregation, sepaExecsolAggregation,

1556

assert(sepa !=