A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://scip.zib.de/doc/html/branch__relpscost_8c_source.php below:

SCIP Doxygen Documentation: branch_relpscost.c Source File

66#define BRANCHRULE_NAME "relpscost" 67#define BRANCHRULE_DESC "reliability branching on pseudo cost values" 68#define BRANCHRULE_PRIORITY 10000 69#define BRANCHRULE_MAXDEPTH -1 70#define BRANCHRULE_MAXBOUNDDIST 1.0 72#define DEFAULT_CONFLICTWEIGHT 0.01 73#define DEFAULT_CONFLENGTHWEIGHT 0.0 74#define DEFAULT_INFERENCEWEIGHT 0.0001 75#define DEFAULT_CUTOFFWEIGHT 0.0001 76#define DEFAULT_GMIAVGEFFWEIGHT 0.0 77#define DEFAULT_GMILASTEFFWEIGHT 0.00001 78#define DEFAULT_PSCOSTWEIGHT 1.0 79#define DEFAULT_NLSCOREWEIGHT 0.1 80#define DEFAULT_MINRELIABLE 1.0 81#define DEFAULT_MAXRELIABLE 5.0 82#define DEFAULT_SBITERQUOT 0.5 83#define DEFAULT_SBITEROFS 100000 84#define DEFAULT_MAXLOOKAHEAD 9 85#define DEFAULT_INITCAND 100 86#define DEFAULT_INITITER 0 87#define DEFAULT_MAXBDCHGS 5 88#define DEFAULT_MAXPROPROUNDS -2 90#define DEFAULT_PROBINGBOUNDS TRUE 92#define DEFAULT_USERELERRORFORRELIABILITY FALSE 93#define DEFAULT_LOWERRORTOL 0.05 94#define DEFAULT_HIGHERRORTOL 1.0 95#define DEFAULT_USEHYPTESTFORRELIABILITY FALSE 96#define DEFAULT_USEDYNAMICCONFIDENCE FALSE 97#define DEFAULT_STORESEMIINITCOSTS FALSE 98#define DEFAULT_USESBLOCALINFO FALSE 99#define DEFAULT_CONFIDENCELEVEL 2 100#define DEFAULT_SKIPBADINITCANDS TRUE 102#define DEFAULT_STARTRANDSEED 5 103#define DEFAULT_RANDINITORDER FALSE 104#define DEFAULT_USESMALLWEIGHTSITLIM FALSE 105#define DEFAULT_DYNAMICWEIGHTS TRUE 107#define DEFAULT_DEGENERACYAWARE 1 110#define DEFAULT_FILTERCANDSSYM FALSE 111#define DEFAULT_TRANSSYMPSCOST FALSE 114struct

SCIP_BranchruleData

185 int

** permstrans =

NULL

;

186 int

* components =

NULL

;

187 int

* componentbegins =

NULL

;

188 int

* vartocomponent =

NULL

;

193

assert( branchruledata !=

NULL

);

194

assert( branchruledata->filtercandssym );

197 if

( branchruledata->nosymmetry || branchruledata->orbits !=

NULL

)

200

assert( branchruledata->orbitbegins ==

NULL

);

201

assert( branchruledata->varorbitmap ==

NULL

);

202

assert( branchruledata->orbitrep ==

NULL

);

206

&nperms,

NULL

, &permstrans,

NULL

,

NULL

, &components, &componentbegins, &vartocomponent, &ncomponents) );

211

branchruledata->nosymmetry =

TRUE

;

214

assert( branchruledata->permvars !=

NULL

);

215

assert( branchruledata->permvarmap !=

NULL

);

216

assert( branchruledata->npermvars > 0 );

217

assert( permstrans !=

NULL

);

218

assert( components !=

NULL

);

219

assert( componentbegins !=

NULL

);

220

assert( vartocomponent !=

NULL

);

221

assert( ncomponents > 0 );

230

components, componentbegins, vartocomponent, ncomponents,

231

branchruledata->orbits, branchruledata->orbitbegins, &branchruledata->norbits, branchruledata->varorbitmap) );

232

assert( branchruledata->norbits < branchruledata->npermvars );

245 int

norigbranchcands,

249 int

* branchorbitidx,

256

assert( branchruledata !=

NULL

);

257

assert( origbranchcands !=

NULL

);

258

assert( origbranchcandssol !=

NULL

);

259

assert( origbranchcandsfrac !=

NULL

);

260

assert( branchcands !=

NULL

);

261

assert( branchcandssol !=

NULL

);

262

assert( branchcandsfrac !=

NULL

);

263

assert( nbranchcands !=

NULL

);

265

assert( ! branchruledata->nosymmetry );

266

assert( branchruledata->orbitbegins !=

NULL

);

267

assert( branchruledata->orbits !=

NULL

);

268

assert( branchruledata->permvarmap !=

NULL

);

269

assert( branchruledata->varorbitmap !=

NULL

);

270

assert( branchruledata->orbitrep !=

NULL

);

271

assert( branchruledata->norbits < branchruledata->npermvars );

274 for

( i = 0; i < branchruledata->norbits; ++i )

275

branchruledata->orbitrep[i] = -1;

279 for

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

285 if

( varidx != INT_MAX )

287

assert( 0 <= varidx && varidx < branchruledata->npermvars );

288

orbitidx = branchruledata->varorbitmap[varidx];

290

assert( -1 <= orbitidx && orbitidx < branchruledata->norbits );

294 if

( orbitidx == -1 )

296

