RetroSearch Browse

) /

SQR

(2.0 - sqrt(3.0) + sqrt(7.0 -

+ sqrt(3.0)*(2.0*n - 6.0 +

)) );

156

volrect = width * height;

158

assert(volcircle != 0.0);

170 SCIP_Real

c =

MIN

(sqrt(3.0*rext*rext + rext * height - height * height / 4.0),

171

sqrt(8.0 * rext * height - height * height - 12.0 * rext * rext));

200

assert(probdata !=

);

201

assert(types !=

);

207

assert(conss !=

);

214 for

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

216 if

( ispacked ==

|| ispacked[i] )

219

(void) strcat(name, strtmp);

236 for

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

238 if

( ispacked ==

|| ispacked[i] )

276

assert(success !=

);

285

assert(sol !=

);

304 for

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

310

selectedtypes[nselected] = types[i];

316

assert(nselected > 0);

345

assert(iter < iterlim);

347 for

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

349 int

elemtype = elements[i];

354

scores[i] = lambdas[elemtype];

357 else if

( iter == 1 )

361 else if

( iter == 2 )

365 else if

( iter <= iterlim * 0.1 )

369 else if

( iter <= iterlim * 0.4 )

373 else if

( iter <= iterlim * 0.8 )

374

scores[i] =

SCIPrandomGetReal

(randnumgen, -1.0, 1.0) * rext * lambdas[elemtype];

412

assert(pricerdata !=

);

413

assert(addedvar !=

);

430 for

( t = 0; t < ntypes; ++t )

431

nelements +=

getNCircles

(

, rexts[t], demands[t], width, height, lambdas[t]);

442 for

( t = 0; t < ntypes; ++t )

447

n =

getNCircles

(

, rexts[t], demands[t], width, height, lambdas[t]);

449 for

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

451

elements[nelements] = t;

457 while

( niters < iterlim

466 computeScores

(

, rexts, pricerdata->randnumgen, elements, nelements, lambdas, scores, niters, iterlim);

472 SCIPpackCirclesGreedy

(

, rexts, xs, ys, -1.0, width, height, ispacked, elements, nelements,

476 for

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

480

redcosts -= lambdas[elements[i]];

481

vol += rexts[elements[i]];

488 SCIPdebugMsg

(

"pricing heuristic found column with reduced costs %g and volume %g after %d iterations\n"

, redcosts, vol, niters + 1);

492

bestredcosts =

MIN

(bestredcosts, redcosts);

493

bestvol =

MAX

(bestvol, vol);

545

assert(probdata !=

);

546

assert(lambdas !=

);

547

assert(nodelim >= -1L);

548

assert(addedvar !=

);

549

assert(solstat !=

);

550

assert(dualbound !=

);

557 if

( timelim <= 0.0 )

585 for

( t = 0; t < ntypes; ++t )

587

nvars +=

getNCircles

(

, rexts[t], demands[t], width, height, lambdas[t]);

601 for

( t = 0; t < ntypes; ++t )

621

vols[pos] =

SQR

(rexts[t]) *

;

628 for

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

634

assert(type1 >= 0 && type1 < ntypes);

636 for

( j = i+1; j < nvars; ++j )

642

assert(types2 >= 0 && types2 < ntypes);

644

c = (rexts[type1] + rexts[types2]) * (rexts[type1] + rexts[types2]);

647

linvars[0] =

[i]; lincoefs[0] = -c;

648

linvars[1] =

[j]; lincoefs[1] = -c;

651

quadvars1[0] =

[i]; quadvars2[0] =

[i]; quadcoefs[0] = 1.0;

652

quadvars1[1] =

[i]; quadvars2[1] =

[j]; quadcoefs[1] = -2.0;

653

quadvars1[2] =

[j]; quadvars2[2] =

[j]; quadcoefs[2] = 1.0;

654

quadvars1[3] =

[i]; quadvars2[3] =

[i]; quadcoefs[3] = 1.0;

655

quadvars1[4] =

[i]; quadvars2[4] =

[j]; quadcoefs[4] = -2.0;

656

quadvars1[5] =

[j]; quadvars2[5] =

[j]; quadcoefs[5] = 1.0;

661

quadcoefs, -c,

SCIPinfinity

(subscip),

TRUE

FALSE

) );

670 for

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

678 if

( type1 != type2 )

694 for

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

702 if

( type1 != type2 )

723 SCIPdebugMsg

(

"----------------------- solve pricing problem -----------------------\n"

);

725 SCIPdebugMsg

(

"---------------------------------------------------------------------\n"

);

735 for

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

767

assert(pricerdata->randnumgen ==

);

779

assert(pricerdata !=

);

780

assert(pricerdata->randnumgen ==

);

793

assert(pricerdata !=

);

794

assert(pricerdata->randnumgen !=

);

818

assert(pricerdata !=

);

820

assert(probdata !=

);

834

assert(conss !=

);

840

assert(conss[t] !=

);

869 SCIPdebugMsg

(

"result of pricing MINLP: addedvar=%u soltat=%d\n"

, success, solstat);

933

pricerRedcostRingpacking, pricerFarkasRingpacking, pricerdata) );

941 "ringpacking/pricing/nlptilim"

942 "time limit for each pricing NLP"

946 "ringpacking/pricing/nlpnodelim"

947 "node limit for each pricing NLP"

951 "ringpacking/pricing/heurtilim"

952 "time limit for each heuristic pricing"

956 "ringpacking/pricing/heuriterlim"

957 "iteration limit for each heuristic pricing"

961 "ringpacking/pricing/totaltilim"

962 "total time limit for all pricing NLPs and heuristic calls"

978

assert(pricer !=