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;
194 assert( branchruledata->filtercandssym );
197 if( branchruledata->nosymmetry || branchruledata->orbits !=
NULL )
200 assert( branchruledata->orbitbegins ==
NULL );
201 assert( branchruledata->varorbitmap ==
NULL );
206 &nperms,
NULL, &permstrans,
NULL,
NULL, &components, &componentbegins, &vartocomponent, &ncomponents) );
211 branchruledata->nosymmetry =
TRUE;
216 assert( branchruledata->npermvars > 0 );
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,
265 assert( ! branchruledata->nosymmetry );
266 assert( branchruledata->orbitbegins !=
NULL );
269 assert( branchruledata->varorbitmap !=
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 )
288 orbitidx = branchruledata->varorbitmap[
varidx];
290 assert( -1 <= orbitidx && orbitidx < branchruledata->norbits );
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 )
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);
339 if( branchruledata->nosymmetry || ! branchruledata->transsympscost || branchorbitidx ==
NULL )
346 assert( branchruledata->orbitbegins !=
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];
418 if( andconshdlr !=
NULL )
442 ++nlcount[probindex];
445 for( v = 0; v < nandvars; ++v )
452 ++nlcount[probindex];
462 if( *nlcountmax < nlcount[
i] )
463 *nlcountmax = nlcount[
i];
484 if( branchruledata->nlscoreweight > 0.0 )
486 if( branchruledata->nlcount ==
NULL )
489 branchruledata->nlcountsize =
nvars;
493 else if( branchruledata->nlcountsize <
nvars )
498 branchruledata->nlcountsize =
nvars;
502 assert(branchruledata->nlcountmax >= 1);
507 branchruledata->nlcountsize = 0;
508 branchruledata->nlcountmax = 1;
524 if( nlcountmax >= 1 && nlcount !=
NULL )
532 nlscore = nlcount[probindex] / (
SCIP_Real)nlcountmax;
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;
619 (*bdchginds)[*nbdchgs] = ind;
620 (*bdchgtypes)[*nbdchgs] = type;
621 (*bdchgbounds)[*nbdchgs] =
bound;
685 for(
i = 0;
i < nbdchgs; ++
i )
705 assert(tightened || (branchruledata->maxproprounds != 0));
720 assert(tightened || (branchruledata->maxproprounds != 0));
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 )
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;
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];
1361 if( !initstrongbranching )
1363 initstrongbranching =
TRUE;
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 ) )
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 )
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 )
1688 if(
i < ninitcands && bestuninitsbcand == -1 )
1689 bestuninitsbscore = initcandscores[
i];
1694 if( bestpsscore > bestuninitsbscore &&
SCIPisSumGT(
scip, bestpsscore, bestsbscore) )
1697 bestisstrongbranch =
FALSE;
1699 else if( bestsbcand >= 0 )
1702 bestisstrongbranch =
TRUE;
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,
1805 assert(!bestsbdowncutoff && !bestsbupcutoff);
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",
1813 bestsbdown, bestsbdown - lpobjval, bestsbup, bestsbup - lpobjval, bestisstrongbranch,
1823 if( allcolsinlp && !exactsolve )
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;
1967 SCIPdebugMsg(
scip,
"Could not apply relpscost branching, as the current LP was not solved to optimality.\n");
1989 if( runfiltering && branchruledata->norbits != 0 )
1998 filteredlpcands, filteredlpcandssol, filteredlpcandsfrac, filteredlpcandsorbitidx, &nfilteredlpcands) );
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;
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?",
#define BRANCHRULE_PRIORITY
#define BRANCHRULE_MAXDEPTH
#define BRANCHRULE_MAXBOUNDDIST
#define DEFAULT_PROBINGBOUNDS
#define DEFAULT_MAXPROPROUNDS
#define DEFAULT_INFERENCEWEIGHT
#define DEFAULT_CONFLICTWEIGHT
#define DEFAULT_CUTOFFWEIGHT
#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 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_RANDINITORDER
static SCIP_RETCODE initOrbits(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
#define DEFAULT_MAXLOOKAHEAD
#define DEFAULT_SBITEROFS
#define DEFAULT_NLSCOREWEIGHT
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
static SCIP_RETCODE countNonlinearities(SCIP *scip, int *nlcount, int nlcountsize, int *nlcountmax)
#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_MAXRELIABLE
#define DEFAULT_PSCOSTWEIGHT
static void freeBdchgs(SCIP *scip, int **bdchginds, SCIP_BOUNDTYPE **bdchgtypes, SCIP_Real **bdchgbounds, int *nbdchgs)
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_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
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 SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
SCIP_RETCODE SCIPsetBranchruleInitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
void SCIPbranchruleSetData(SCIP_BRANCHRULE *branchrule, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
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)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
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_Treemodel SCIP_TREEMODEL
#define SCIP_DECL_BRANCHEXECLP(x)
#define SCIP_DECL_BRANCHINITSOL(x)
#define SCIP_DECL_BRANCHCOPY(x)
#define SCIP_DECL_BRANCHFREE(x)
struct SCIP_Branchrule SCIP_BRANCHRULE
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
#define SCIP_DECL_BRANCHEXITSOL(x)
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
@ SCIP_LPSOLSTAT_ITERLIMIT
struct SCIP_HashMap SCIP_HASHMAP
struct SCIP_RandNumGen SCIP_RANDNUMGEN
@ 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
struct SCIP_Node SCIP_NODE