branchcands[*nbranchcands] = origbranchcands[i];

297

branchcandssol[*nbranchcands] = origbranchcandssol[i];

298

branchcandsfrac[*nbranchcands] = origbranchcandsfrac[i];

299

branchorbitidx[*nbranchcands] = -1;

302 else if

( branchruledata->orbitrep[orbitidx] == -1 )

305

assert( 0 <= varidx && varidx < branchruledata->npermvars );

306

branchruledata->orbitrep[orbitidx] = varidx;

307

branchcands[*nbranchcands] = origbranchcands[i];

308

branchcandssol[*nbranchcands] = origbranchcandssol[i];

309

branchcandsfrac[*nbranchcands] = origbranchcandsfrac[i];

310

branchorbitidx[*nbranchcands] = orbitidx;

315 SCIPdebugMsg

(

scip

,

"Filtered out %d variables by symmetry.\n"

, norigbranchcands - *nbranchcands);

326 int

* branchorbitidx,

337

assert( branchruledata !=

NULL

);

339 if

( branchruledata->nosymmetry || ! branchruledata->transsympscost || branchorbitidx ==

NULL

)

346

assert( branchruledata->orbitbegins !=

NULL

);

347

assert( branchruledata->orbits !=

NULL

);

348

assert( 0 <= branchvaridx && branchvaridx < branchruledata->npermvars );

350

orbitidx = branchorbitidx[branchvaridx];

357

assert( 0 <= orbitidx && orbitidx < branchruledata->norbits );

360 for

( j = branchruledata->orbitbegins[orbitidx]; j < branchruledata->orbitbegins[orbitidx+1]; ++j )

365

idx = branchruledata->orbits[j];

366

assert( 0 <= idx && idx < branchruledata->npermvars );

368

var = branchruledata->permvars[idx];

369

assert( var !=

NULL

);

399

assert(nlcount !=

NULL

);

400

assert(nlcountmax !=

NULL

);

403

assert(nlcountsize >= nvars);

418 if

( andconshdlr !=

NULL

)

441 if

( probindex >= 0 )

442

++nlcount[probindex];

445 for

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

451 if

( probindex >= 0 )

452

++nlcount[probindex];

460 for

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

462 if

( *nlcountmax < nlcount[i] )

463

*nlcountmax = nlcount[i];

478

assert(branchruledata !=

NULL

);

484 if

( branchruledata->nlscoreweight > 0.0 )

486 if

( branchruledata->nlcount ==

NULL

)

489

branchruledata->nlcountsize = nvars;

493 else if

( branchruledata->nlcountsize < nvars )

497 BMSclearMemoryArray

(&(branchruledata->nlcount[branchruledata->nlcountsize]), nvars - branchruledata->nlcountsize);

498

branchruledata->nlcountsize = nvars;

500

assert(branchruledata->nlcount !=

NULL

);

501

assert(branchruledata->nlcountsize == nvars);

502

assert(branchruledata->nlcountmax >= 1);

507

branchruledata->nlcountsize = 0;

508

branchruledata->nlcountmax = 1;

524 if

( nlcountmax >= 1 && nlcount !=

NULL

)

529

assert(probindex >= 0);

532

nlscore = nlcount[probindex] / (

SCIP_Real

)nlcountmax;

534

assert(nlscore >= 0.0);

535

assert(nlscore <= 1.0);

567

assert(branchruledata !=

NULL

);

568

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

570 if

( branchruledata->dynamicweights )

577

dynamicfactor *= degeneracyfactor;

579

score = dynamicfactor * (branchruledata->conflictweight * (1.0 - 1.0/(1.0+conflictscore/avgconflictscore))

580

+ branchruledata->conflengthweight * (1.0 - 1.0/(1.0+conflengthscore/avgconflengthscore))

581

+ branchruledata->inferenceweight * (1.0 - 1.0/(1.0+inferencescore/avginferencescore))

582

+ branchruledata->cutoffweight * (1.0 - 1.0/(1.0+cutoffscore/avgcutoffscore))

583

+ branchruledata->gmiavgeffweight * gmieffscore + branchruledata->gmilasteffweight * lastgmieffscore)

584

+ branchruledata->pscostweight / dynamicfactor * (1.0 - 1.0/(1.0+pscostscore/avgpscostscore))

585

+ branchruledata->nlscoreweight * nlscore;

607

assert(bdchginds !=

NULL

);

608

assert(bdchgtypes !=

NULL

);

609

assert(bdchgbounds !=

NULL

);

610

assert(nbdchgs !=

NULL

);

615

assert(*bdchginds !=

NULL

);

616

assert(*bdchgtypes !=

NULL

);

617

assert(*bdchgbounds !=

NULL

);

619

(*bdchginds)[*nbdchgs] = ind;

620

(*bdchgtypes)[*nbdchgs] = type;

621

(*bdchgbounds)[*nbdchgs] =

bound

;

639

assert(bdchginds !=

NULL

);

640

assert(bdchgtypes !=

NULL

);

641

assert(bdchgbounds !=

NULL

);

642

assert(nbdchgs !=

NULL

);

671

assert(vars !=

NULL

);

676

assert(branchrule !=

NULL

);

680

assert(branchruledata !=

NULL

);

685 for

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

705

assert(tightened || (branchruledata->maxproprounds != 0));

720

assert(tightened || (branchruledata->maxproprounds != 0));

736 int

* branchorbitidx,

770

assert(branchruledata !=

NULL

);

784

bestisstrongbranch =

FALSE

