RetroSearch Browse

);

70

assert(pos < nlabels);

72

currlabel = labels[pos];

78 while

( endpos < nlabels && labels[endpos] == currlabel );

104 return

2 *

MAX

(norigvars, ntransvars);

120

assert(decomp !=

);

154

assert(decomp !=

);

155

assert(cons !=

);

156

assert(varbuf !=

);

157

assert(nvars !=

);

158

assert(requiredsize !=

);

159

assert(success !=

);

172 if

( bufsize < *nvars )

174

*requiredsize = *nvars;

190 if

( *requiredsize > bufsize )

196 for

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

207 if

( labelbuf !=

)

251

assert(decomp !=

);

272 SCIP_CALL_ABORT

(

SCIPcheckStage

(

scip

"SCIPgetDecomps"

, original, original,

) );

274 if

( decomps !=

)

277 if

( ndecomps !=

)

295

assert(cons !=

);

296

assert(decomp !=

);

297

assert(hasonlylinkvars !=

);

311

assert(requiredsize <= nvars);

314

*hasonlylinkvars =

;

316 for

( i = 0; i < nvars && *hasonlylinkvars; ++i )

360

assert(decomp !=

);

372

benderserror =

;

375 for

( c = 0; c < nconss && ! benderserror; ++c )

379 int

nlinkingvars = 0;

386

varbufsize, &nconsvars, &requiredsize, &success) );

391 for

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

393 int

varlabel = varlabels[v];

399

conslabel = varlabel;

400 else if

( conslabel != varlabel )

406

benderserror =

;

420

conslabels[c] = conslabel;

432 SCIPerrorMessage

(

"Error in constraint label computation; variables from multiple named blocks in a single constraint\n"

);

469

assert(decomp !=

);

470

assert(conss !=

);

484 for

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

493

conslabel = conslabels[c];

498 if

( ! benderslabels )

504

newvarlabel = conslabel;

507

varbufsize, &nconsvars, &requiredsize, &success) );

511 for

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

570

assert(decomp !=

);

581 for

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

585

defaultlabel = varslabels[c];

591 for

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

596

&nconsvars, &requiredsize, &success) );

601 if

( nconsvars == 0 )

633

assert(nlinkvars < nconsvars);

642 if

( nblockvars > maxnblockvars )

644

maxnblockvars = nblockvars;

649 while

( curr < nconsvars );

652

startposs[0] = nlinkvars;

654

startposs[1] = block + maxnblockvars;

655

endposs[1] = nconsvars;

658 for

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

661 for

( v = startposs[p]; v < endposs[p]; ++v )

672 if

( nskipconss !=

)

673

*nskipconss = nskipconsslocal;

732 for

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

735 int

conslabel = conslabels[c];

749

varbufsize, &nconsvars, &requiredsize, &success) );

756 while

( varblockstart < nconsvars )

761

varblockpos =

findLabelIdx

(decomp, varslabels[varblockstart]);

767 if

( varblockpos == blockpos )

768

withinedges[varblockpos] += nblockvars;

773

totaldegrees[blockpos] += nblockvars;

774

totaldegrees[varblockpos] += nblockvars;

775

nnonzeroes += nblockvars;

778

varblockstart += nblockvars;

785 int

totaldegreesum = 0;

787

totaldegreesum += totaldegrees[

];

789

assert(totaldegreesum == 2 * nnonzeroes);

795

nnonzeroes =

MAX

(nnonzeroes, 1);

799

expectedval = totaldegrees[

] / (2.0 * nnonzeroes);

800

expectedval =

SQR

(expectedval);

801

*modularity += (withinedges[

] / (

SCIP_Real

)nnonzeroes) - expectedval;

826 if

( nvars > 0 && nconss > 0 )

829 int

nlinkvars = decomp->

[0];

835 for

( i = 1; i < decomp->

+ 1; ++i )

870 int

nlinkingvars = 0;

875 int

nblockgraphedges;

882 if

( maxgraphedge == -1 )

883

maxgraphedge = INT_MAX;

886

assert(decomp !=

);

916 for

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

920

linkvaridx[v] = nlinkingvars;

942 while

( conspos < nconss )

947 int

nblocklinkingvars = 0;

956 for

( c = conspos; c < conspos + nblockconss && nblocklinkingvars < nlinkingvars; ++c )

963

varbufsize, &nconsvars, &requiredsize, &success) );

967 for

( j = 0; j < nconsvars && nblocklinkingvars < nlinkingvars; ++j )

969 int

linkingvarnodeidx;

975

assert(linkingvarnodeidx >= 0);

977 if

( !adjacent[linkingvarnodeidx] )

979

adjacent[linkingvarnodeidx] =

;

980

adjacentidxs[nblocklinkingvars++] = linkingvarnodeidx;

986

assert(blocknodeidx ==

findLabelIdx

(decomp, conslabels[conspos]) - 1);

987 for

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

994 for

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

995

adjacent[adjacentidxs[i]] =

;

999 for

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

1000

assert(adjacent[i] ==

);

1006

conspos += nblockconss;

1018 if

( nsuccvar == nblocks )

1020

decomp->

nedges

= nblocks * (nblocks - 1) / 2;

1034

nblockgraphedges = 0;

1035 for

( n = 0; n < nblocks - 1 && nblockgraphedges < maxgraphedge; ++n )

1040 int

nadjacentblks = 0;

1049 for

( i = 0; i < nsuccblk && nadjacentblks < nblocks - (n + 1); ++i )

1062 for

( j = startpos + 1; j < nsuccvar; ++j )

1064

assert( succnodesvar[j] > n );

1065 if

( !adjacent[succnodesvar[j]] )

1067

adjacent[succnodesvar[j]] =

;

1068

adjacentidxs[nadjacentblks] = succnodesvar[j];

1075 for

( i = 0; i < nadjacentblks && nblockgraphedges < maxgraphedge; ++i )

1084 for

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

1085

adjacent[adjacentidxs[i]] =

;

1094

decomp->

nedges

= nblockgraphedges;

1104 if

( nsuccblk < tempmin )

1106 else if

( nsuccblk > tempmax )

1127 if

( blockgraph !=

)

1160

assert(decomp !=

);

1168 if

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

1215 while

( varidx < nvars || considx < nconss )

1220

varlabel = varidx < nvars ? varslabels[varidx] : INT_MAX;

1221

conslabel = considx < nconss ? conslabels[considx] : INT_MAX;

1223

assert(currlabelidx < decomp->memsize);

1225

decomp->

labels

[currlabelidx] =

MIN

(varlabel, conslabel);

1228 if

( varlabel <= conslabel )

1231

decomp->

[currlabelidx] = 0;

1234 if

( conslabel <= varlabel )

1240

varidx += decomp->

[currlabelidx];

1241

considx += decomp->

[currlabelidx];

1249 if

( currlabelidx < decomp->nblocks + 1 )

1250

decomp->

= currlabelidx - 1;

1253

varblockstart = decomp->

[0];

1254

consblockstart = decomp->

[0];

1256 for

( i = 1; i < decomp->

+ 1; ++i )

1262 int

nblockconss = decomp->

[i];

1265 for

( c = consblockstart; c < consblockstart + nblockconss; ++c )

1277 int

nblockvars = decomp->

[i];

1281 for

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

1287

decomp->

[0] += nblockvars;

1290

varblockstart += decomp->

[i];

1291

consblockstart += decomp->

[i];

1297 for

( i = 1; i < decomp->

+ 1; ++i )

1310

decomp->

= currlabelidx - 1;

1314 for

( i = 1; i < decomp->