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_PSCOSTWEIGHT 1.0
77#define DEFAULT_NLSCOREWEIGHT 0.1
78#define DEFAULT_MINRELIABLE 1.0
79#define DEFAULT_MAXRELIABLE 5.0
80#define DEFAULT_SBITERQUOT 0.5
81#define DEFAULT_SBITEROFS 100000
82#define DEFAULT_MAXLOOKAHEAD 9
83#define DEFAULT_INITCAND 100
84#define DEFAULT_INITITER 0
85#define DEFAULT_MAXBDCHGS 5
86#define DEFAULT_MAXPROPROUNDS -2
88#define DEFAULT_PROBINGBOUNDS TRUE
90#define DEFAULT_USERELERRORFORRELIABILITY FALSE
91#define DEFAULT_LOWERRORTOL 0.05
92#define DEFAULT_HIGHERRORTOL 1.0
93#define DEFAULT_USEHYPTESTFORRELIABILITY FALSE
94#define DEFAULT_USEDYNAMICCONFIDENCE FALSE
95#define DEFAULT_STORESEMIINITCOSTS FALSE
96#define DEFAULT_USESBLOCALINFO FALSE
97#define DEFAULT_CONFIDENCELEVEL 2
98#define DEFAULT_SKIPBADINITCANDS TRUE
100#define DEFAULT_STARTRANDSEED 5
101#define DEFAULT_RANDINITORDER FALSE
102#define DEFAULT_USESMALLWEIGHTSITLIM FALSE
103#define DEFAULT_DYNAMICWEIGHTS TRUE
105#define DEFAULT_DEGENERACYAWARE 1
108#define DEFAULT_FILTERCANDSSYM FALSE
109#define DEFAULT_TRANSSYMPSCOST FALSE
112struct SCIP_BranchruleData
114 SCIP_Real conflictweight;
115 SCIP_Real conflengthweight;
116 SCIP_Real inferenceweight;
117 SCIP_Real cutoffweight;
118 SCIP_Real pscostweight;
119 SCIP_Real nlscoreweight;
120 SCIP_Real minreliable;
121 SCIP_Real maxreliable;
122 SCIP_Real sbiterquot;
130 SCIP_Bool probingbounds;
132 SCIP_Bool userelerrorforreliability;
133 SCIP_Real lowerrortol;
134 SCIP_Real higherrortol;
135 SCIP_Bool usehyptestforreliability;
136 SCIP_Bool usedynamicconfidence;
137 SCIP_Bool storesemiinitcosts;
139 SCIP_Bool usesblocalinfo;
140 SCIP_Bool skipbadinitcands;
142 SCIP_Bool dynamicweights;
149 SCIP_Bool randinitorder;
152 SCIP_Bool usesmallweightsitlim;
156 SCIP_Bool filtercandssym;
157 SCIP_Bool transsympscost;
159 SCIP_Bool nosymmetry;
181 int** permstrans =
NULL;
182 int* components =
NULL;
183 int* componentbegins =
NULL;
184 int* vartocomponent =
NULL;
190 assert( branchruledata->filtercandssym );
193 if( branchruledata->nosymmetry || branchruledata->orbits !=
NULL )
196 assert( branchruledata->orbitbegins ==
NULL );
197 assert( branchruledata->varorbitmap ==
NULL );
202 &nperms,
NULL, &permstrans,
NULL,
NULL, &components, &componentbegins, &vartocomponent, &ncomponents) );
207 branchruledata->nosymmetry =
TRUE;
212 assert( branchruledata->npermvars > 0 );
217 assert( ncomponents > 0 );
226 components, componentbegins, vartocomponent, ncomponents,
227 branchruledata->orbits, branchruledata->orbitbegins, &branchruledata->norbits, branchruledata->varorbitmap) );
228 assert( branchruledata->norbits < branchruledata->npermvars );
261 assert( ! branchruledata->nosymmetry );
262 assert( branchruledata->orbitbegins !=
NULL );
265 assert( branchruledata->varorbitmap !=
NULL );
267 assert( branchruledata->norbits < branchruledata->npermvars );
270 for(
i = 0;
i < branchruledata->norbits; ++
i )
271 branchruledata->orbitrep[
i] = -1;
284 orbitidx = branchruledata->varorbitmap[
varidx];
298 else if( branchruledata->orbitrep[orbitidx] == -1 )
302 branchruledata->orbitrep[orbitidx] =
varidx;
335 if( branchruledata->nosymmetry || ! branchruledata->transsympscost ||
branchorbitidx ==
NULL )
342 assert( branchruledata->orbitbegins !=
NULL );
356 for(
j = branchruledata->orbitbegins[orbitidx];
j < branchruledata->orbitbegins[orbitidx+1]; ++
j )
361 idx = branchruledata->orbits[
j];
364 var = branchruledata->permvars[idx];
396 if( *probindex == -1 )
484 nlcount[probindex]++;
492 nlcount[probindex]++;
500 if( *nlcountmax < nlcount[
i] )
501 *nlcountmax = nlcount[
i];
522 if( branchruledata->nlscoreweight > 0.0 )
524 if( branchruledata->nlcount ==
NULL )
527 branchruledata->nlcountsize =
nvars;
531 else if( branchruledata->nlcountsize <
nvars )
536 branchruledata->nlcountsize =
nvars;
540 assert(branchruledata->nlcountmax >= 1);
545 branchruledata->nlcountsize = 0;
546 branchruledata->nlcountmax = 1;
562 if( nlcountmax >= 1 && nlcount !=
NULL )
570 nlscore = nlcount[probindex] / (
SCIP_Real)nlcountmax;
606 if( branchruledata->dynamicweights )
620 + branchruledata->nlscoreweight * nlscore;
654 (*bdchginds)[*nbdchgs] =
ind;
655 (*bdchgtypes)[*nbdchgs] = type;
656 (*bdchgbounds)[*nbdchgs] =
bound;
699 SCIP_Bool infeasible;
717 for(
i = 0;
i < nbdchgs; ++
i )
737 assert(tightened || (branchruledata->maxproprounds != 0));
752 assert(tightened || (branchruledata->maxproprounds != 0));
792 SCIP_Real* sbdown =
NULL;
793 SCIP_Real* sbup =
NULL;
794 SCIP_Bool* sbdownvalid =
NULL;
795 SCIP_Bool* sbupvalid =
NULL;
852 SCIP_Real* scores =
NULL;
876 SCIP_Real maxlookahead;
881 SCIP_Bool probingbounds;
882 SCIP_Longint nodenum;
884 SCIP_Longint nsblpiterations;
899 if( branchruledata->degeneracyaware > 0 && (
SCIPgetDepth(
scip) > 0 || branchruledata->degeneracyaware > 1) )
901 SCIP_Real degeneracy;
902 SCIP_Real varconsratio;
907 assert(degeneracy >= 0.0);
908 assert(degeneracy <= 1.0);
909 assert(varconsratio >= 1.0);
912 if( degeneracy >= 0.8 )
914 degeneracy = 10.0 * (degeneracy - 0.7);
918 if( varconsratio >= 2.0 )
947 propagate = (branchruledata->maxproprounds != 0);
950 probingbounds =
propagate && branchruledata->probingbounds;
989 maxbdchgs = branchruledata->maxbdchgs;
990 if( maxbdchgs == -1 )
997 reliable = (1.0-
prio) * branchruledata->minreliable +
prio * branchruledata->maxreliable;
1004 if( branchruledata->usedynamicconfidence )
1009 else if(
prio >= 0.7 )
1011 else if(
prio >= 0.5 )
1013 else if(
prio >= 0.3 )
1027 if( branchruledata->usehyptestforreliability )
1063 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n",
1148 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> already performed (down=%g (%+g), up=%g (%+g), pscostscore=%g)\n",
1168 else if( branchruledata->userelerrorforreliability && branchruledata->usehyptestforreliability )
1178 else if( branchruledata->userelerrorforreliability &&
1182 else if( branchruledata->usehyptestforreliability &&
1214 if( branchruledata->randinitorder )
1229 else if( !branchruledata->usehyptestforreliability )
1253 if( branchruledata->usehyptestforreliability &&
ninitcands == 1 )
1256 SCIPdebugMsg(
scip,
"Only one single candidate for initialization-->Skipping strong branching\n");
1263 inititer = branchruledata->inititer;
1287 inititer = (int)((SCIP_Real)inititer * (1.0 + 20.0/nodenum));
1288 inititer =
MAX(inititer, 10);
1289 inititer =
MIN(inititer, 500);
1292 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",
1324 if( branchruledata->skipbadinitcands )
1419 "(node %" SCIP_LONGINT_FORMAT ") error in strong branching call for variable <%s> with solution %g\n",
1434 SCIPdebugMsg(
scip,
" -> strong branching on variable <%s> lead to a new incumbent\n",
1456 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",
1459 SCIPdebugMsg(
scip,
" -> increase lower bound of best candidate <%s> to %g\n",
1470 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",
1473 SCIPdebugMsg(
scip,
" -> decrease upper bound of best candidate <%s> to %g\n",
1500 && (!
upinf || branchruledata->storesemiinitcosts) )
1505 if( branchruledata->usesmallweightsitlim )
1517 && (!
downinf || branchruledata->storesemiinitcosts) )
1522 if( branchruledata->usesmallweightsitlim )
1548 for( v = 0; v <
nvars; ++v )
1552 SCIPdebugMsg(
scip,
"better lower bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n",
1560 SCIPdebugMsg(
scip,
"better upper bound for variable <%s>: %.9g -> %.9g (by strongbranching on <%s>)\n",
1579 SCIPdebugMsg(
scip,
" -> variable <%s> is infeasible in both directions (conflict: %u/%u)\n",
1587 SCIPdebugMsg(
scip,
" -> variable <%s> is infeasible in %s branch (conflict: %u/%u)\n",
1667 SCIPdebugMsg(
scip,
" -> variable <%s> (solval=%g, down=%g (%+g,valid=%u), up=%g (%+g,valid=%u), score=%g/ %g/%g %g/%g -> %g)\n",
1677 lookahead, maxlookahead);
1753 SCIP_Real smallpscost;
1785 branchruledata->treemodel,
1826 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",
1917 branchruledata->nlcount =
NULL;
1918 branchruledata->nlcountsize = 0;
1919 branchruledata->nlcountmax = 1;
1920 assert(branchruledata->startrandseed >= 0);
1924 (
unsigned int)branchruledata->startrandseed,
TRUE) );
1947 branchruledata->nosymmetry =
FALSE;
1948 branchruledata->norbits = 0;
1949 branchruledata->permvars =
NULL;
1950 branchruledata->permvarmap =
NULL;
1951 branchruledata->npermvars = 0;
1983 SCIPdebugMsg(
scip,
"Could not apply relpscost branching, as the current LP was not solved to optimality.\n");
2052 branchruledata->nosymmetry =
FALSE;
2053 branchruledata->orbits =
NULL;
2054 branchruledata->orbitbegins =
NULL;
2055 branchruledata->orbitrep =
NULL;
2056 branchruledata->varorbitmap =
NULL;
2057 branchruledata->norbits = 0;
2058 branchruledata->permvars =
NULL;
2059 branchruledata->npermvars = 0;
2060 branchruledata->permvarmap =
NULL;
2077 "branching/relpscost/conflictweight",
2078 "weight in score calculations for conflict score",
2081 "branching/relpscost/conflictlengthweight",
2082 "weight in score calculations for conflict length score",
2085 "branching/relpscost/inferenceweight",
2086 "weight in score calculations for inference score",
2089 "branching/relpscost/cutoffweight",
2090 "weight in score calculations for cutoff score",
2093 "branching/relpscost/pscostweight",
2094 "weight in score calculations for pseudo cost score",
2097 "branching/relpscost/nlscoreweight",
2098 "weight in score calculations for nlcount score",
2101 "branching/relpscost/minreliable",
2102 "minimal value for minimum pseudo cost size to regard pseudo cost value as reliable",
2105 "branching/relpscost/maxreliable",
2106 "maximal value for minimum pseudo cost size to regard pseudo cost value as reliable",
2109 "branching/relpscost/sbiterquot",
2110 "maximal fraction of strong branching LP iterations compared to node relaxation LP iterations",
2113 "branching/relpscost/sbiterofs",
2114 "additional number of allowed strong branching LP iterations",
2117 "branching/relpscost/maxlookahead",
2118 "maximal number of further variables evaluated without better score",
2121 "branching/relpscost/initcand",
2122 "maximal number of candidates initialized with strong branching per node",
2125 "branching/relpscost/inititer",
2126 "iteration limit for strong branching initializations of pseudo cost entries (0: auto)",
2129 "branching/relpscost/maxbdchgs",
2130 "maximal number of bound tightenings before the node is reevaluated (-1: unlimited)",
2133 "branching/relpscost/maxproprounds",
2134 "maximum number of propagation rounds to be performed during strong branching before solving the LP (-1: no limit, -2: parameter settings)",
2137 "branching/relpscost/probingbounds",
2138 "should valid bounds be identified in a probing-like fashion during strong branching (only with propagation)?",
2154 "should strong branching result be considered for pseudo costs if the other direction was infeasible?",
2161 "should the scoring function use only local cutoff and inference information obtained for strong branching candidates?",
2166 "should the strong branching decision be based on a hypothesis test?",
2171 "should the confidence level be adjusted dynamically?",
2175 "should branching rule skip candidates that have a low probability to "
2176 "be better than the best strong-branching or pseudo-candidate?",
2180 "branching/relpscost/confidencelevel",
2181 "the confidence level for statistical methods, between 0 (Min) and 4 (Max).",
2185 "should candidates be initialized in randomized order?",
2190 "should smaller weights be used for pseudo cost updates after hitting the LP iteration limit?",
2195 "should the weights of the branching rule be adjusted dynamically during solving based on objective and infeasible leaf counters?",
2199 "should degeneracy be taken into account to update weights and skip strong branching? (0: off, 1: after root, 2: always)",
2206 "Use symmetry to filter branching candidates?",
2210 "Transfer pscost information to symmetric variables?",
#define DEFAULT_DEGENERACYAWARE
#define DEFAULT_USESBLOCALINFO
#define DEFAULT_SKIPBADINITCANDS
#define DEFAULT_SBITERQUOT
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 pscostscore, SCIP_Real avgpscostscore, SCIP_Real nlscore, SCIP_Real frac, SCIP_Real degeneracyfactor)
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
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_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
#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, .
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 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