;

787

bestsbdownvalid =

FALSE

;

788

bestsbupvalid =

FALSE

;

789

bestsbdowncutoff =

FALSE

;

790

bestsbupcutoff =

FALSE

;

791

provedbound = lpobjval;

801 if

( nbranchcands == 1 )

806

sbdownvalid[0] =

FALSE

;

807

sbupvalid[0] =

FALSE

;

857 int

bestuninitsbcand;

866 if

( branchruledata->degeneracyaware > 0 && (

SCIPgetDepth

(

scip

) > 0 || branchruledata->degeneracyaware > 1) )

874

assert(degeneracy >= 0.0);

875

assert(degeneracy <= 1.0);

876

assert(varconsratio >= 1.0);

879 if

( degeneracy >= 0.8 )

881

degeneracy = 10.0 * (degeneracy - 0.7);

882

degeneracyfactor = degeneracyfactor * pow(10.0,degeneracy);

885 if

( varconsratio >= 2.0 )

887

degeneracyfactor *= 10.0 * varconsratio;

898

avgconflictscore =

MAX

(avgconflictscore, 0.1);

900

avgconflengthscore =

MAX

(avgconflengthscore, 0.1);

902

avginferencescore =

MAX

(avginferencescore, 0.1);

904

avgcutoffscore =

MAX

(avgcutoffscore, 0.1);

906

avgpscostscore =

MAX

(avgpscostscore, 0.1);

911

initstrongbranching =

FALSE

;

914

propagate = (branchruledata->maxproprounds != 0);

917

probingbounds = propagate && branchruledata->probingbounds;

922

maxninitcands =

MIN

(nbranchcands, branchruledata->initcand);

932 if

( nsblpiterations > maxnsblpiterations || degeneracyfactor >= 10.0 )

956

maxbdchgs = branchruledata->maxbdchgs;

957 if

( maxbdchgs == -1 )

961

prio = (maxnsblpiterations - nsblpiterations)/(nsblpiterations + 1.0);

962

prio =

MIN

(prio, 1.0);

963

prio =

MAX

(prio, (nlpiterationsquot - nsblpiterations)/(nsblpiterations + 1.0));

964

reliable = (1.0-prio) * branchruledata->minreliable + prio * branchruledata->maxreliable;

967

relerrorthreshold = (1.0 - prio) * branchruledata->higherrortol + prio * branchruledata->lowerrortol;

971 if

( branchruledata->usedynamicconfidence )

976 else if

( prio >= 0.7 )

978 else if

( prio >= 0.5 )

980 else if

( prio >= 0.3 )

994 if

( branchruledata->usehyptestforreliability )

996 for

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

1030

downgain =

MAX

(down - lastlpobjval, 0.0);

1031

upgain =

MAX

(up - lastlpobjval, 0.0);

1034 SCIPdebugMsg

(

scip

,

" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n"

,

1035 SCIPvarGetName

(branchcands[c]), down, downgain, up, upgain, pscostscore);

1038

score =

calcScore

(

scip

, branchruledata, conflictscore, avgconflictscore, conflengthscore, avgconflengthscore,

1039

inferencescore, avginferencescore, cutoffscore, avgcutoffscore, gmieffscore, lastgmieffscore,

1040

pscostscore, avgpscostscore, nlscore, branchcandsfrac[c], degeneracyfactor);

1048

fracscore =

MIN

(branchcandsfrac[c], 1.0 - branchcandsfrac[c]);

1052

|| (

SCIPisSumGE

(

scip

, fracscore, bestpsfracscore) && domainscore > bestpsdomainscore) )

1055

bestpsscore = score;

1056

bestpsfracscore = fracscore;

1057

bestpsdomainscore = domainscore;

1063 for

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

1079

assert(branchcands[c] !=

NULL

);

1086

sbdownvalid[c] =

FALSE

;

1087

sbupvalid[c] =

FALSE

;

1091

mingains[c] =

MIN

(downgain, upgain);

1092

maxgains[c] =

MAX

(downgain, upgain);

1117

downgain =

MAX

(down - lastlpobjval, 0.0);

1118

upgain =

MAX

(up - lastlpobjval, 0.0);

1121

mingains[c] =

MIN

(downgain, upgain);

1122

maxgains[c] =

MAX

(downgain, upgain);

1124 SCIPdebugMsg

(

scip

,

" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n"

,

1125 SCIPvarGetName

(branchcands[c]), down, downgain, up, upgain, pscostscore);

1127 else if

( maxninitcands > 0 )

1136

size =

MIN

(downsize, upsize);

1140

assert(!branchruledata->usehyptestforreliability || bestpscand >= 0);

1142 if

( size < reliable )

1144 else if

( branchruledata->userelerrorforreliability && branchruledata->usehyptestforreliability )

1154 else if

