64 #define BRANCHRULE_NAME "distribution" 65 #define BRANCHRULE_DESC "branching rule based on variable influence on cumulative normal distribution of row activities" 66 #define BRANCHRULE_PRIORITY 0 67 #define BRANCHRULE_MAXDEPTH -1 68 #define BRANCHRULE_MAXBOUNDDIST 1.0 70 #define SCOREPARAM_VALUES "dhlvw" 71 #define DEFAULT_SCOREPARAM 'v' 72 #define DEFAULT_PRIORITY 2.0 73 #define SQRTOFTWO 1.4142136 74 #define SQUARED(x) ((x) * (x)) 75 #define DEFAULT_ONLYACTIVEROWS FALSE 76 #define DEFAULT_USEWEIGHTEDSCORE FALSE 79 #define EVENTHDLR_NAME "eventhdlr_distribution" 80 #define EVENT_DISTRIBUTION SCIP_EVENTTYPE_BOUNDCHANGED 87 struct SCIP_BranchruleData
95 int* rowinfinitiesdown;
109 struct SCIP_EventhdlrData
131 if( maxindex < branchruledata->memsize )
135 newsize = (int)
SCIPfeasCeil(scip, (maxindex + 1) * 1.1);
136 assert(newsize > branchruledata->memsize);
137 assert(branchruledata->memsize >= 0);
140 if( branchruledata->memsize == 0 )
165 branchruledata->varpossmemsize = nvars;
166 branchruledata->nupdatedvars = 0;
169 for( v = 0; v < nvars; ++v )
176 assert(branchruledata->varfilterposs[v] >= 0);
178 branchruledata->varposs[v] = -1;
179 branchruledata->updatedvars[v] = NULL;
194 for( r = branchruledata->memsize; r < newsize; ++r )
198 branchruledata->rowinfinitiesdown[r] = 0;
199 branchruledata->rowinfinitiesup[r] = 0;
203 branchruledata->memsize = newsize;
223 assert(0 <= varindex && varindex < branchruledata->varpossmemsize);
229 branchruledata->currentlbs[varindex] = lblocal;
230 branchruledata->currentubs[varindex] = ublocal;
244 assert(mean != NULL);
245 assert(variance != NULL);
264 *variance =
SQUARED(varub - varlb);
266 *variance =
SQUARED(varub - varlb + 1) - 1;
268 *mean = (varub + varlb) * .5;
295 std =
sqrt(variance);
305 assert( std != 0.0 );
308 normvalue = (value - mean)/(std *
SQRTOFTWO);
310 SCIPdebugMsg(scip,
" Normalized value %g = ( %g - %g ) / (%g * 1.4142136)\n", normvalue, value, mean, std);
317 else if( normvalue > 0 )
321 erfresult =
SCIPerf(normvalue);
322 return erfresult / 2.0 + 0.5;
328 erfresult =
SCIPerf(-normvalue);
330 return 0.5 - erfresult / 2.0;
349 int rowinfinitiesdown,
385 minprobability = MIN(rhsprob, lhsprob);
386 maxprobability =
MAX(lhsprob, rhsprob);
387 rowprobability = minprobability / maxprobability;
390 rowprobability = MIN(rhsprob, lhsprob);
393 SCIPdebugMsg(scip,
" Row %s, mean %g, sigma2 %g, LHS %g, RHS %g has probability %g to be satisfied\n",
398 return rowprobability;
417 int* rowinfinitiesdown,
426 assert(scip != NULL);
429 assert(sigma2 != NULL);
430 assert(rowinfinitiesup != NULL);
431 assert(rowinfinitiesdown != NULL);
437 assert(nrowvals == 0 || rowcols != NULL);
438 assert(nrowvals == 0 || rowvals != NULL);
442 *rowinfinitiesdown = 0;
443 *rowinfinitiesup = 0;
446 for( c = 0; c < nrowvals; ++c )
457 assert(rowcols[c] != NULL);
459 assert(colvar != NULL);
468 assert((branchruledata->currentlbs[varindex] ==
SCIP_INVALID) == (branchruledata->currentubs[varindex] ==
SCIP_INVALID));
471 if( branchruledata->currentlbs[varindex] ==
SCIP_INVALID )
489 ++(*rowinfinitiesdown);
491 ++(*rowinfinitiesup);
500 ++(*rowinfinitiesdown);
502 ++(*rowinfinitiesup);
508 *mu += colval * varmean;
512 *sigma2 += squarecoeff * varvariance;
534 assert(scip != NULL);
538 assert(upscore != NULL);
539 assert(downscore != NULL);
546 if(
SCIPisGT(scip, 1.0 - newprobup, *upscore) )
547 *upscore = 1.0 - newprobup;
548 if(
SCIPisGT(scip, 1.0 - newprobdown, *downscore) )
549 *downscore = 1.0 - newprobdown;
554 if(
SCIPisGT(scip, currentprob - newprobup, *upscore) )
555 *upscore = currentprob - newprobup;
556 if(
SCIPisGT(scip, currentprob - newprobdown, *downscore) )
557 *downscore = currentprob - newprobdown;
562 if(
SCIPisGT(scip, newprobup, *upscore) )
563 *upscore = newprobup;
564 if(
SCIPisGT(scip, newprobdown, *downscore) )
565 *downscore = newprobdown;
570 if(
SCIPisLT(scip, newprobup, newprobdown) )
572 else if(
SCIPisGT(scip, newprobup, newprobdown) )
578 if(
SCIPisGT(scip, newprobup, newprobdown) )
580 else if(
SCIPisLT(scip, newprobup, newprobdown) )
585 SCIPerrorMessage(
" ERROR! No branching scheme selected! Exiting method.\n");
623 assert(scip != NULL);
625 assert(upscore != NULL);
626 assert(downscore != NULL);
631 assert(varcol != NULL);
643 squaredbounddiff = 0.0;
650 squaredbounddiffup = 0.0;
655 squaredbounddiffdown = 0.0;
663 onlyactiverows = branchruledata->onlyactiverows;
666 for( i = 0; i < ncolrows; ++i )
678 int rowinfinitiesdown;
699 rowCalculateGauss(scip, branchruledata, row, &branchruledata->rowmeans[rowpos], &branchruledata->rowvariances[rowpos],
700 &branchruledata->rowinfinitiesdown[rowpos], &branchruledata->rowinfinitiesup[rowpos]);
704 rowmean = branchruledata->rowmeans[rowpos];
705 rowvariance = branchruledata->rowvariances[rowpos];
706 rowinfinitiesdown = branchruledata->rowinfinitiesdown[rowpos];
707 rowinfinitiesup = branchruledata->rowinfinitiesdown[rowpos];
711 rowinfinitiesdown, rowinfinitiesup);
714 squaredcoeff =
SQUARED(rowval);
721 int rowinftiesdownafterbranch;
722 int rowinftiesupafterbranch;
725 changedrowmean = rowmean + rowval * (meanup - currentmean);
726 changedrowvariance = rowvariance + squaredcoeff * (squaredbounddiffup - squaredbounddiff);
727 changedrowvariance =
MAX(0.0, changedrowvariance);
729 rowinftiesdownafterbranch = rowinfinitiesdown;
730 rowinftiesupafterbranch = rowinfinitiesup;
734 rowinftiesupafterbranch--;
736 rowinftiesdownafterbranch--;
738 assert(rowinftiesupafterbranch >= 0);
739 assert(rowinftiesdownafterbranch >= 0);
740 newrowprobup =
SCIProwCalcProbability(scip, row, changedrowmean, changedrowvariance, rowinftiesdownafterbranch,
741 rowinftiesupafterbranch);
744 newrowprobup = currentrowprob;
749 int rowinftiesdownafterbranch;
750 int rowinftiesupafterbranch;
752 changedrowmean = rowmean + rowval * (meandown - currentmean);
753 changedrowvariance = rowvariance + squaredcoeff * (squaredbounddiffdown - squaredbounddiff);
754 changedrowvariance =
MAX(0.0, changedrowvariance);
756 rowinftiesdownafterbranch = rowinfinitiesdown;
757 rowinftiesupafterbranch = rowinfinitiesup;
761 rowinftiesupafterbranch -= 1;
763 rowinftiesdownafterbranch -= 1;
765 assert(rowinftiesdownafterbranch >= 0);
766 assert(rowinftiesupafterbranch >= 0);
767 newrowprobdown =
SCIProwCalcProbability(scip, row, changedrowmean, changedrowvariance, rowinftiesdownafterbranch,
768 rowinftiesupafterbranch);
771 newrowprobdown = currentrowprob;
776 SCIPdebugMsg(scip,
" Variable %s changes probability of row %s from %g to %g (branch up) or %g;\n",
778 SCIPdebugMsg(scip,
" --> new variable score: %g (for branching up), %g (for branching down)\n",
779 *upscore, *downscore);
792 assert(branchruledata->memsize == 0 || branchruledata->rowmeans != NULL);
793 assert(branchruledata->memsize >= 0);
795 if( branchruledata->memsize > 0 )
802 branchruledata->memsize = 0;
824 assert(-1 <= varindex && varindex < branchruledata->varpossmemsize);
829 varpos = branchruledata->varposs[varindex];
830 assert(varpos < branchruledata->nupdatedvars);
835 assert(branchruledata->updatedvars[varpos] == var);
841 assert((branchruledata->currentlbs[varindex] ==
SCIP_INVALID) == (branchruledata->currentubs[varindex] ==
SCIP_INVALID));
842 if( branchruledata->currentlbs[varindex] ==
SCIP_INVALID )
846 assert(branchruledata->varpossmemsize > branchruledata->nupdatedvars);
847 varpos = branchruledata->nupdatedvars;
848 branchruledata->updatedvars[varpos] = var;
849 branchruledata->varposs[varindex] = varpos;
850 ++branchruledata->nupdatedvars;
864 assert(branchruledata->nupdatedvars >= 0);
867 if( branchruledata->nupdatedvars == 0 )
870 varpos = branchruledata->nupdatedvars - 1;
871 var = branchruledata->updatedvars[varpos];
874 assert(0 <= varindex && varindex < branchruledata->varpossmemsize);
875 assert(varpos == branchruledata->varposs[varindex]);
877 branchruledata->varposs[varindex] = -1;
878 branchruledata->nupdatedvars--;
914 assert(varcol != NULL);
921 oldlb = branchruledata->currentlbs[varindex];
922 oldub = branchruledata->currentubs[varindex];
946 for( r = 0; r < ncolrows; ++r )
950 assert(colrows[r] != NULL);
961 assert(branchruledata->rowvariances[rowpos] !=
SCIP_INVALID 962 &&
SCIPisFeasGE(scip, branchruledata->rowvariances[rowpos], 0.0));
968 branchruledata->rowmeans[rowpos] += coeff * (newmean - oldmean);
969 branchruledata->rowvariances[rowpos] += coeffsquared * (newvariance - oldvariance);
970 branchruledata->rowvariances[rowpos] =
MAX(0.0, branchruledata->rowvariances[rowpos]);
977 ++branchruledata->rowinfinitiesup[rowpos];
979 --branchruledata->rowinfinitiesup[rowpos];
982 ++branchruledata->rowinfinitiesdown[rowpos];
984 --branchruledata->rowinfinitiesdown[rowpos];
986 else if( coeff < 0.0 )
989 ++branchruledata->rowinfinitiesdown[rowpos];
991 --branchruledata->rowinfinitiesdown[rowpos];
994 ++branchruledata->rowinfinitiesup[rowpos];
996 --branchruledata->rowinfinitiesup[rowpos];
998 assert(branchruledata->rowinfinitiesdown[rowpos] >= 0);
999 assert(branchruledata->rowinfinitiesup[rowpos] >= 0);
1016 assert(eventhdlrdata != NULL);
1032 assert(
scip != NULL);
1045 assert(branchrule != NULL);
1049 assert(branchruledata != NULL);
1055 if( branchruledata->varfilterposs != NULL)
1065 for( v = 0; v < nvars; ++v )
1080 assert(branchrule != NULL);
1084 assert(branchruledata != NULL);
1111 assert(branchrule != NULL);
1113 assert(
scip != NULL);
1114 assert(result != NULL);
1130 if( branchruledata->memsize == 0 )
1147 while( branchruledata->nupdatedvars > 0 )
1153 assert(nextvar != NULL);
1165 for( c = 0; c < nlpcands; ++c )
1172 lpcand = lpcands[c];
1173 assert(lpcand != NULL);
1181 assert(0 <= varindex && varindex < branchruledata->varpossmemsize);
1183 assert((branchruledata->currentlbs[varindex] ==
SCIP_INVALID) == (branchruledata->currentubs[varindex] ==
SCIP_INVALID));
1184 assert((branchruledata->currentlbs[varindex] ==
SCIP_INVALID)
1186 assert((branchruledata->currentubs[varindex] ==
SCIP_INVALID)
1190 if( branchruledata->currentlbs[varindex] ==
SCIP_INVALID )
1200 &upscore, &downscore, branchruledata->scoreparam) );
1203 if( branchruledata->usescipscore )
1210 if( score > bestscore )
1215 if( upscore > downscore )
1224 if( upscore > bestscore && upscore > downscore )
1226 bestscore = upscore;
1230 else if( downscore > bestscore )
1232 bestscore = downscore;
1243 assert(bestcand != NULL);
1251 assert(downchild != NULL);
1252 assert(upchild != NULL);
1279 assert(eventhdlr != NULL);
1281 assert(eventhdlrdata != NULL);
1283 branchruledata = eventhdlrdata->branchruledata;
1307 branchruledata = NULL;
1310 branchruledata->memsize = 0;
1311 branchruledata->rowmeans = NULL;
1312 branchruledata->rowvariances = NULL;
1313 branchruledata->rowinfinitiesdown = NULL;
1314 branchruledata->rowinfinitiesup = NULL;
1315 branchruledata->varfilterposs = NULL;
1316 branchruledata->currentlbs = NULL;
1317 branchruledata->currentubs = NULL;
1320 eventhdlrdata = NULL;
1322 eventhdlrdata->branchruledata = branchruledata;
1324 branchruledata->eventhdlr = NULL;
1326 "event handler for dynamic acitivity distribution updating",
1327 eventExecDistribution, eventhdlrdata) );
1328 assert( branchruledata->eventhdlr != NULL);
1335 assert(branchrule != NULL);
1343 "the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w') ",
1347 "should only rows which are active at the current node be considered?",
1351 "should the branching score weigh up- and down-scores of a variable",
SCIP_RETCODE SCIPgetLPBranchCands(SCIP *scip, SCIP_VAR ***lpcands, SCIP_Real **lpcandssol, SCIP_Real **lpcandsfrac, int *nlpcands, int *npriolpcands, int *nfracimplvars)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
void SCIPvarCalcDistributionParameters(SCIP *scip, SCIP_Real varlb, SCIP_Real varub, SCIP_VARTYPE vartype, SCIP_Real *mean, SCIP_Real *variance)
SCIP_BRANCHRULEDATA * SCIPbranchruleGetData(SCIP_BRANCHRULE *branchrule)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
probability based branching rule based on an article by J. Pryor and J.W. Chinneck ...
SCIP_Real SCIPerf(SCIP_Real x)
static SCIP_DECL_BRANCHFREE(branchFreeDistribution)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static SCIP_RETCODE branchruledataFreeArrays(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
#define DEFAULT_USEWEIGHTEDSCORE
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
const char * SCIProwGetName(SCIP_ROW *row)
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
#define BRANCHRULE_PRIORITY
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
static SCIP_DECL_BRANCHCOPY(branchCopyDistribution)
int SCIPgetNActivePricers(SCIP *scip)
SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))
enum SCIP_Retcode SCIP_RETCODE
int SCIPvarGetProbindex(SCIP_VAR *var)
static void branchruledataAddBoundChangeVar(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR *var)
#define SCIPfreeBlockMemory(scip, ptr)
SCIP_RETCODE SCIPincludeBranchruleBasic(SCIP *scip, SCIP_BRANCHRULE **branchruleptr, const char *name, const char *desc, int priority, int maxdepth, SCIP_Real maxbounddist, SCIP_BRANCHRULEDATA *branchruledata)
static void branchruledataUpdateCurrentBounds(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR *var)
#define DEFAULT_SCOREPARAM
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))
void SCIPeventhdlrSetData(SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTHDLRDATA *eventhdlrdata)
SCIP_Real SCIPgetBranchScore(SCIP *scip, SCIP_VAR *var, SCIP_Real downgain, SCIP_Real upgain)
#define BRANCHRULE_MAXBOUNDDIST
enum SCIP_BranchDir SCIP_BRANCHDIR
#define SCOREPARAM_VALUES
#define EVENT_DISTRIBUTION
static SCIP_VAR * branchruledataPopBoundChangeVar(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_RETCODE SCIPbranchVar(SCIP *scip, SCIP_VAR *var, SCIP_NODE **downchild, SCIP_NODE **eqchild, SCIP_NODE **upchild)
SCIP_RETCODE SCIPsetEventhdlrFree(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTFREE((*eventfree)))
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
SCIP_Real SCIPcalcCumulativeDistribution(SCIP *scip, SCIP_Real mean, SCIP_Real variance, SCIP_Real value)
SCIPInterval sqrt(const SCIPInterval &x)
static SCIP_RETCODE branchruledataEnsureArraySize(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, int maxindex)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
int SCIPgetNLPRows(SCIP *scip)
static SCIP_DECL_BRANCHEXECLP(branchExeclpDistribution)
static SCIP_RETCODE calcBranchScore(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR *var, SCIP_Real lpsolval, SCIP_Real *upscore, SCIP_Real *downscore, char scoreparam)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Real SCIProwCalcProbability(SCIP *scip, SCIP_ROW *row, SCIP_Real mu, SCIP_Real sigma2, int rowinfinitiesdown, int rowinfinitiesup)
void SCIPbranchruleSetData(SCIP_BRANCHRULE *branchrule, SCIP_BRANCHRULEDATA *branchruledata)
SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
static SCIP_RETCODE varProcessBoundChanges(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_VAR *var)
static SCIP_DECL_BRANCHEXITSOL(branchExitsolDistribution)
SCIP_Bool SCIPinProbing(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
#define BRANCHRULE_MAXDEPTH
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
#define DEFAULT_ONLYACTIVEROWS
SCIP_RETCODE SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
static SCIP_DECL_EVENTFREE(eventFreeDistribution)
static void rowCalculateGauss(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_ROW *row, SCIP_Real *mu, SCIP_Real *sigma2, int *rowinfinitiesdown, int *rowinfinitiesup)
SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)
static SCIP_DECL_EVENTEXEC(eventExecDistribution)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
const char * SCIPbranchruleGetName(SCIP_BRANCHRULE *branchrule)
SCIP_RETCODE SCIPupdateDistributionScore(SCIP *scip, SCIP_Real currentprob, SCIP_Real newprobup, SCIP_Real newprobdown, SCIP_Real *upscore, SCIP_Real *downscore, char scoreparam)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
int SCIProwGetIndex(SCIP_ROW *row)
enum SCIP_Vartype SCIP_VARTYPE
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
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_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_RETCODE SCIPincludeBranchruleDistribution(SCIP *scip)