RetroSearch Browse

);

143

assert(ind1 >= 0 && ind2 >= 0);

145

diffval = value[ind1] - value[ind2];

148 else if

( diffval > 0.0)

186

assert(ndominated !=

);

187

assert(dominated !=

);

195 for

( origindex=0; origindex<size; ++origindex )

196

permb[origindex] = origindex;

205

bestcurrenta =

[permb[0]];

208

currentb =

[permb[0]];

210

bestcurrents[0] = permb[0];

214 for

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

216

origindex = permb[indexinpermb];

217

assert(

[origindex] <= currentb);

223 if

( bestcurrenta > besta )

225 for

( iterbestcurrent=0; iterbestcurrent < nbestcurrent; ++iterbestcurrent )

226

dominated[bestcurrents[iterbestcurrent]] =

FALSE

;

228

besta = bestcurrenta;

232 for

( iterbestcurrent = 0; iterbestcurrent < nbestcurrent; ++iterbestcurrent )

234

dominated[bestcurrents[iterbestcurrent]] =

;

238

bestcurrenta =

[origindex];

239

currentb =

[origindex];

240

bestcurrents[0] = origindex;

249 for

( iterbestcurrent = 0; iterbestcurrent < nbestcurrent; ++iterbestcurrent )

251

dominated[bestcurrents[iterbestcurrent]] =

;

255

bestcurrenta =

[origindex];

256

bestcurrents[0] = origindex;

264

bestcurrents[nbestcurrent] = origindex;

269

dominated[origindex] =

;

276 if

( bestcurrenta > besta )

278 for

( iterbestcurrent = 0; iterbestcurrent < nbestcurrent; ++iterbestcurrent )

279

dominated[bestcurrents[iterbestcurrent]] =

FALSE

;

283 for

( iterbestcurrent = 0; iterbestcurrent < nbestcurrent; ++iterbestcurrent )

285

dominated[bestcurrents[iterbestcurrent]] =

;

306

assert(branchratio !=

);

307

assert(branchratio->

);

312 if

( leftgain > 0.0 && rightgain > 0.0 )

314

result = pow(branchratio->

, rightgain * branchratio->

) - pow(branchratio->

, (rightgain - leftgain) * branchratio->

) - 1;

318 return

(result > 0.0);

347 r

= rightgain / leftgain;

354

branchratio->

= 1.0 / leftgain;

363

branchratio->

= 1.0 / leftgain;

373

newratio = pow(2.0, 1.0/

);

388 for

( iters = 0; ((iters <= 5 && !

SCIPisEQ

(

, ratio, newratio)) ||

390

&& iters < treemodel->

maxfpiter

&& newratio > 1.0; iters++ )

392 double

G, H,

, p, p1, p2, phi_r;

395

phi_r = pow(ratio,

);

396

p = phi_r - phi_r / ratio - 1.0;

399

p1 = (

* phi_r - (

- 1.0) * phi_r / ratio) / ratio;

400

p2 = (

* (

- 1.0) * phi_r - (

- 1.0) * (

- 2.0) * phi_r / ratio) / ratio / ratio;

402

H = G * G - (p2 / p);

403 a

/ (G + (G >= 0 ? 1.0 : -1.0) * sqrt((

- 1.0) * (

* H - G * G)));

404

newratio = ratio -

;

413 for

( iters = 0; ((iters <= 10 && !

SCIPisEQ

(

, ratio, newratio)) ||

415

&& iters < treemodel->

maxfpiter

&& newratio > 1; iters++ )

418

newratio = pow(1.0-1.0/ratio, -1.0/

);

427 if

( iters < treemodel->maxfpiter && newratio > 1.0 )

430

branchratio->

= (ratio + newratio) / 2.0;

431

branchratio->

= 1.0 / leftgain;

466 int

referencevar = *bestcand;

467 computeVarRatio

(

, treemodel, branchcands[referencevar], mingains[referencevar], maxgains[referencevar], &bestbranchratio);

469 for

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

471 if

( (!filterdominated || !dominated[c]) && c != referencevar )

475 computeVarRatio

(

, treemodel, branchcands[c], mingains[c], maxgains[c], &branchratio);

476 if

( branchratio.

)

479

bestbranchratio = branchratio;

513

scaledgain = maxgain / mingain;

514

scaledgap = absgap / mingain;

516

mindepth = (int)

SCIPceil

(

, scaledgap / scaledgain);

522

gaptoreach = scaledgap * (treemodel->

maxsvtsheight

- 1) / mindepth;

525

assert(gaptoreach > scaledgain);

529

gaptoreach = scaledgap;

532

mindepth = (int) ceil(gaptoreach / scaledgain);

533

assert(mindepth <= treemodel->maxsvtsheight);

537 for

( nr = 1; nr <= mindepth; ++nr )

540 for

( ir = 1; ir <= nr; ++ir )

542

binomcoeff *= (nr + ceil((gaptoreach - (nr - 1) * scaledgain)) - ir) / ir;

544

treesize += binomcoeff;

547

treesize = 2.0 * treesize - 1.0;

561 if

( branchratio.

)

562

prediction = treesize * pow(branchratio.

, (scaledgap - gaptoreach) * branchratio.

);

567

prediction = treesize;

603

besttscand = *bestcand;

604

referencevar = *bestcand;

611

referencetreesize =

computeSVTS

(

, treemodel, branchcands[referencevar], localabsgap, mingains[referencevar],

612

maxgains[referencevar]);

616

treesizes[referencevar] = referencetreesize;

618 for

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

620 if

( !filterdominated || !dominated[c] )

622 if

( c != referencevar )

623

treesizes[c] =

computeSVTS

(

, treemodel, branchcands[c], localabsgap, mingains[c], maxgains[c]);

625

treesizes[c] = referencetreesize;

627

avgtreesize += treesizes[c];

632

avgtreesize = avgtreesize / (nbranchcands - ndominated);

634 for

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

636

score = (1.0 - 1.0 / (1.0 + avgtreesize / treesizes[c])) + 0.01 * tiebreakerscore[c];

637 if

(score > bestscore)

644

*bestcand = besttscand;

652

nbranchcands, bestcand) );