( branchruledata->userelerrorforreliability &&

1158 else if

( branchruledata->usehyptestforreliability &&

1171

scoresfrompc[c] =

calcScore

(

scip

, branchruledata, 0.0, avgconflictscore, 0.0, avgconflengthscore,

1172

0.0, avginferencescore, 0.0, avgcutoffscore, 0.0, 0.0,

1173

pscostscore, avgpscostscore, 0.0, branchcandsfrac[c], degeneracyfactor);

1174

scoresfromothers[c] =

calcScore

(

scip

, branchruledata, conflictscore, avgconflictscore, conflengthscore, avgconflengthscore,

1175

inferencescore, avginferencescore, cutoffscore, avgcutoffscore, gmieffscore, lastgmieffscore,

1176

0.0, avgpscostscore, nlscore, branchcandsfrac[c], degeneracyfactor);

1177

score = scoresfrompc[c] + scoresfromothers[c];

1188

scoresfrompc[c] = 0;

1189

scoresfromothers[c] = 0;

1192 if

( branchruledata->randinitorder )

1196 for

( j = ninitcands; j > 0 && score > initcandscores[j-1]; --j )

1198

initcands[j] = initcands[j-1];

1199

initcandscores[j] = initcandscores[j-1];

1202

initcandscores[j] = score;

1204

ninitcands =

MIN

(ninitcands, maxninitcands);

1207 else if

( !branchruledata->usehyptestforreliability )

1215

fracscore =

MIN

(branchcandsfrac[c], 1.0 - branchcandsfrac[c]);

1219

|| (

SCIPisSumGE

(

scip

, fracscore, bestpsfracscore) && domainscore > bestpsdomainscore) )

1222

bestpsscore = score;

1223

bestpsfracscore = fracscore;

1224

bestpsdomainscore = domainscore;

1231 if

( branchruledata->usehyptestforreliability && ninitcands == 1 )

1234 SCIPdebugMsg

(

scip

,

"Only one single candidate for initialization-->Skipping strong branching\n"

);

1241

inititer = branchruledata->inititer;

1242 if

( inititer == 0 )

1259

nlpiterations = 1000;

1264

inititer = (int)(2*nlpiterations / nlps);

1265

inititer = (int)((

SCIP_Real

)inititer * (1.0 + 20.0/nodenum));

1266

inititer =

MAX

(inititer, 10);

1267

inititer =

MIN

(inititer, 500);

1270 SCIPdebugMsg

(

scip

,

"strong branching (reliable=%g, %d/%d cands, %d uninit, maxcands=%d, maxlookahead=%g, maxbdchgs=%d, inititer=%d, iterations:%" SCIP_LONGINT_FORMAT "/%" SCIP_LONGINT_FORMAT ", basic:%u)\n"

,

1271

reliable, ninitcands, nbranchcands, nuninitcands, maxninitcands, maxlookahead, maxbdchgs, inititer,

1279

bestuninitsbcand = -1;

1281 for

( i = 0; i < ninitcands && lookahead < maxlookahead && nbdchgs + nbdconflicts < maxbdchgs

1302 if

( branchruledata->skipbadinitcands )

1308 if

( bestsbscore > bestpsscore && bestsbscore > bestuninitsbscore && bestsbupvalid && bestsbdownvalid )

1310

assert(bestsbcand != -1);

1325 else if

( bestpscand != -1 && bestpsscore > bestuninitsbscore )

1334 else if

( bestuninitsbcand != -1 )

1346 if

( bestuninitsbcand == -1 )

1348

bestuninitsbcand = c;

1349

bestuninitsbscore = initcandscores[i];

1357 SCIPvarGetName

(branchcands[c]), branchcandssol[c], initcandscores[i],

1361 if

( !initstrongbranching )

1363

initstrongbranching =

TRUE

;

1368 if

( probingbounds )

1379

branchruledata->maxproprounds, &down, &up, &downvalid, &upvalid, &ndomredsdown, &ndomredsup, &downinf, &upinf,

1380

&downconflict, &upconflict, &lperror, newlbs, newubs) );

1386

&down, &up, &downvalid, &upvalid, &downinf, &upinf, &downconflict, &upconflict, &lperror) );

1388

ndomredsdown = ndomredsup = 0;

1397 "(node %" SCIP_LONGINT_FORMAT ") error in strong branching call for variable <%s> with solution %g\n"

,

1412 SCIPdebugMsg

