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
116 SCIP_Real conflictweight;
117 SCIP_Real conflengthweight;
118 SCIP_Real inferenceweight;
119 SCIP_Real cutoffweight;
120 SCIP_Real gmiavgeffweight;
121 SCIP_Real gmilasteffweight;
122 SCIP_Real pscostweight;
123 SCIP_Real nlscoreweight;
124 SCIP_Real minreliable;
125 SCIP_Real maxreliable;
126 SCIP_Real sbiterquot;
134 SCIP_Bool probingbounds;
136 SCIP_Bool userelerrorforreliability;
137 SCIP_Real lowerrortol;
138 SCIP_Real higherrortol;
139 SCIP_Bool usehyptestforreliability;
140 SCIP_Bool usedynamicconfidence;
141 SCIP_Bool storesemiinitcosts;
143 SCIP_Bool usesblocalinfo;
144 SCIP_Bool skipbadinitcands;
146 SCIP_Bool dynamicweights;
153 SCIP_Bool randinitorder;
156 SCIP_Bool usesmallweightsitlim;
160 SCIP_Bool filtercandssym;
161 SCIP_Bool transsympscost;
163 SCIP_Bool nosymmetry;
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 );
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;
288 orbitidx = branchruledata->varorbitmap[
varidx];
302 else if( branchruledata->orbitrep[orbitidx] == -1 )
306 branchruledata->orbitrep[orbitidx] =
varidx;
339 if( branchruledata->nosymmetry || ! branchruledata->transsympscost ||
branchorbitidx ==
NULL )
346 assert( branchruledata->orbitbegins !=
NULL );
360 for(
j = branchruledata->orbitbegins[orbitidx];
j < branchruledata->orbitbegins[orbitidx+1]; ++
j )
365 idx = branchruledata->orbits[
j];
368 var = branchruledata->permvars[idx];
400 if( *probindex == -1 )
488 nlcount[probindex]++;
496 nlcount[probindex]++;
504 if( *nlcountmax < nlcount[
i] )
505 *nlcountmax = nlcount[
i];
526 if( branchruledata->nlscoreweight > 0.0 )
528 if( branchruledata->nlcount ==
NULL )
531 branchruledata->nlcountsize =
nvars;
535 else if( branchruledata->nlcountsize <
nvars )
540 branchruledata->nlcountsize =
nvars;
544 assert(branchruledata->nlcountmax >= 1);
549 branchruledata->nlcountsize = 0;
550 branchruledata->nlcountmax = 1;
566 if( nlcountmax >= 1 && nlcount !=
NULL )
574 nlscore = nlcount[probindex] / (
SCIP_Real)nlcountmax;
612 if( branchruledata->dynamicweights )
627 + branchruledata->nlscoreweight * nlscore;
661 (*bdchginds)[*nbdchgs] =
ind;
662 (*bdchgtypes)[*nbdchgs] = type;
663 (*bdchgbounds)[*nbdchgs] =
bound;
706 SCIP_Bool infeasible;
724 for(
i = 0;
i < nbdchgs; ++
i )
744 assert(tightened || (branchruledata->maxproprounds != 0));
759 assert(tightened || (branchruledata->maxproprounds != 0));
799 SCIP_Real* sbdown =
NULL;
800 SCIP_Real* sbup =
NULL;
801 SCIP_Bool* sbdownvalid =
NULL;
802 SCIP_Bool* sbupvalid =
NULL;
859 SCIP_Real* scores =
NULL;
883 SCIP_Real maxlookahead;
888 SCIP_Bool probingbounds;
889 SCIP_Longint nodenum;
891 SCIP_Longint nsblpiterations;
906 if( branchruledata->degeneracyaware > 0 && (
SCIPgetDepth(
scip) > 0 || branchruledata->degeneracyaware > 1) )
908 SCIP_Real degeneracy;
909 SCIP_Real varconsratio;
914 assert(degeneracy >= 0.0);
915 assert(degeneracy <= 1.0);
916 assert(varconsratio >= 1.0);
919 if( degeneracy >= 0.8 )
921 degeneracy = 10.0 * (degeneracy - 0.7);
925 if( varconsratio >= 2.0 )
954 propagate = (branchruledata->maxproprounds != 0);
957 probingbounds =
propagate && branchruledata->probingbounds;
996 maxbdchgs = branchruledata->maxbdchgs;
997 if( maxbdchgs == -1 )
1004 reliable = (1.0-
prio) * branchruledata->minreliable +
prio * branchruledata->maxreliable;
1011 if( branchruledata->usedynamicconfidence )
1016 else if(
prio >= 0.7 )
1018 else if(
prio >= 0.5 )
1020 else if(
prio >= 0.3 )
1034 if( branchruledata->usehyptestforreliability )
1074 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n",
1163 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n",
1183 else if( branchruledata->userelerrorforreliability && branchruledata->usehyptestforreliability )
1193 else if( branchruledata->userelerrorforreliability &&
1197 else if( branchruledata->usehyptestforreliability &&
1231 if( branchruledata->randinitorder )
1246 else if( !branchruledata->usehyptestforreliability )
1270 if( branchruledata->usehyptestforreliability &&
ninitcands == 1 )
1273 SCIPdebugMsg(
scip,
"Only one single candidate for initialization-->Skipping strong branching\n");
1280 inititer = branchruledata->inititer;
1304 inititer = (int)((SCIP_Real)inititer * (1.0 + 20.0/nodenum));
1305 inititer =
MAX(inititer, 10);
1306 inititer =
MIN(inititer, 500);
1309 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",
1341 if( branchruledata->skipbadinitcands )
1436 "(node %" SCIP_LONGINT_FORMAT ") error in strong branching call for variable <%s> with solution %g\n",
1451 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> lead to a new incumbent\n",
1473 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",
1476 SCIPdebugMsg(
scip,
" -> increase lower bound of best candidate <%s> to %g\n",
1487 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",
1490 SCIPdebugMsg(
scip,
" -> decrease upper bound of best candidate <%s> to %g\n",
1517 && (!
upinf || branchruledata->storesemiinitcosts) )
1522 if( branchruledata->usesmallweightsitlim )
1534 && (!
downinf || branchruledata->storesemiinitcosts) )
1539 if( branchruledata->usesmallweightsitlim )
1565 for( v = 0; v <
nvars; ++v )
1569 SCIPdebugMsg(
scip,
"better lower bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n",
1577 SCIPdebugMsg(
scip,
"better upper bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n",
1596 SCIPdebugMsg(
scip,
" -> variable <%s> is infeasible in both directions (conflict: %u/%u)\n",
1604 SCIPdebugMsg(
scip,
" -> variable <%s> is infeasible in %s branch (conflict: %u/%u)\n",
1691 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",
1701 lookahead, maxlookahead);
1777 SCIP_Real smallpscost;
1809 branchruledata->treemodel,
1850 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",
1941 branchruledata->nlcount =
NULL;
1942 branchruledata->nlcountsize = 0;
1943 branchruledata->nlcountmax = 1;
1944 assert(branchruledata->startrandseed >= 0);
1948 (
unsigned int)branchruledata->startrandseed,
TRUE) );
1971 branchruledata->nosymmetry =
FALSE;
1972 branchruledata->norbits = 0;
1973 branchruledata->permvars =
NULL;
1974 branchruledata->permvarmap =
NULL;
1975 branchruledata->npermvars = 0;
2007 SCIPdebugMsg(
scip,
"Could not apply relpscost branching, as the current LP was not solved to optimality.\n");
2076 branchruledata->nosymmetry =
FALSE;
2077 branchruledata->orbits =
NULL;
2078 branchruledata->orbitbegins =
NULL;
2079 branchruledata->orbitrep =
NULL;
2080 branchruledata->varorbitmap =
NULL;
2081 branchruledata->norbits = 0;
2082 branchruledata->permvars =
NULL;
2083 branchruledata->npermvars = 0;
2084 branchruledata->permvarmap =
NULL;
2101 "branching/relpscost/conflictweight",
2102 "weight in score calculations for conflict score",
2105 "branching/relpscost/conflictlengthweight",
2106 "weight in score calculations for conflict length score",
2109 "branching/relpscost/inferenceweight",
2110 "weight in score calculations for inference score",
2113 "branching/relpscost/cutoffweight",
2114 "weight in score calculations for cutoff score",
2117 "branching/relpscost/gmiavgeffweight",
2118 "weight in score calculations for average GMI cuts normalized efficacy",
2121 "branching/relpscost/gmilasteffweight",
2122 "weight in score calculations for last GMI cuts normalized efficacy",
2125 "branching/relpscost/pscostweight",
2126 "weight in score calculations for pseudo cost score",
2129 "branching/relpscost/nlscoreweight",
2130 "weight in score calculations for nlcount score",
2133 "branching/relpscost/minreliable",
2134 "minimal value for minimum pseudo cost size to regard pseudo cost value as reliable",
2137 "branching/relpscost/maxreliable",
2138 "maximal value for minimum pseudo cost size to regard pseudo cost value as reliable",
2141 "branching/relpscost/sbiterquot",
2142 "maximal fraction of strong branching LP iterations compared to node relaxation LP iterations",
2145 "branching/relpscost/sbiterofs",
2146 "additional number of allowed strong branching LP iterations",
2149 "branching/relpscost/maxlookahead",
2150 "maximal number of further variables evaluated without better score",
2153 "branching/relpscost/initcand",
2154 "maximal number of candidates initialized with strong branching per node",
2157 "branching/relpscost/inititer",
2158 "iteration limit for strong branching initializations of pseudo cost entries (0: auto)",
2161 "branching/relpscost/maxbdchgs",
2162 "maximal number of bound tightenings before the node is reevaluated (-1: unlimited)",
2165 "branching/relpscost/maxproprounds",
2166 "maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)",
2169 "branching/relpscost/probingbounds",
2170 "should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?",
2186 "should strong branching result be considered for pseudo costs if the other direction was infeasible?",
2193 "should the scoring function use only local cutoff and inference information obtained for strong branching candidates?",
2198 "should the strong branching decision be based on a hypothesis test?",
2203 "should the confidence level be adjusted dynamically?",
2207 "should branching rule skip candidates that have a low probability to "
2208 "be better than the best strong-branching or pseudo-candidate?",
2212 "branching/relpscost/confidencelevel",
2213 "the confidence level for statistical methods, between 0 (Min) and 4 (Max).",
2217 "should candidates be initialized in randomized order?",
2222 "should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?",
2227 "should the weights of the branching rule be adjusted dynamically during solving based on objective and infeasible leaf counters?",
2231 "should degeneracy be taken into account to update weights and skip strong branching? (0: off, 1: after root, 2: always)",
2238 "Use symmetry to filter branching candidates?",
2242 "Transfer pscost information to symmetric variables?",
#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
#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_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
static SCIP_RETCODE binvarGetActiveProbindex(SCIP *scip, SCIP_VAR *var, int *probindex)
#define DEFAULT_MAXPROPROUNDS
#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)
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_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_Bool SCIPvarIsBinary(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_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
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_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_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(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 SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
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.
#define SCIP_DECL_BRANCHEXECLP(x)
#define SCIP_DECL_BRANCHINITSOL(x)
#define SCIP_DECL_BRANCHCOPY(x)
#define SCIP_DECL_BRANCHFREE(x)
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
#define SCIP_DECL_BRANCHEXITSOL(x)
@ 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