659

nbranchcands, bestcand) );

703 if

( branchratio.

)

707 int

kl = (int)ceil(absgap / leftgain);

708 int

kr = (int)ceil(absgap / rightgain);

709 int

k = (int)ceil(absgap / (leftgain + rightgain));

715

leftsize = (

integerpow

(phi_l, kl + 1) - 1.0) / (phi_l - 1.0);

716

rightsize = (

integerpow

(phi_r, kr + 1) - 1.0) / (phi_r - 1.0);

718 if

( k * (leftgain + rightgain) < absgap + rightgain )

719

midsize = (1.0 + phi_l) * (phi_klr * phi_lr - 1.0) / (phi_lr - 1.0) - phi_klr * phi_l;

721

midsize = (1.0 + phi_l) * (phi_klr - 1.0) / (phi_lr - 1.0);

723

prediction = (leftsize + rightsize + midsize) / 3.0;

762

besttscand = *bestcand;

763

referencevar = *bestcand;

770

referencetreesize =

computeSampleTreesize

(

, treemodel, branchcands[referencevar], localabsgap, mingains[referencevar],

771

maxgains[referencevar]);

776

treesizes[referencevar] = referencetreesize;

778 for

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

780 if

( !filterdominated || !dominated[c] )

782 if

( c != referencevar )

785

treesizes[c] = referencetreesize;

787

avgtreesize += treesizes[c];

792

avgtreesize = avgtreesize / (nbranchcands - ndominated);

794 for

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

796

score = (1.0 - 1.0 / (1.0 + avgtreesize / treesizes[c])) + 0.01 * tiebreakerscore[c];

797 if

( score > bestscore )

804

*bestcand = besttscand;

812

nbranchcands, bestcand) );

819

nbranchcands, bestcand) );

831

assert(treemodel !=

);

833

assert(*treemodel !=

);

836 "should candidate branching variables be scored using the Treemodel branching rules?"

840 "scoring function to use at nodes predicted to be high in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)"

844 "scoring function to use at nodes predicted to be low in the tree ('d'efault, 's'vts, 'r'atio, 't'ree sample)"

848 "estimated tree height at which we switch from using the low rule to the high rule"

852 "should dominated candidates be filtered before using the high scoring function? ('a'uto, 't'rue, 'f'alse)"

856 "should dominated candidates be filtered before using the low scoring function? ('a'uto, 't'rue, 'f'alse)"

860 "maximum number of fixed-point iterations when computing the ratio"

864 "maximum height to compute the SVTS score exactly before approximating"

868 "which method should be used as a fallback if the tree size estimates are infinite? ('d'efault, 'r'atio)"

872 "which method should be used as a fallback if there is no primal bound available? ('d'efault, 'r'atio)"

876 "threshold at which pseudocosts are considered small, making hybrid scores more likely to be the deciding factor in branching"

889

assert(treemodel !=

);

890

assert(*treemodel !=

);

894

assert(*treemodel ==

);

926 char

scoringfunction;

929

assert(treemodel !=

);

931

assert(*bestcand >= 0);

941

SCIPisLT

(

, localabsgap/mingains[*bestcand], 1.0 * INT_MAX))

942

bestcandheight = (int)(localabsgap/mingains[*bestcand]);

944

bestcandheight = INT_MAX;

947 if

( bestcandheight < treemodel->height )

949

scoringfunction = treemodel->

lowrule

;

954

scoringfunction = treemodel->

highrule

;

959 if

( scoringfunction !=

'd'

)

967

autofilter = (filtersetting ==

'a'

&& (scoringfunction ==

's'

|| scoringfunction ==

't'

));

968

filterdominated = (autofilter || filtersetting ==

't'

);

971 if

( filterdominated )

983 switch

( scoringfunction )

987

localabsgap, filterdominated, dominated, nbranchcands, ndominated, bestcand) );

991

dominated, nbranchcands, bestcand) );

995

localabsgap, filterdominated, dominated, nbranchcands, ndominated, bestcand) );

1002 if

( filterdominated )

1004

assert(dominated !=