(

scip

,

" -> strong branching on variable <%s> lead to a new incumbent\n"

,

1428 else if

( bestsbcand != -1 && allcolsinlp )

1432

bestsbdowncutoff =

TRUE

;

1434 SCIPdebugMsg

(

scip

,

" -> valid dual bound for down child of best candidate <%s> is higher than new cutoff bound (valid=%u, bestsbdown=%g, cutoff=%g)\n"

,

1437 SCIPdebugMsg

(

scip

,

" -> increase lower bound of best candidate <%s> to %g\n"

,

1446

bestsbupcutoff =

TRUE

;

1448 SCIPdebugMsg

(

scip

,

" -> valid dual bound for up child of best candidate <%s> is higher than new cutoff bound (valid=%u, bestsbup=%g, cutoff=%g)\n"

,

1451 SCIPdebugMsg

(

scip

,

" -> decrease upper bound of best candidate <%s> to %g\n"

,

1461

down =

MAX

(down, lpobjval);

1462

up =

MAX

(up, lpobjval);

1463

downgain = down - lpobjval;

1464

upgain = up - lpobjval;

1467

assert(downinf || !downconflict);

1468

assert(upinf || !upconflict);

1475

#ifdef WITH_LPSOLSTAT

1478

&& (!upinf || branchruledata->storesemiinitcosts) )

1483 if

( branchruledata->usesmallweightsitlim )

1492

#ifdef WITH_LPSOLSTAT

1495

&& (!downinf || branchruledata->storesemiinitcosts) )

1500 if

( branchruledata->usesmallweightsitlim )

1510 if

( allcolsinlp && !exactsolve && downvalid && upvalid )

1514

minbound =

MIN

(down, up);

1515

provedbound =

MAX

(provedbound, minbound);

1519 if

( probingbounds && ( !downinf || !upinf ) )

1523

assert(newlbs !=

NULL

);

1524

assert(newubs !=

NULL

);

1526 for

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

1530 SCIPdebugMsg

(

scip

,

"better lower bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n"

,

1538 SCIPdebugMsg

(

scip

,

"better upper bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n"

,

1549 if

( downinf || upinf )

1551

assert(allcolsinlp || propagate);

1552

assert(!exactsolve);

1554 if

( downinf && upinf )

1557 SCIPdebugMsg

(

scip

,

" -> variable <%s> is infeasible in both directions (conflict: %u/%u)\n"

,

1565 SCIPdebugMsg

(

scip

,

" -> variable <%s> is infeasible in %s branch (conflict: %u/%u)\n"

,

1566 SCIPvarGetName

(branchcands[c]), downinf ?

"downward"

:

"upward"

, downconflict, upconflict);

1570 if

( nbdchgs + nbdconflicts >= maxbdchgs )

1586

mingains[c] =

MIN

(downgain, upgain);

1587

maxgains[c] =

MAX

(downgain, upgain);

1591

sbdownvalid[c] = downvalid;

1592

sbupvalid[c] = upvalid;

1609

scoresfrompc[c] =

calcScore

(

scip

, branchruledata, 0.0, avgconflictscore, 0.0, avgconflengthscore,

1610

0.0, avginferencescore, 0.0, avgcutoffscore, 0.0, 0.0, pscostscore,

1611

avgpscostscore, 0.0, branchcandsfrac[c], degeneracyfactor);

1612

scoresfromothers[c] =

calcScore

(

scip

, branchruledata, conflictscore, avgconflictscore, conflengthscore, avgconflengthscore,

1613

inferencescore, avginferencescore, cutoffscore, avgcutoffscore, gmieffscore,

1614

lastgmieffscore, 0.0, avgpscostscore, nlscore, branchcandsfrac[c],

1616

score = scoresfrompc[c] + scoresfromothers[c];

1627

fracscore =

MIN

(branchcandsfrac[c], 1.0 - branchcandsfrac[c]);

1631

|| (

SCIPisSumGE

(

scip

, fracscore, bestsbfracscore) && domainscore > bestsbdomainscore) )

1634

bestsbscore = score;

1637

bestsbdownvalid = downvalid;

1638

bestsbupvalid = upvalid;

1639

bestsbdowncutoff =

FALSE

;

1640

bestsbupcutoff =

FALSE

;

1641

bestsbfracscore = fracscore;

1642

bestsbdomainscore = domainscore;

1651 SCIPdebugMsg

(

scip

,

" -> variable <%s> (solval=%g, down=%g (%+g,valid=%u), up=%g (%+g,valid=%u), score=%g/ %g/%g %g/%g %g -> %g)\n"

,

1652 SCIPvarGetName

(branchcands[c]), branchcandssol[c], down, downgain, downvalid, up, upgain, upvalid,

1653

pscostscore, conflictscore, conflengthscore, inferencescore, cutoffscore, gmieffscore, score);

1657 if

( bestsbcand >= 0 )

1660 SCIPvarGetName

(branchcands[bestsbcand]), bestsbscore, bestsbfracscore, bestsbdomainscore,

1661

lookahead, maxlookahead);

1665 if

( initstrongbranching )

1667 if

( probingbounds )

1669

assert(newlbs !=

NULL

);

1670

assert(newubs !=

NULL

);

1688 if

( i < ninitcands && bestuninitsbcand == -1 )

1689

bestuninitsbscore = initcandscores[i];

1694 if

( bestpsscore > bestuninitsbscore &&

SCIPisSumGT

(

scip

, bestpsscore, bestsbscore) )

1696

bestcand = bestpscand;

1697

bestisstrongbranch =

FALSE

;

1699 else if

( bestsbcand >= 0 )

1701

bestcand = bestsbcand;

1702

bestisstrongbranch =

TRUE

;

1709

assert(ninitcands >= 1);

1710

bestcand = initcands[0];

1711

bestisstrongbranch =

FALSE

;

1715 if

( allcolsinlp && !exactsolve )

1732 freeBdchgs

(

scip

, &bdchginds, &bdchgtypes, &bdchgbounds, &nbdchgs);

1741

usetreemodel =

TRUE

;

1746

usetreemodel =

FALSE

;

1753 if

( usetreemodel ==

TRUE

&& avgpscostscore <= smallpscost )

1756 for

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

1758 if

( scoresfrompc[cand] > scoresfrompc[bestcand] )

1760

usetreemodel =

FALSE

;

1766 if

( usetreemodel ==

TRUE

)

1770

branchruledata->treemodel,

1802

assert(0 <= bestcand && bestcand < nbranchcands);

1805

assert(!bestsbdowncutoff && !bestsbupcutoff);

1807

var = branchcands[bestcand];

1808

val = branchcandssol[bestcand];

1811 SCIPdebugMsg

(

scip

,

" -> %d (%d) cands, sel cand %d: var <%s> (sol=%g, down=%g (%+g), up=%g (%+g), sb=%u, psc=%g/%g [%g])\n"

,

1812

nbranchcands, ninitcands, bestcand,

SCIPvarGetName

(var), branchcandssol[bestcand],

1813

bestsbdown, bestsbdown - lpobjval, bestsbup, bestsbup - lpobjval, bestisstrongbranch,

1819

assert(downchild !=

NULL

);

1820

assert(upchild !=

NULL

);

1823 if

( allcolsinlp && !exactsolve )

1825 if

( sbdownvalid[bestcand] )

1831 if

( sbupvalid[bestcand] )

1866

assert(branchrule !=

NULL

);

1901

branchruledata->nlcount =

NULL

;

1902

branchruledata->nlcountsize = 0;

1903

branchruledata->nlcountmax = 1;

1904

assert(branchruledata->startrandseed >= 0);

1908

(

unsigned int

)branchruledata->startrandseed,

TRUE

) );

1931

branchruledata->nosymmetry =

FALSE

;

1932

branchruledata->norbits = 0;

1933

branchruledata->permvars =

NULL

;

1934

branchruledata->permvarmap =

NULL

;

1935

branchruledata->npermvars = 0;

1953 int

* filteredlpcandsorbitidx =

NULL

;

1954 int

nfilteredlpcands;

1957

assert(branchrule !=

NULL

);

1960

assert(result !=

NULL

);

1967 SCIPdebugMsg

(

scip

,

"Could not apply relpscost branching, as the current LP was not solved to optimality.\n"

);

1974

assert(nlpcands > 0);

1977

assert(branchruledata !=

NULL

);

1989 if

( runfiltering && branchruledata->norbits != 0 )

1998

filteredlpcands, filteredlpcandssol, filteredlpcandsfrac, filteredlpcandsorbitidx, &nfilteredlpcands) );

2006

nfilteredlpcands = nlpcands;

2010 SCIP_CALL

(

execRelpscost

(

scip

, branchrule, filteredlpcands, filteredlpcandssol, filteredlpcandsfrac, filteredlpcandsorbitidx, nfilteredlpcands,

TRUE

, result) );

2036

branchruledata->nosymmetry =

FALSE

;

2037

branchruledata->orbits =

NULL

;

2038

branchruledata->orbitbegins =

NULL

;

2039

branchruledata->orbitrep =

NULL

;

2040

branchruledata->varorbitmap =

NULL

;

2041

branchruledata->norbits = 0;

2042

branchruledata->permvars =

NULL

;

2043

branchruledata->npermvars = 0;

2044

branchruledata->permvarmap =

NULL

;

2050

assert(branchrule !=

NULL

);

2061 "branching/relpscost/conflictweight"

,

2062 "weight in score calculations for conflict score"

,

2065 "branching/relpscost/conflictlengthweight"

,

2066 "weight in score calculations for conflict length score"

,

2069 "branching/relpscost/inferenceweight"

,

2070 "weight in score calculations for inference score"

,

2073 "branching/relpscost/cutoffweight"

,

2074 "weight in score calculations for cutoff score"

,

2077 "branching/relpscost/gmiavgeffweight"

,

2078 "weight in score calculations for average GMI cuts normalized efficacy"

,

2081 "branching/relpscost/gmilasteffweight"

,

2082 "weight in score calculations for last GMI cuts normalized efficacy"

,

2085 "branching/relpscost/pscostweight"

,

2086 "weight in score calculations for pseudo cost score"

,

2089 "branching/relpscost/nlscoreweight"

,

2090 "weight in score calculations for nlcount score"

,

2093 "branching/relpscost/minreliable"

,

2094 "minimal value for minimum pseudo cost size to regard pseudo cost value as reliable"

,

2097 "branching/relpscost/maxreliable"

,

2098 "maximal value for minimum pseudo cost size to regard pseudo cost value as reliable"

,

2101 "branching/relpscost/sbiterquot"

,

2102 "maximal fraction of strong branching LP iterations compared to node relaxation LP iterations"

,

2105 "branching/relpscost/sbiterofs"

,

2106 "additional number of allowed strong branching LP iterations"

,

2109 "branching/relpscost/maxlookahead"

,

2110 "maximal number of further variables evaluated without better score"

,

2113 "branching/relpscost/initcand"

,

2114 "maximal number of candidates initialized with strong branching per node"

,

2117 "branching/relpscost/inititer"

,

2118 "iteration limit for strong branching initializations of pseudo cost entries (0: auto)"

,

2121 "branching/relpscost/maxbdchgs"

,

2122 "maximal number of bound tightenings before the node is reevaluated (-1: unlimited)"

,

2125 "branching/relpscost/maxproprounds"

,

2126 "maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)"

,

2129 "branching/relpscost/probingbounds"

,

2130 "should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?"

,

2146 "should strong branching result be considered for pseudo costs if the other direction was infeasible?"

,

2153 "should the scoring function use only local cutoff and inference information obtained for strong branching candidates?"

,

2158 "should the strong branching decision be based on a hypothesis test?"

,

2163 "should the confidence level be adjusted dynamically?"

,

2167 "should branching rule skip candidates that have a low probability to " 2168 "be better than the best strong-branching or pseudo-candidate?"

,

2172 "branching/relpscost/confidencelevel"

,

2173 "the confidence level for statistical methods, between 0 (Min) and 4 (Max)."

,

2177 "should candidates be initialized in randomized order?"

,

2182 "should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?"

,

2187 "should the weights of the branching rule be adjusted dynamically during solving based on objective and infeasible leaf counters?"

,

2191 "should degeneracy be taken into account to update weights and skip strong branching? (0: off, 1: after root, 2: always)"

,

2198 "Use symmetry to filter branching candidates?"

,

2202 "Transfer pscost information to symmetric variables?"

,

2225

assert(result !=

NULL

);

2229

assert(branchrule !=

NULL

);

#define DEFAULT_DEGENERACYAWARE

#define DEFAULT_USESBLOCALINFO

#define DEFAULT_SKIPBADINITCANDS

#define DEFAULT_SBITERQUOT

static SCIP_Real calcNlscore(SCIP *scip, int *nlcount, int nlcountmax, int probindex)

#define DEFAULT_HIGHERRORTOL

#define BRANCHRULE_PRIORITY

#define DEFAULT_PROBINGBOUNDS

#define DEFAULT_USESMALLWEIGHTSITLIM

static SCIP_RETCODE applyBdchgs(SCIP *scip, SCIP_VAR **vars, int *bdchginds, SCIP_BOUNDTYPE *bdchgtypes, SCIP_Real *bdchgbounds, int nbdchgs, SCIP_RESULT *result)

#define DEFAULT_STARTRANDSEED

#define DEFAULT_FILTERCANDSSYM

#define DEFAULT_USEDYNAMICCONFIDENCE

#define DEFAULT_DYNAMICWEIGHTS

#define DEFAULT_MAXBDCHGS

#define DEFAULT_USEHYPTESTFORRELIABILITY

#define DEFAULT_GMIAVGEFFWEIGHT

static SCIP_RETCODE SCIPupdateVarPseudocostSymmetric(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR *branchvar, int *branchorbitidx, int branchvaridx, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)

#define DEFAULT_INFERENCEWEIGHT

#define DEFAULT_RANDINITORDER

static SCIP_RETCODE initOrbits(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)

#define DEFAULT_MAXLOOKAHEAD

#define DEFAULT_SBITEROFS

static SCIP_DECL_BRANCHFREE(branchFreeRelpscost)

#define DEFAULT_NLSCOREWEIGHT

#define DEFAULT_CONFLICTWEIGHT

static SCIP_RETCODE filterSymmetricVariables(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR **origbranchcands, SCIP_Real *origbranchcandssol, SCIP_Real *origbranchcandsfrac, int norigbranchcands, SCIP_VAR **branchcands, SCIP_Real *branchcandssol, SCIP_Real *branchcandsfrac, int *branchorbitidx, int *nbranchcands)

#define DEFAULT_GMILASTEFFWEIGHT

#define DEFAULT_USERELERRORFORRELIABILITY

#define DEFAULT_CUTOFFWEIGHT

static SCIP_DECL_BRANCHCOPY(branchCopyRelpscost)

static SCIP_RETCODE countNonlinearities(SCIP *scip, int *nlcount, int nlcountsize, int *nlcountmax)

static SCIP_DECL_BRANCHINITSOL(branchInitsolRelpscost)

#define DEFAULT_TRANSSYMPSCOST

static SCIP_RETCODE addBdchg(SCIP *scip, int **bdchginds, SCIP_BOUNDTYPE **bdchgtypes, SCIP_Real **bdchgbounds, int *nbdchgs, int ind, SCIP_BOUNDTYPE type, SCIP_Real bound)

#define DEFAULT_LOWERRORTOL

static SCIP_RETCODE execRelpscost(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_VAR **branchcands, SCIP_Real *branchcandssol, SCIP_Real *branchcandsfrac, int *branchorbitidx, int nbranchcands, SCIP_Bool executebranch, SCIP_RESULT *result)

static SCIP_RETCODE branchruledataEnsureNlcount(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)

#define DEFAULT_CONFLENGTHWEIGHT

#define DEFAULT_CONFIDENCELEVEL

#define DEFAULT_MINRELIABLE

static SCIP_Real calcScore(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_Real conflictscore, SCIP_Real avgconflictscore, SCIP_Real conflengthscore, SCIP_Real avgconflengthscore, SCIP_Real inferencescore, SCIP_Real avginferencescore, SCIP_Real cutoffscore, SCIP_Real avgcutoffscore, SCIP_Real gmieffscore, SCIP_Real lastgmieffscore, SCIP_Real pscostscore, SCIP_Real avgpscostscore, SCIP_Real nlscore, SCIP_Real frac, SCIP_Real degeneracyfactor)

#define DEFAULT_STORESEMIINITCOSTS

#define DEFAULT_MAXPROPROUNDS

static SCIP_DECL_BRANCHEXITSOL(branchExitsolRelpscost)

#define BRANCHRULE_MAXDEPTH

#define DEFAULT_MAXRELIABLE

#define DEFAULT_PSCOSTWEIGHT

#define BRANCHRULE_MAXBOUNDDIST

static void freeBdchgs(SCIP *scip, int **bdchginds, SCIP_BOUNDTYPE **bdchgtypes, SCIP_Real **bdchgbounds, int *nbdchgs)

static SCIP_DECL_BRANCHEXECLP(branchExeclpRelpscost)

reliable pseudo costs branching rule

Constraint handler for AND constraints, .

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPexecRelpscostBranching(SCIP *scip, SCIP_VAR **branchcands, SCIP_Real *branchcandssol, SCIP_Real *branchcandsfrac, int nbranchcands, SCIP_Bool executebranching, SCIP_RESULT *result)

SCIP_RETCODE SCIPincludeBranchruleRelpscost(SCIP *scip)

SCIP_VAR * SCIPgetResultantAnd(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNVarsAnd(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsAnd(SCIP *scip, SCIP_CONS *cons)

int SCIPgetSubscipDepth(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_Bool SCIPisExactSolve(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

int SCIPgetNVars(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPhashmapGetImageInt(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)

SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)

SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)

SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)

SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))

SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))

SCIP_RETCODE SCIPincludeBranchruleBasic(SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)

const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)

SCIP_BRANCHRULEDATA * SCIPbranchruleGetData(SCIP_BRANCHRULE *branchrule)

SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))

SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))

void SCIPbranchruleSetData(SCIP_BRANCHRULE *branchrule, SCIP_BRANCHRULEDATA *branchruledata)

SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINITSOL((*branchinitsol)))

SCIP_RETCODE SCIPbranchVarVal(SCIP *scip, SCIP_VAR *var, SCIP_Real val, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)

SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)

SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPgetLPDualDegeneracy(SCIP *scip, SCIP_Real *degeneracy, SCIP_Real *varconsratio)

SCIP_Bool SCIPinDive(SCIP *scip)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

SCIP_Bool SCIPallColsInLP(SCIP *scip)

SCIP_Real SCIPgetLPObjval(SCIP *scip)

SCIP_Bool SCIPisLPSolBasic(SCIP *scip)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPreallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

int SCIPgetNNLPVars(SCIP *scip)

SCIP_RETCODE SCIPgetNLPVarsNonlinearity(SCIP *scip, int *nlcount)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_SOL * SCIPgetBestSol(SCIP *scip)

int SCIPsolGetIndex(SCIP_SOL *sol)

SCIP_Real SCIPgetAvgInferenceScore(SCIP *scip)

SCIP_Real SCIPgetAvgConflictlengthScore(SCIP *scip)

SCIP_Longint SCIPgetNInfeasibleLeaves(SCIP *scip)

SCIP_Longint SCIPgetNNodes(SCIP *scip)

SCIP_Longint SCIPgetNNodeInitLPs(SCIP *scip)

SCIP_Longint SCIPgetNStrongbranchLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgConflictScore(SCIP *scip)

SCIP_Longint SCIPgetNDualResolveLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgPseudocostScore(SCIP *scip)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

SCIP_Longint SCIPgetNObjlimLeaves(SCIP *scip)

SCIP_Longint SCIPgetNNodeInitLPIterations(SCIP *scip)

SCIP_Longint SCIPgetNDualResolveLPs(SCIP *scip)

SCIP_Longint SCIPgetNRootStrongbranchLPIterations(SCIP *scip)

SCIP_Real SCIPgetAvgCutoffScore(SCIP *scip)

SCIP_RETCODE SCIPcomputeOrbitsComponentsSym(SCIP *scip, int npermvars, int **permstrans, int nperms, int *components, int *componentbegins, int *vartocomponent, int ncomponents, int *orbits, int *orbitbegins, int *norbits, int *varorbitmap)

SCIP_Real SCIPinfinity(SCIP *scip)

SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeastol(SCIP *scip)

SCIP_Bool SCIPisSumGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisSumGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

int SCIPgetDepth(SCIP *scip)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)

SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)

SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)

SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)

SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)

SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)

SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)

SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)

SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)

SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)

SCIP_Real SCIPgetVarAvgGMIScore(SCIP *scip, SCIP_VAR *var)

SCIP_Real SCIPgetVarLastGMIScore(SCIP *scip, SCIP_VAR *var)

SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)

SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)

SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)

SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)

void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)

SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)

SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)

memory allocation routines

#define BMSclearMemoryArray(ptr, num)

SCIP_RETCODE SCIPgetSymmetry(SCIP *scip, int *npermvars, SCIP_VAR ***permvars, SCIP_HASHMAP **permvarmap, int *nperms, int ***perms, int ***permstrans, SCIP_Real *log10groupsize, SCIP_Bool *binvaraffected, int **components, int **componentbegins, int **vartocomponent, int *ncomponents)

propagator for symmetry handling

public methods for branching rules

public methods for managing constraints

public methods for message output

public data structures and miscellaneous methods

public methods for primal CIP solutions

public methods for branch and bound tree

public methods for problem variables

public methods for branching rule plugins and branching

public methods for constraint handler plugins and constraints

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for random numbers

public methods for solutions

public methods for querying solving statistics

public methods for the branch-and-bound tree

public methods for SCIP variables

methods for handling symmetries

SCIP_RETCODE SCIPtreemodelSelectCandidate(SCIP *scip, SCIP_TREEMODEL *treemodel, SCIP_VAR **branchcands, SCIP_Real *mingains, SCIP_Real *maxgains, SCIP_Real *tiebreakerscore, int nbranchcands, int *bestcand)

SCIP_RETCODE SCIPtreemodelInit(SCIP *scip, SCIP_TREEMODEL **treemodel)

SCIP_RETCODE SCIPtreemodelFree(SCIP *scip, SCIP_TREEMODEL **treemodel)

SCIP_Bool SCIPtreemodelIsEnabled(SCIP *scip, SCIP_TREEMODEL *treemodel)

Branching rules based on the Single-Variable-Branching (SVB) model.

struct SCIP_BranchruleData SCIP_BRANCHRULEDATA

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BoundType SCIP_BOUNDTYPE

@ SCIP_LPSOLSTAT_INFEASIBLE

@ SCIP_LPSOLSTAT_OBJLIMIT

@ SCIP_LPSOLSTAT_ITERLIMIT

@ SCIP_CONFIDENCELEVEL_MAX

@ SCIP_CONFIDENCELEVEL_MEDIUM

@ SCIP_CONFIDENCELEVEL_HIGH

@ SCIP_CONFIDENCELEVEL_MIN

@ SCIP_CONFIDENCELEVEL_LOW

enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4