84#define BRANCHRULE_NAME "lookahead"
85#define BRANCHRULE_DESC "full strong branching over multiple levels"
86#define BRANCHRULE_PRIORITY 0
87#define BRANCHRULE_MAXDEPTH -1
88#define BRANCHRULE_MAXBOUNDDIST 1.0
90#define DEFAULT_USEBINARYCONSTRAINTS FALSE
91#define DEFAULT_ADDCLIQUE FALSE
92#define DEFAULT_ADDBINCONSROW 0
94#define DEFAULT_USEDOMAINREDUCTION TRUE
95#define DEFAULT_MERGEDOMAINREDUCTIONS FALSE
96#define DEFAULT_PREFERSIMPLEBOUNDS FALSE
97#define DEFAULT_ONLYVIOLDOMREDS FALSE
98#define DEFAULT_MAXNVIOLATEDCONS 1
100#define DEFAULT_MAXNVIOLATEDBINCONS 0
103#define DEFAULT_MAXNVIOLATEDDOMREDS 1
105#define DEFAULT_STOREUNVIOLATEDSOL TRUE
107#define DEFAULT_REEVALAGE 10LL
109#define DEFAULT_REEVALAGEFSB 10LL
111#define DEFAULT_RECURSIONDEPTH 2
112#define DEFAULT_ADDNONVIOCONS FALSE
114#define DEFAULT_PROPAGATE TRUE
116#define DEFAULT_USELEVEL2DATA TRUE
117#define DEFAULT_APPLYCHILDBOUNDS FALSE
118#define DEFAULT_ENFORCEMAXDOMREDS FALSE
119#define DEFAULT_UPDATEBRANCHINGRESULTS FALSE
120#define DEFAULT_MAXPROPROUNDS 0
122#define DEFAULT_ABBREVIATED TRUE
123#define DEFAULT_MAXNCANDS 4
124#define DEFAULT_MAXNDEEPERCANDS 2
126#define DEFAULT_REUSEBASIS TRUE
128#define DEFAULT_ABBREVPSEUDO FALSE
130#define DEFAULT_LEVEL2AVGSCORE FALSE
131#define DEFAULT_LEVEL2ZEROSCORE FALSE
132#define DEFAULT_SCORINGFUNCTION 'a'
133#define DEFAULT_DEEPERSCORINGFUNCTION 'x'
134#define DEFAULT_SCORINGSCORINGFUNCTION 'd'
135#define DEFAULT_MINWEIGHT 0.8
137#define DEFAULT_WORSEFACTOR -1.0
138#define DEFAULT_FILTERBYMAXGAIN FALSE
142#define LABdebugMessage(scip,lvl,...) do \
145 SCIPverbMessage(scip, lvl, NULL, "[%s:%-4d] ", __FILE__, __LINE__); \
146 stage = SCIPgetStage(scip); \
147 if( stage == SCIP_STAGE_INIT ) \
149 SCIPverbMessage(scip, lvl, NULL, "Init : "); \
151 else if( stage == SCIP_STAGE_FREE ) \
153 SCIPverbMessage(scip, lvl, NULL, "Free : "); \
155 else if( SCIPinProbing(scip) ) \
157 SCIPverbMessage(scip, lvl, NULL, "%*sDepth %i: ", \
158 2 * SCIPgetProbingDepth(scip), "", SCIPgetProbingDepth(scip)); \
162 SCIPverbMessage(scip, lvl, NULL, "Base : "); \
164 SCIPverbMessage(scip, lvl, NULL, __VA_ARGS__); \
169#define LABdebugMessagePrint(scip,lvl,...) do \
171 SCIPverbMessage(scip, lvl, NULL, __VA_ARGS__); \
175#define LABdebugMessage(scip,lvl,...)
205 (*warmstartinfo)->lpistate =
NULL;
206 (*warmstartinfo)->lpinorms =
NULL;
207 (*warmstartinfo)->primalfeas =
FALSE;
208 (*warmstartinfo)->dualfeas =
FALSE;
238 if( (*warmstartinfo)->lpistate !=
NULL )
243 if( (*warmstartinfo)->lpinorms !=
NULL )
275 (*candidate)->downwarmstartinfo =
NULL;
276 (*candidate)->upwarmstartinfo =
NULL;
277 (*candidate)->branchvar =
NULL;
321 (*candidate)->upwarmstartinfo !=
NULL, (*candidate)->downwarmstartinfo !=
NULL);
513 targetdecision->
updb = sourcedecision->
updb;
516 targetdecision->
score = sourcedecision->
score;
571 if( (*decision)->boundssize != 0 )
761 "level 2 result: <%s> %s %g + <%s> %s %g: lpval: %.9g, inf: %d, valid: %d\n",
767#define level2resultPrint(scip,result)
821 (*data)->level2results =
NULL;
824 (*data)->nlevel2results = 0;
825 (*data)->level2resultssize = 0;
826 (*data)->branchvar1 = 0;
827 (*data)->branchvar2 = 0;
828 (*data)->branchdir1 = 0;
829 (*data)->branchdir2 = 0;
844 while( (*data)->nlevel2results > 0 )
846 --(*data)->nlevel2results;
849 assert((*data)->nlevel2results == 0);
851 if( (*data)->level2results !=
NULL )
951 result->lpobjval = lpobjval;
1048#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
1049#define MAXRESULT SCIP_DELAYNODE
1053const char* getStatusString(
1063 return "SCIP_DIDNOTRUN";
1065 return "SCIP_DELAYED";
1067 return "SCIP_DIDNOTFIND";
1069 return "SCIP_FEASIBLE";
1071 return "SCIP_INFEASIBLE";
1073 return "SCIP_UNBOUNDED";
1075 return "SCIP_CUTOFF";
1077 return "SCIP_SEPARATED";
1079 return "SCIP_NEWROUND";
1081 return "SCIP_REDUCEDDOM";
1083 return "SCIP_CONSADDED";
1085 return "SCIP_CONSCHANGED";
1087 return "SCIP_BRANCHED";
1089 return "SCIP_SOLVELP";
1091 return "SCIP_FOUNDSOL";
1093 return "SCIP_SUSPENDED";
1095 return "SCIP_SUCCESS";
1097 return "SCIP_DELAYNODE";
1106#ifdef SCIP_STATISTIC
1113 int* nsinglecutoffs;
1120 SCIP_Longint* nlpiterationsfsb;
1123 int* noldbranchused;
1125 int* noldbranchusedfsb;
1131 int* cutoffafterfsb;
1133 int* domredafterfsb;
1135 int nsinglecandidate;
1136 int nsingleafterfilter;
1152 int ncutoffproofnodes;
1153 int ndomredproofnodes;
1163 STATISTICS* statistics
1169 assert(statistics->recursiondepth > 0);
1171 statistics->nsinglecandidate = 0;
1172 statistics->nsingleafterfilter = 0;
1173 statistics->noldcandidate = 0;
1174 statistics->nlperrorcalls = 0;
1175 statistics->nlimitcalls = 0;
1176 statistics->ntotalresults = 0;
1177 statistics->nbinconst = 0;
1178 statistics->nbinconstvio = 0;
1179 statistics->ndomredvio = 0;
1180 statistics->ndepthreached = 0;
1181 statistics->ndomred = 0;
1182 statistics->ndomredcons = 0;
1183 statistics->ncutoffproofnodes = 0;
1184 statistics->ndomredproofnodes = 0;
1185 statistics->ncliquesadded = 0;
1187 for(
i = 0;
i <= MAXRESULT;
i++)
1189 statistics->nresults[
i] = 0;
1192 for(
i = 0;
i < statistics->recursiondepth;
i++ )
1194 statistics->noldbranchused[
i] = 0;
1195 statistics->noldbranchusedfsb[
i] = 0;
1196 statistics->npropdomred[
i] = 0;
1197 statistics->nfullcutoffs[
i] = 0;
1198 statistics->nlpssolved[
i] = 0;
1199 statistics->nlpssolvedfsb[
i] = 0;
1200 statistics->nduplicatelps[
i] = 0;
1201 statistics->nlpiterations[
i] = 0;
1202 statistics->nlpiterationsfsb[
i] = 0;
1203 statistics->nsinglecutoffs[
i] = 0;
1204 statistics->stopafterfsb[
i] = 0;
1205 statistics->cutoffafterfsb[
i] = 0;
1206 statistics->domredafterfsb[
i] = 0;
1209 for(
i = 0;
i < statistics->maxnbestcands;
i++ )
1211 statistics->chosenfsbcand[
i] = 0;
1217void statisticsPrint(
1219 STATISTICS* statistics
1224 assert(statistics->recursiondepth > 0);
1227 if( statistics->ntotalresults > 0 )
1233 for(
i = 1;
i <= MAXRESULT;
i++ )
1238 statistics->nresults[
i]);
1241 for(
i = 0;
i < statistics->maxnbestcands;
i++ )
1243 if( statistics->chosenfsbcand[
i] > 0 )
1246 i+1, statistics->chosenfsbcand[
i]);
1250 for(
i = 0;
i < statistics->recursiondepth;
i++ )
1253 i, statistics->stopafterfsb[
i], statistics->cutoffafterfsb[
i], statistics->domredafterfsb[
i]);
1255 i, statistics->nfullcutoffs[
i], statistics->nsinglecutoffs[
i]);
1257 i, statistics->nlpssolved[
i], statistics->nlpssolvedfsb[
i], statistics->nduplicatelps[
i]);
1260 statistics->nlpiterationsfsb[
i]);
1262 " propagation.\n",
i, statistics->npropdomred[
i]);
1264 i, statistics->noldbranchused[
i], statistics->noldbranchusedfsb[
i]);
1268 statistics->nsinglecandidate, statistics->nsingleafterfilter);
1270 statistics->noldcandidate);
1272 statistics->nlperrorcalls);
1274 statistics->nlimitcalls);
1277 statistics->ndomredcons);
1279 statistics->nbinconst, statistics->nbinconstvio);
1281 statistics->ndomred, statistics->ndomredvio);
1283 statistics->ncliquesadded);
1285 statistics->ncutoffproofnodes);
1287 statistics->ndomredproofnodes);
1294 int ncutoffproofnodes;
1301 LOCALSTATISTICS** localstats
1309 (*localstats)->ncutoffproofnodes = 0;
1316void localStatisticsFree(
1318 LOCALSTATISTICS** localstats
1329struct SCIP_BranchruleData
1333 SCIP_Bool isinitialized;
1334#ifdef SCIP_STATISTIC
1335 STATISTICS* statistics;
1369 (*conslist)->nelements = 0;
1370 (*conslist)->memorysize = startsize;
1371 (*conslist)->nviolatedcons = 0;
1423 for(
i = 0;
i < (*conslist)->nelements;
i++ )
1464 (*list)->nbinaryvars = 0;
1465 (*list)->memorysize = startsize;
1579 assert(ncandidates >= 0);
1583 if( ncandidates > 0 )
1588 (*candidatelist)->candidates =
NULL;
1590 (*candidatelist)->ncandidates = ncandidates;
1631 (*candidatelist)->candidates[
i] = candidate;
1651 assert((*candidatelist)->ncandidates > 0 || (*candidatelist)->candidates ==
NULL);
1653 if( (*candidatelist)->candidates !=
NULL )
1655 for(
i = (*candidatelist)->ncandidates - 1;
i >= 0;
i-- )
1657 CANDIDATE* cand = (*candidatelist)->candidates[
i];
1684 assert(nindices <= candidatelist->ncandidates);
1712#ifdef SCIP_STATISTIC
1713 int* lowerboundnproofs;
1714 int* upperboundnproofs;
1741#ifdef SCIP_STATISTIC
1746 for( v = 0; v < ntotalvars; ++v )
1753 (*domreds)->nviolatedvars = 0;
1754 (*domreds)->nchangedvars = 0;
1755 (*domreds)->nsimplebounds = 0;
1770#ifdef SCIP_STATISTIC
1806 (*status)->addedbinconss =
FALSE;
1807 (*status)->depthtoosmall =
FALSE;
1808 (*status)->lperror =
FALSE;
1809 (*status)->cutoff =
FALSE;
1810 (*status)->domred =
FALSE;
1811 (*status)->domredcutoff =
FALSE;
1812 (*status)->limitreached =
FALSE;
1813 (*status)->maxnconsreached =
FALSE;
1881 (*scorecontainer)->nbestsortedcands = ncands;
1882 (*scorecontainer)->scoresum = 0.0;
1883 (*scorecontainer)->nsetscores = 0;
1888 for(
i = 0;
i < ntotalvars;
i++ )
1890 (*scorecontainer)->scores[
i] = -1.0;
1891 (*scorecontainer)->downgains[
i] = -1.0;
1892 (*scorecontainer)->upgains[
i] = -1.0;
1906 SCIP_Real scoretoinsert,
1913 int right = ncandidates - 1;
1918 assert(ncandidates >= 0);
1920 while( left <= right )
1922 int mid = left + ((right - left) / 2);
1926 if( midcand !=
NULL)
1933 midscore = scorecontainer->
scores[midindex];
1959 assert(insertpoint >= 0);
1994 if( scorecontainer->
scores[probindex] < -0.5 )
2001 scorecontainer->
scoresum += (score - scorecontainer->
scores[probindex]);
2004 scorecontainer->
scores[probindex] = score;
2005 scorecontainer->
downgains[probindex] = downgain;
2006 scorecontainer->
upgains[probindex] = upgain;
2018 if( droppedcandidate !=
NULL )
2068 SCIP_Real baselpobjval,
2069 SCIP_Longint* niterations,
2070 int* ndeepestcutoffs,
2071 SCIP_Real* bestgain,
2072 SCIP_Real* totalgains,
2075#ifdef SCIP_STATISTIC
2076 ,STATISTICS* statistics
2077 ,LOCALSTATISTICS* localstats
2078 ,SCIP_Real* firstscoreptr
2079 ,SCIP_Real* bestscoreptr
2088 SCIP_Real lowerbound,
2091 SCIP_Bool simplechange,
2093#ifdef SCIP_STATISTIC
2100 SCIP_Real basesolutionval;
2106#ifdef SCIP_STATISTIC
2107 assert(nproofnodes >= 0);
2115 if(
SCIPisLT(
scip, domainreductions->lowerbounds[varindex], lowerbound) )
2119 domainreductions->lowerbounds[varindex] = lowerbound;
2120 domainreductions->nchangedvars++;
2122 domainreductions->nsimplebounds++;
2123#ifdef SCIP_STATISTIC
2124 domainreductions->lowerboundnproofs[varindex] = nproofnodes;
2129 if(
SCIPisEQ(
scip, domainreductions->lowerbounds[varindex], lowerbound) &&
2130 (force || domainreductions->lowerboundnproofs[varindex] > nproofnodes) )
2131 domainreductions->lowerboundnproofs[varindex] = nproofnodes;
2140 if(
SCIPisFeasGT(
scip, domainreductions->lowerbounds[varindex], basesolutionval)
2141 && !domainreductions->baselpviolated[varindex] )
2143 domainreductions->baselpviolated[varindex] =
TRUE;
2144 domainreductions->nviolatedvars++;
2153 SCIP_Real upperbound,
2156 SCIP_Bool simplechange,
2158#ifdef SCIP_STATISTIC
2165 SCIP_Real basesolutionval;
2171#ifdef SCIP_STATISTIC
2172 assert(nproofnodes >= 0);
2180 if(
SCIPisLE(
scip, domainreductions->upperbounds[varindex], upperbound) )
2182#ifdef SCIP_STATISTIC
2184 if(
SCIPisEQ(
scip, domainreductions->upperbounds[varindex], upperbound) &&
2185 (force || domainreductions->upperboundnproofs[varindex] > nproofnodes) )
2186 domainreductions->upperboundnproofs[varindex] = nproofnodes;
2193 domainreductions->upperbounds[varindex] = upperbound;
2194 domainreductions->nchangedvars++;
2196 domainreductions->nsimplebounds++;
2197#ifdef SCIP_STATISTIC
2198 domainreductions->upperboundnproofs[varindex] = nproofnodes;
2207 if(
SCIPisFeasLT(
scip, domainreductions->upperbounds[varindex], basesolutionval)
2208 && !domainreductions->baselpviolated[varindex] )
2210 domainreductions->baselpviolated[varindex] =
TRUE;
2211 domainreductions->nviolatedvars++;
2223 int maxstoredomreds,
2249#ifdef SCIP_STATISTIC
2252 domreds->lowerboundnproofs[
i],
FALSE);
2260#ifdef SCIP_STATISTIC
2262 domreds->upperboundnproofs[
i],
FALSE);
2277 int maxstoredomreds,
2311 SCIP_Real newlowerbound;
2312 SCIP_Real newupperbound;
2323#ifdef SCIP_STATISTIC
2325 MIN(4, downdomreds->lowerboundnproofs[
i] + updomreds->lowerboundnproofs[
i] + 2),
FALSE);
2337#ifdef SCIP_STATISTIC
2339 MIN(4, downdomreds->upperboundnproofs[
i] + updomreds->upperboundnproofs[
i] + 2),
FALSE);
2357 SCIP_Bool* domredcutoff,
2359#ifdef SCIP_STATISTIC
2360 ,STATISTICS* statistics
2367#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2368 int nboundsadded = 0;
2369 int nboundsaddedvio = 0;
2377#ifdef SCIP_STATISTIC
2382 *domredcutoff =
FALSE;
2394 for(
i = 0;
i < nprobvars && !(*domredcutoff);
i++ )
2397 SCIP_Real proposedbound;
2398 SCIP_Real baselpval;
2402 SCIP_Bool infeasible;
2403 SCIP_Bool tightened;
2425#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2433 *domredcutoff =
TRUE;
2437 else if( tightened )
2441#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2444#ifdef SCIP_STATISTIC
2447 statistics->ndomredproofnodes += domreds->lowerboundnproofs[
i];
2450#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2476#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2484 *domredcutoff =
TRUE;
2488 else if( tightened )
2492#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2495#ifdef SCIP_STATISTIC
2498 statistics->ndomredproofnodes += domreds->upperboundnproofs[
i];
2501#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2514#ifdef SCIP_STATISTIC
2515 statistics->ndomred += nboundsadded;
2516 statistics->ndomredvio += nboundsaddedvio;
2520 "base lp.\n", nboundsadded, nboundsaddedvio);
2615 SCIP_Real currentlb;
2616 SCIP_Real currentub;
2681 SCIP_Longint* iterations
2706 SCIP_Bool downbranching,
2714 SCIP_Real oldupperbound;
2715 SCIP_Real oldlowerbound;
2719 SCIP_Real branchval;
2752 "old bounds=[<%g>..<%g>], new bounds=[<%g>..<%g>]\n",
SCIPvarGetName(branchvar), newbound, oldlowerbound,
2753 oldupperbound, oldlowerbound, newbound);
2758 "old bounds=[<%g>..<%g>], new bounds=[<%g>..<%g>]\n",
SCIPvarGetName(branchvar), newbound, oldlowerbound,
2759 oldupperbound, newbound, oldupperbound);
2763 if( (downbranching && newbound < oldlowerbound - 0.5)
2764 || (!downbranching && newbound > oldupperbound + 0.5) )
2811 SCIP_Longint ndomredsfound = 0;
2815 if( ndomredsfound > 0 )
2820 if( domreds !=
NULL )
2830 for(
i = 0;
i < nproblemvars;
i++ )
2832 SCIP_Real lowerbound;
2833 SCIP_Real upperbound;
2839#ifdef SCIP_STATISTIC
2851 if( !resultdata->
cutoff )
2878 SCIP_Bool foundsol =
FALSE;
2907 char* constraintname,
2914 SCIP_Bool removable;
2915 SCIP_Bool enforce =
FALSE;
2916 SCIP_Bool check =
FALSE;
2918 SCIP_Bool local =
TRUE;
2919 SCIP_Bool modifiable =
FALSE;
2920 SCIP_Bool dynamic =
FALSE;
2921 SCIP_Bool stickingatnode =
FALSE;
2938 check,
propagate, local, modifiable, dynamic, removable, stickingatnode) );
2949 char* constraintname
2961 for(
i = 1;
i < nbinaryvars;
i++ )
2967 oldlen = strlen(constraintname);
2984#ifdef SCIP_STATISTIC
2985 ,STATISTICS* statistics
3001 SCIP_Real lhssum = 0.0;
3019 violated = (lhssum < 1);
3036#ifdef SCIP_STATISTIC
3040 statistics->ndomredcons++;
3054 SCIP_Bool* consadded,
3056 SCIP_Bool* boundchange
3058#ifdef SCIP_STATISTIC
3059 ,STATISTICS* statistics
3065#ifdef SCIP_STATISTIC
3066 int nvioconsadded = 0;
3087#ifdef SCIP_STATISTIC
3088 SCIP_Bool violated = conslist->
violated[
i];
3093 for( v = 0; v <
nvars; ++v )
3123#ifdef SCIP_STATISTIC
3136 SCIP_Bool infeasible;
3146#ifdef SCIP_STATISTIC
3147 statistics->ncliquesadded++;
3154 *boundchange =
TRUE;
3163 if( nconsadded > 0 )
3167#ifdef SCIP_STATISTIC
3168 statistics->nbinconst += nconsadded;
3169 statistics->nbinconstvio += nvioconsadded;
3181 SCIP_Real lowerbound,
3182 SCIP_Real upperbound
3200 SCIP_Bool checkdomreds
3217 SCIP_Bool branchfurther;
3224 if( !branchfurther )
3227 return branchfurther;
3265 SCIP_Real* oldlpobjval
3296 downgain =
MAX(downbranchingresult->
dualbound - *oldlpobjval, 0);
3297 upgain =
MAX(upbranchingresult->
dualbound - *oldlpobjval, 0);
3316 SCIP_Real branchval,
3365#ifdef SCIP_STATISTIC
3366 ,STATISTICS* statistics
3367 ,LOCALSTATISTICS* localstats
3382#ifdef SCIP_STATISTIC
3384 binconsdata, candidatelist, decision, scorecontainer, level2data, 1,
3386 statistics, localstats,
NULL,
NULL) );
3389 binconsdata, candidatelist, decision, scorecontainer, level2data, 1,
3402void printCandidates(
3416 LABdebugMessagePrint(
scip, lvl,
"[");
3418 for(
i = 0;
i < ncands;
i++ )
3428 LABdebugMessagePrint(
scip, lvl,
", ");
3431 LABdebugMessagePrint(
scip, lvl,
"]\n");
3457 if( !downbranchingresult->
cutoff )
3458 downgain =
MAX(downgain, downbranchingresult->
dualbound - lpobjval);
3459 if( !upbranchingresult->
cutoff )
3460 upgain =
MAX(upgain, upbranchingresult->
dualbound - lpobjval);
3462 downgain = 100.0 * downgain;
3463 upgain = 100.0 * upgain;
3469 if( downbranchingresult->
cutoff )
3470 downgain = 2 * upgain;
3471 if( upbranchingresult->
cutoff )
3472 upgain = 2 * downgain;
3503 if( !downbranchingresult->
cutoff )
3504 downgain =
MAX(downgain, downbranchingresult->
objval - lpobjval);
3505 if( !upbranchingresult->
cutoff )
3506 upgain =
MAX(upgain, upbranchingresult->
objval - lpobjval);
3508 downgain = 100.0 * downgain;
3509 upgain = 100.0 * upgain;
3515 if( downbranchingresult->
cutoff )
3516 downgain = 2 * upgain;
3517 if( upbranchingresult->
cutoff )
3518 upgain = 2 * downgain;
3525 if( !downbranchingresult->
cutoff )
3527 if( !upbranchingresult->
cutoff )
3530 downgain = 100.0 * downgain;
3531 upgain = 100.0 * upgain;
3537 if( downbranchingresult->
cutoff )
3538 downgain = 2 * upgain;
3539 if( upbranchingresult->
cutoff )
3540 upgain = 2 * downgain;
3559 SCIP_Real downscore;
3570 downscore = sqrt(downbranchingresult->
deeperscore);
3576 if( downbranchingresult->
cutoff )
3577 downscore = 2 * upscore;
3578 if( upbranchingresult->
cutoff )
3579 upscore = 2 * downscore;
3596 SCIP_Real downscore;
3598 SCIP_Real totaldowngains;
3599 SCIP_Real totalupgains;
3600 SCIP_Real nlowestlevelcutoffs;
3601 int ntotaldowngains;
3613 totaldowngains = downbranchingresult->
totalgains;
3614 totalupgains = upbranchingresult->
totalgains;
3618 downscore = sqrt(downbranchingresult->
deeperscore);
3624 if( downbranchingresult->
cutoff )
3625 downscore = 2 * upscore;
3626 if( upbranchingresult->
cutoff )
3627 upscore = 2 * downscore;
3631 downscore = sqrt(totaldowngains/ntotaldowngains);
3632 upscore = sqrt(totalupgains/ntotalupgains);
3652 SCIP_Real downgain = 0.0;
3653 SCIP_Real upgain = 0.0;
3662 if( !downbranchingresult->
cutoff )
3663 downgain =
MAX(0, downbranchingresult->
dualbound - lpobjval);
3664 if( !upbranchingresult->
cutoff )
3665 upgain =
MAX(0, upbranchingresult->
dualbound - lpobjval);
3669 if( downbranchingresult->
cutoff )
3671 if( upbranchingresult->
cutoff )
3680 if( downbranchingresult->
cutoff )
3682 if( upbranchingresult->
cutoff )
3699 SCIP_Real bestdowngain;
3700 SCIP_Real bestupgain;
3701 SCIP_Real totaldowngains;
3702 SCIP_Real totalupgains;
3703 int nlowestlevelcutoffs;
3704 int ntotaldowngains;
3711 bestdowngain = downbranchingresult->
bestgain;
3712 bestupgain = upbranchingresult->
bestgain;
3713 totaldowngains = downbranchingresult->
totalgains;
3714 totalupgains = upbranchingresult->
totalgains;
3718 return bestdowngain + bestupgain + (totaldowngains/ntotaldowngains + totalupgains/ntotalupgains)*nlowestlevelcutoffs;
3732 SCIP_Real bestdowngain;
3733 SCIP_Real bestupgain;
3734 SCIP_Real totaldowngains;
3735 SCIP_Real totalupgains;
3736 SCIP_Real nlowestlevelcutoffs;
3737 int ntotaldowngains;
3744 bestdowngain = downbranchingresult->
bestgain;
3745 bestupgain = upbranchingresult->
bestgain;
3746 totaldowngains = downbranchingresult->
totalgains;
3747 totalupgains = upbranchingresult->
totalgains;
3751 return config->
minweight*
MIN(bestdowngain, bestupgain) + (1.0 - config->
minweight)*
MAX(bestdowngain, bestupgain) + (totaldowngains/ntotaldowngains + totalupgains/ntotalupgains)*nlowestlevelcutoffs;
3767 int nlowestlevelcutoffs;
3772 nlowestlevelcutoffs = 0;
3777 if( !downbranchingresult->
cutoff )
3780 downgain =
MAX(downgain, downbranchingresult->
dualbound - lpobjval);
3782 if( !upbranchingresult->
cutoff )
3785 upgain =
MAX(upgain, upbranchingresult->
dualbound - lpobjval);
3792 if( downbranchingresult->
cutoff )
3795 downgain = 2 * upgain;
3797 if( upbranchingresult->
cutoff )
3800 upgain = 2 * downgain;
3805 downgain = downgain/gap;
3806 upgain = upgain/gap;
3827 SCIP_Real nlowestlevelcutoffs;
3839 factor = factor * factor;
3844 if( !downbranchingresult->
cutoff )
3846 downgain =
MAX(downgain, downbranchingresult->
dualbound - lpobjval);
3848 if( !upbranchingresult->
cutoff )
3850 upgain =
MAX(upgain, upbranchingresult->
dualbound - lpobjval);
3857 if( downbranchingresult->
cutoff )
3859 downgain = 2 * upgain;
3861 if( upbranchingresult->
cutoff )
3863 upgain = 2 * downgain;
3868 downgain = downgain/gap;
3869 upgain = upgain/gap;
3885 SCIP_Real baselpobjval
3889 char scoringfunction;
3904 switch( scoringfunction )
3934 assert(scoringfunction ==
'd');
3948 SCIP_Real downpseudocost;
3949 SCIP_Real uppseudocost;
3966void printCandidateList(
4005 assert(nbestcandidates <= candidatelist->ncandidates);
4011 SCIP_Real movescore;
4017 movescore = scorecontainer->
scores[moveprobindex];
4020 nsorted =
MIN(
i, nbestcandidates);
4024 assert(insertionindex <= nsorted);
4029 if( insertionindex !=
i && insertionindex < nsorted )
4035 for( j = insertionindex; j < nsorted; j++ )
4041 reordercand = oldcand;
4050 "\n", candidatelist->
ncandidates, nbestcandidates);
4051 printCandidateList(
scip, candidatelist, scorecontainer);
4065 SCIP_Real reliable = 5;
4072 size =
MIN(downsize, upsize);
4074 return size >= reliable;
4103#ifdef SCIP_STATISTIC
4104 ,STATISTICS* statistics
4105 ,LOCALSTATISTICS* localstats
4110 int nunscoredcandidates = 0;
4111 int* candidateunscored;
4130 SCIP_Real knownscore = scorecontainer->
scores[probindex];
4157 candidateunscored[nunscoredcandidates] =
i;
4158 nunscoredcandidates++;
4163 if( nunscoredcandidates > 0 )
4171 for(
i = 0;
i < nunscoredcandidates;
i++ )
4173 int candindex = candidateunscored[
i];
4189#ifdef SCIP_STATISTIC
4191 decision, scorecontainer, level2data, lpobjval, statistics, localstats) );
4194 decision, scorecontainer, level2data, lpobjval) );
4198 for(
i = 0;
i < nunscoredcandidates;
i++ )
4235#ifdef SCIP_STATISTIC
4236 ,STATISTICS* statistics
4237 ,LOCALSTATISTICS* localstats
4259#ifdef SCIP_STATISTIC
4261 decision, scorecontainer, level2data, lpobjval, statistics, localstats) );
4264 decision, scorecontainer, level2data, lpobjval) );
4287 for(
i = 1;
i < nusedcands; ++
i )
4302 if( bestmaxgain == 0.0 )
4306 for(
i = nusedcands - 1;
i >= 1; --
i )
4315 if(
i < nusedcands )
4328 for(
i = 1;
i < nusedcands; ++
i )
4364 SCIP_Real localbaselpsolval,
4365 SCIP_Real baselpobjval,
4372 SCIP_Bool downbranching
4373#ifdef SCIP_STATISTIC
4374 ,STATISTICS* statistics
4375 ,LOCALSTATISTICS* localstats
4381 SCIP_Real branchvalfrac;
4382 SCIP_Real branchval;
4383 SCIP_Bool varisbinary;
4384 SCIP_Bool solvedlp =
TRUE;
4393 branchvalfrac = candidate->
fracval;
4401 if( binconsdata !=
NULL && varisbinary )
4431 if( level2data !=
NULL )
4459#ifdef SCIP_STATISTIC
4460 statistics->nduplicatelps[probingdepth]++;
4473 "Use old %s branching result on var <%s> with 'val > %g' and bounds [<%g>..<%g>]: objval <%.9g>, cutoff <%d> "
4474 "(the parent objval was <%.9g>)\n",
4490 SCIP_Bool duplicate;
4496#ifdef SCIP_STATISTIC
4497 statistics->nlpssolved[probingdepth]++;
4498 statistics->nlpiterations[probingdepth] += branchingresult->
niterations;
4502 statistics->nlpssolvedfsb[probingdepth]++;
4503 statistics->nlpiterationsfsb[probingdepth] += branchingresult->
niterations;
4514 else if( branchingresult->
cutoff )
4521 "<%.9g>)\n", branchingresult->
objval, localbaselpsolval);
4528 SCIP_Real localgain;
4530 localgain =
MAX(0, branchingresult->
objval - localbaselpsolval);
4554 if( recursiondepth > 1 && !config->
inscoring )
4569 SCIP_Real deeperlpobjval = branchingresult->
objval;
4570#ifdef SCIP_STATISTIC
4571 LOCALSTATISTICS* deeperlocalstats;
4573 SCIP_CALL( localStatisticsAllocate(
scip, &deeperlocalstats) );
4579#ifdef SCIP_STATISTIC
4581 deeperdecision, scorecontainer, level2data, deeperlpobjval,
4582 statistics, localstats) );
4585 deeperdecision, scorecontainer, level2data, deeperlpobjval) );
4592 if( deeperstatus->
cutoff )
4603#ifdef SCIP_STATISTIC
4604 deeperlocalstats->ncutoffproofnodes = 0;
4606 binconsdata, candidatelist, deeperdecision, scorecontainer, level2data, recursiondepth - 1,
4610 statistics, deeperlocalstats,
NULL,
NULL) );
4613 binconsdata, candidatelist, deeperdecision, scorecontainer, level2data, recursiondepth - 1,
4631#ifdef SCIP_STATISTIC
4636 statistics->stopafterfsb[probingdepth+1]++;
4638 if( deeperstatus->
cutoff )
4640 statistics->cutoffafterfsb[probingdepth+1]++;
4642 else if( deeperstatus->
domred )
4644 statistics->domredafterfsb[probingdepth+1]++;
4649 if( deeperstatus->
cutoff )
4652#ifdef SCIP_STATISTIC
4653 localstats->ncutoffproofnodes += deeperlocalstats->ncutoffproofnodes;
4656 "cutoff\n", downbranching ?
"down" :
"up");
4661#ifdef SCIP_STATISTIC
4662 localStatisticsFree(
scip, &deeperlocalstats);
4673 if( recursiondepth == 1 && !config->
inscoring )
4677 if( branchingresult->
cutoff )
4683 if( binconsdata !=
NULL && varisbinary )
4689#ifdef SCIP_STATISTIC
4721 SCIP_Real baselpobjval,
4722 SCIP_Longint* niterations,
4723 int* ndeepestcutoffs,
4724 SCIP_Real* bestgain,
4725 SCIP_Real* totalgains,
4730#ifdef SCIP_STATISTIC
4731 ,STATISTICS* statistics
4732 ,LOCALSTATISTICS* localstats
4733 ,SCIP_Real* firstscoreptr
4734 ,SCIP_Real* bestscoreptr
4744 SCIP_Real bestscorelowerbound;
4745 SCIP_Real bestscoreupperbound;
4752 SCIP_Bool stopafterinfeasible =
FALSE;
4761 assert(recursiondepth >= 1);
4762#ifdef SCIP_STATISTIC
4765 if( firstscoreptr !=
NULL )
4766 *firstscoreptr = -1.0;
4767 if( bestscoreptr !=
NULL )
4768 *bestscoreptr = -1.0;
4773 assert(probingdepth >= 0 && probingdepth < config->recursiondepth);
4781 decision->
downdb = lpobjval;
4783 decision->
updb = lpobjval;
4786 decision->
score = 0.0;
4803 stopafterinfeasible = !stopafterinfeasible;
4827 for(
i = 0,
c = start;
4832 SCIP_Bool useoldbranching =
FALSE;
4836 SCIP_Real branchval;
4860#ifdef SCIP_STATISTIC
4861 statistics->npropdomred[probingdepth]++;
4870#ifdef SCIP_STATISTIC
4874 localstats->ncutoffproofnodes = 0;
4885 useoldbranching =
TRUE;
4886#ifdef SCIP_STATISTIC
4888 statistics->noldbranchusedfsb[probingdepth]++;
4890 statistics->noldbranchused[probingdepth]++;
4911 for( k = 0; k < 2; ++k )
4917 localdomainreductions = down ? downdomainreductions : updomainreductions;
4918 localbranchingresult = down ? downbranchingresult : upbranchingresult;
4919 otherbranchingresult = down ? upbranchingresult : downbranchingresult;
4921#ifdef SCIP_STATISTIC
4923 recursiondepth, localdomainreductions, binconsdata, level2data, localbranchingresult, scorecontainer,
4924 down, statistics, localstats) );
4928 recursiondepth, localdomainreductions, binconsdata, level2data, localbranchingresult, scorecontainer,
4939 "The %s branching changed the cutoffbound and rendered the %s branching result infeasible.\n",
4940 down ?
"down" :
"up", down ?
"up" :
"down");
4943 if( stopafterinfeasible && k == 0 && localbranchingresult->
cutoff )
4951 "(gain=%.9g, valid=%u, inf=%u)\n", downbranchingresult->
dualbound,
4956 if( niterations !=
NULL )
4960 if( persistent !=
NULL && !upbranchingresult->
cutoff && !downbranchingresult->
cutoff && (config->
inscoring || probingdepth == 0) )
4963 upbranchingresult, lpobjval) );
4967 if( ndeepestcutoffs !=
NULL )
4970 if( ndeepestnodes !=
NULL )
4975 SCIP_Real scoringlpobjval = useoldbranching ? oldlpobjval : lpobjval;
4976 SCIP_Real score =
calculateScore(
scip, config, branchvar, downbranchingresult, upbranchingresult,
4977 scoringlpobjval, baselpobjval);
4979#ifdef SCIP_STATISTIC
4980 if(
i == 0 && firstscoreptr !=
NULL )
4981 *firstscoreptr = score;
4989 *bestgain =
MAX(*bestgain, score);
4991 if( !downbranchingresult->
cutoff && !upbranchingresult->
cutoff )
4993 (*totalgains) += score;
5006#ifdef SCIP_STATISTIC
5007 statistics->nfullcutoffs[probingdepth]++;
5008 localstats->ncutoffproofnodes += 2;
5022#ifdef SCIP_STATISTIC
5023 assert(localstats->ncutoffproofnodes == 0 || localstats->ncutoffproofnodes == 2);
5025 2 + localstats->ncutoffproofnodes,
TRUE);
5037#ifdef SCIP_STATISTIC
5038 statistics->nsinglecutoffs[probingdepth]++;
5052#ifdef SCIP_STATISTIC
5053 assert(localstats->ncutoffproofnodes == 0 || localstats->ncutoffproofnodes == 2);
5055 2 + localstats->ncutoffproofnodes,
TRUE);
5067#ifdef SCIP_STATISTIC
5068 statistics->nsinglecutoffs[probingdepth]++;
5087 int maxstoredomreds = INT_MAX;
5096 updomainreductions);
5097 else if( upbranchingresult->
cutoff && !downbranchingresult->
cutoff )
5099 else if( downbranchingresult->
cutoff && !upbranchingresult->
cutoff )
5113 bestscoringlpobjval, baselpobjval);
5115 if( newscore > bestscore )
5117 bestscore = newscore;
5119#ifdef SCIP_STATISTIC
5120 if( bestscoreptr !=
NULL )
5121 *bestscoreptr = newscore;
5123 decision->
score = newscore;
5139#ifdef SCIP_STATISTIC
5140 if( bestscoreptr !=
NULL )
5141 *bestscoreptr = score;
5149 decision->
score = score;
5172 bestscorelowerbound = branchlb;
5173 bestscoreupperbound = branchub;
5174 bestscoringlpobjval = scoringlpobjval;
5184 MAX(downbranchingresult->
objval - scoringlpobjval, 0),
MAX(downbranchingresult->
dualbound - scoringlpobjval, 0),
5185 MAX(upbranchingresult->
objval - scoringlpobjval, 0),
MAX(upbranchingresult->
dualbound - scoringlpobjval, 0),
5197 downbranchingresult->
dualbound - scoringlpobjval, upbranchingresult->
dualbound - scoringlpobjval) );
5200 if( probingdepth == 0 && (binconsdata !=
NULL || domainreductions !=
NULL) && !useoldbranching
5206 if( binconsdata !=
NULL )
5221 if( domainreductions !=
NULL )
5254#ifdef SCIP_STATISTIC
5255 statistics->npropdomred[probingdepth]++;
5262 if( updomainreductions !=
NULL )
5324#ifdef SCIP_STATISTIC
5325 ,STATISTICS* statistics
5326 ,LOCALSTATISTICS* localstats
5336#ifdef SCIP_STATISTIC
5337 SCIP_Real firstscore = -1.0;
5338 SCIP_Real bestscore = -1.0;
5339 int chosencandnr = -1;
5340 SCIP_Bool performedlab =
FALSE;
5348#ifdef SCIP_STATISTIC
5355 assert(recursiondepth > 0);
5363#ifdef SCIP_STATISTIC
5364 statistics->ndepthreached++;
5375 decision->
downdb = lpobjval;
5377 decision->
updb = lpobjval;
5384#ifdef SCIP_STATISTIC
5385 statistics->nsinglecandidate++;
5417#ifdef SCIP_STATISTIC
5419 decision, scorecontainer, level2data, lpobjval,
5420 statistics, localstats) );
5423 decision, scorecontainer, level2data, lpobjval) );
5430 decision->
downdb = lpobjval;
5432 decision->
updb = lpobjval;
5439#ifdef SCIP_STATISTIC
5440 statistics->nsingleafterfilter++;
5459#ifdef SCIP_STATISTIC
5461 decision, scorecontainer, level2data, recursiondepth, lpobjval, lpobjval,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
5462 statistics, localstats, &firstscore, &bestscore) );
5465 decision, scorecontainer, level2data, recursiondepth, lpobjval, lpobjval,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL) );
5468 if( level2data !=
NULL )
5487#ifdef SCIP_STATISTIC
5496 for( chosencandnr = 0; chosencandnr < candidatelist->
ncandidates; ++chosencandnr )
5503 assert(chosencandnr < candidatelist->ncandidates);
5509 int probingdepth = 0;
5512 statistics->stopafterfsb[probingdepth]++;
5516 statistics->cutoffafterfsb[probingdepth]++;
5520 statistics->domredafterfsb[probingdepth]++;
5532 if( domainreductions !=
NULL )
5539#ifdef SCIP_STATISTIC
5541 &status->
domred, statistics) );
5551 if( binconsdata !=
NULL )
5561#ifdef SCIP_STATISTIC
5577#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
5584#ifdef SCIP_STATISTIC
5586 statistics->nsingleafterfilter--;
5593#ifdef SCIP_STATISTIC
5595 statistics->nsingleafterfilter--;
5598 else if( status->
cutoff )
5609#ifdef SCIP_STATISTIC
5610 if( chosencandnr >= 0 )
5612 ++statistics->chosenfsbcand[chosencandnr];
5618 bestscore, firstscore);
5636 if( baselpsol !=
NULL )
5661 persistent = branchruledata->persistent;
5665 "nodes=%lld (old=%lld), iterations=%lld (old=%lld), lps=%lld (old=%lld)\n",
5698 assert(branchruledata->persistent->olddecision !=
NULL);
5707 SCIPvarGetName(branchruledata->persistent->olddecision->branchvar));
5710 branchruledata->persistent->olddecision->branchvar =
NULL;
5729 persistent = branchruledata->persistent;
5757 branchruledata->isinitialized =
FALSE;
5776 if( branchruledata->isinitialized &&
5780 if( branchruledata->isinitialized )
5797 branchruledata->persistent->nvars =
nvars;
5798 branchruledata->persistent->oldntotalnodes = -1;
5799 branchruledata->persistent->oldnnodelpiterations = -1;
5800 branchruledata->persistent->oldnnodelps = -1;
5807 branchruledata->persistent->lastbranchid[
i] = -1;
5808 branchruledata->persistent->lastbranchnlps[
i] = 0;
5814 branchruledata->isinitialized =
TRUE;
5870 branchruledata->persistent->restartindex = 0;
5872#ifdef SCIP_STATISTIC
5879 recursiondepth = branchruledata->config->recursiondepth;
5880 maxncands = branchruledata->config->maxncands;
5901 branchruledata->statistics->recursiondepth = recursiondepth;
5902 branchruledata->statistics->maxnbestcands = maxncands;
5904 statisticsInit(branchruledata->statistics);
5918#ifdef SCIP_STATISTIC
5920 STATISTICS* statistics;
5925 statistics = branchruledata->statistics;
5928 statisticsPrint(
scip, statistics);
5960 if( branchruledata->isinitialized )
5974 SCIP_Bool userusebincons;
5986 config = branchruledata->config;
6001#ifdef SCIP_STATISTIC
6002 branchruledata->statistics->noldcandidate++;
6011#ifdef SCIP_STATISTIC
6012 LOCALSTATISTICS* localstats;
6032#ifdef SCIP_STATISTIC
6036 scorecontainer, candidatelist, branchruledata->statistics, localstats) );
6039 scorecontainer, candidatelist) );
6045#ifdef SCIP_STATISTIC
6046 branchruledata->statistics->ncutoffproofnodes += localstats->ncutoffproofnodes;
6055 else if( status->
domred )
6061#ifdef SCIP_STATISTIC
6062 ++branchruledata->statistics->nlperrorcalls;
6080#ifdef SCIP_STATISTIC
6083 ++branchruledata->statistics->nlimitcalls;
6128 "problem is infeasible.\n");
6137 "lookahead branching.\n");
6145#ifdef SCIP_STATISTIC
6146 localStatisticsFree(
scip, &localstats);
6151 if( scorecontainer !=
NULL )
6159#ifdef SCIP_STATISTIC
6162 branchruledata->statistics->ntotalresults++;
6163 branchruledata->statistics->nresults[*
result]++;
6170 sum = branchruledata->statistics->nsinglecandidate + branchruledata->statistics->nsingleafterfilter
6171 + branchruledata->statistics->noldcandidate + branchruledata->statistics->nlperrorcalls
6172 + branchruledata->statistics->nlimitcalls;
6174 for(
i = 0;
i < branchruledata->statistics->maxnbestcands;
i++ )
6176 sum += branchruledata->statistics->chosenfsbcand[
i];
6178 if( sum != branchruledata->statistics->nresults[
SCIP_BRANCHED] )
6180 printf(
"branched = %d != sum = %d (%d/%d/%d/%d/%d)\n",
6182 branchruledata->statistics->nsinglecandidate, branchruledata->statistics->nsingleafterfilter,
6183 branchruledata->statistics->noldcandidate,
6184 branchruledata->statistics->nlperrorcalls, branchruledata->statistics->nlimitcalls);
6191 branchruledata->statistics->ncutoffproofnodes, branchruledata->statistics->ndomredproofnodes);
6216 branchruledata->persistent->restartindex = 0;
6217 branchruledata->isinitialized =
FALSE;
6218 branchruledata->config->inscoring =
FALSE;
6236 "branching/lookahead/useimpliedbincons",
6237 "should binary constraints be collected and applied?",
6240 "branching/lookahead/addbinconsrow",
6241 "should binary constraints be added as rows to the base LP? (0: no, 1: separate, 2: as initial rows)",
6244 "how many constraints that are violated by the base lp solution should be gathered until the rule is stopped and "\
6245 "they are added? [0 for unrestricted]",
6248 "how many binary constraints that are violated by the base lp solution should be gathered until the rule is "\
6249 "stopped and they are added? [0 for unrestricted]",
6252 "how many domain reductions that are violated by the base lp solution should be gathered until the rule is "\
6253 "stopped and they are added? [0 for unrestricted]",
6256 "branching/lookahead/reevalage",
6257 "max number of LPs solved after which a previous prob branching results are recalculated",
6260 "branching/lookahead/reevalagefsb",
6261 "max number of LPs solved after which a previous FSB scoring results are recalculated",
6264 "the max depth of LAB.",
6267 "branching/lookahead/usedomainreduction",
6268 "should domain reductions be collected and applied?",
6271 "branching/lookahead/mergedomainreductions",
6272 "should domain reductions of feasible siblings should be merged?",
6275 "branching/lookahead/prefersimplebounds",
6276 "should domain reductions only be applied if there are simple bound changes?",
6279 "branching/lookahead/onlyvioldomreds",
6280 "should only domain reductions that violate the LP solution be applied?",
6283 "branching/lookahead/addnonviocons",
6284 "should binary constraints, that are not violated by the base LP, be collected and added?",
6287 "branching/lookahead/abbreviated",
6288 "toggles the abbreviated LAB.",
6291 "if abbreviated: The max number of candidates to consider at the node.",
6294 "if abbreviated: The max number of candidates to consider per deeper node.",
6297 "branching/lookahead/reusebasis",
6298 "if abbreviated: Should the information gathered to obtain the best candidates be reused?",
6301 "branching/lookahead/storeunviolatedsol",
6302 "if only non violating constraints are added, should the branching decision be stored till the next call?",
6305 "branching/lookahead/abbrevpseudo",
6306 "if abbreviated: Use pseudo costs to estimate the score of a candidate.",
6309 "branching/lookahead/level2avgscore",
6310 "should the average score be used for uninitialized scores in level 2?",
6313 "branching/lookahead/level2zeroscore",
6314 "should uninitialized scores in level 2 be set to 0?",
6317 "branching/lookahead/addclique",
6318 "add binary constraints with two variables found at the root node also as a clique",
6321 "branching/lookahead/propagate",
6322 "should domain propagation be executed before each temporary node is solved?",
6325 "branching/lookahead/uselevel2data",
6326 "should branching data generated at depth level 2 be stored for re-using it?",
6329 "branching/lookahead/applychildbounds",
6330 "should bounds known for child nodes be applied?",
6333 "branching/lookahead/enforcemaxdomreds",
6334 "should the maximum number of domain reductions maxnviolateddomreds be enforced?",
6337 "branching/lookahead/updatebranchingresults",
6338 "should branching results (and scores) be updated w.r.t. proven dual bounds?",
6341 "branching/lookahead/maxproprounds",
6342 "maximum number of propagation rounds to perform at each temporary node (-1: unlimited, 0: SCIP default)",
6345 "branching/lookahead/scoringfunction",
6346 "scoring function to be used at the base level",
6349 "branching/lookahead/deeperscoringfunction",
6350 "scoring function to be used at deeper levels",
6353 "branching/lookahead/scoringscoringfunction",
6354 "scoring function to be used during FSB scoring",
6357 "branching/lookahead/minweight",
6358 "if scoringfunction is 's', this value is used to weight the min of the gains of two child problems in the convex combination",
6361 "branching/lookahead/worsefactor",
6362 "if the FSB score is of a candidate is worse than the best by this factor, skip this candidate (-1: disable)",
6365 "branching/lookahead/filterbymaxgain",
6366 "should lookahead branching only be applied if the max gain in level 1 is not uniquely that of the best candidate?",
static SCIP_RETCODE selectVarStart(SCIP *scip, CONFIGURATION *config, PERSISTENTDATA *persistent, STATUS *status, BRANCHINGDECISION *decision, SCORECONTAINER *scorecontainer, CANDIDATELIST *candidatelist)
static SCIP_Bool isCandidateReliable(SCIP *scip, SCIP_VAR *branchvar)
static SCIP_Bool warmStartInfoIsAvailable(WARMSTARTINFO *warmstartinfo)
static void domainReductionsFree(SCIP *scip, DOMAINREDUCTIONS **domreds)
#define DEFAULT_USEBINARYCONSTRAINTS
static SCIP_RETCODE branchingDecisionEnsureBoundArraysSize(SCIP *scip, BRANCHINGDECISION *decision, int nvars)
static void binConsDataFree(SCIP *scip, BINCONSDATA **consdata)
static void level2resultFree(SCIP *scip, LEVEL2RESULT **result)
static SCIP_RETCODE getOldBranching(SCIP *scip, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real *oldlpobjval)
#define DEFAULT_UPDATEBRANCHINGRESULTS
#define BRANCHRULE_PRIORITY
static SCIP_RETCODE scoreContainerCreate(SCIP *scip, SCORECONTAINER **scorecontainer, CONFIGURATION *config)
static SCIP_RETCODE applyDomainReductions(SCIP *scip, CONFIGURATION *config, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domreds, SCIP_Bool *domredcutoff, SCIP_Bool *domred)
#define DEFAULT_PROPAGATE
static SCIP_Real calculateScaledCutoffScore(BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult)
static SCIP_RETCODE level2dataEnsureSize(SCIP *scip, LEVEL2DATA *data)
#define DEFAULT_DEEPERSCORINGFUNCTION
static SCIP_RETCODE executeBranching(SCIP *scip, CONFIGURATION *config, SCIP_Bool downbranching, CANDIDATE *candidate, BRANCHINGRESULTDATA *resultdata, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domreds, STATUS *status)
static SCIP_RETCODE statusCreate(SCIP *scip, STATUS **status)
static void addLowerBound(SCIP *scip, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_SOL *baselpsol, SCIP_Bool simplechange, DOMAINREDUCTIONS *domainreductions)
static SCIP_Real calculateScoreFromPseudocosts(SCIP *scip, CANDIDATE *lpcand)
#define DEFAULT_SCORINGFUNCTION
static void createBinaryConstraintName(SCIP_VAR **binaryvars, int nbinaryvars, char *constraintname)
static SCIP_RETCODE executeBranchingRecursive(SCIP *scip, STATUS *status, CONFIGURATION *config, SCIP_SOL *baselpsol, CANDIDATE *candidate, SCIP_Real localbaselpsolval, SCIP_Real baselpobjval, int recursiondepth, DOMAINREDUCTIONS *domainreductions, BINCONSDATA *binconsdata, LEVEL2DATA *level2data, BRANCHINGRESULTDATA *branchingresult, SCORECONTAINER *scorecontainer, SCIP_Bool downbranching)
static void binaryVarListDrop(BINARYVARLIST *list)
#define DEFAULT_USELEVEL2DATA
static SCIP_Bool areBoundsChanged(SCIP *scip, SCIP_VAR *var, SCIP_Real lowerbound, SCIP_Real upperbound)
static SCIP_Bool isBranchFurther(STATUS *status, SCIP_Bool checkdomreds)
#define DEFAULT_ENFORCEMAXDOMREDS
static SCIP_RETCODE branchingResultDataCreate(SCIP *scip, BRANCHINGRESULTDATA **resultdata)
static SCIP_RETCODE domainReductionsCreate(SCIP *scip, DOMAINREDUCTIONS **domreds)
static SCIP_RETCODE copyCurrentSolution(SCIP *scip, SCIP_SOL **lpsol)
#define DEFAULT_ABBREVIATED
static SCIP_RETCODE warmStartInfoFree(SCIP *scip, WARMSTARTINFO **warmstartinfo)
#define DEFAULT_MERGEDOMAINREDUCTIONS
static void branchingResultDataCopy(BRANCHINGRESULTDATA *sourcedata, BRANCHINGRESULTDATA *targetdata)
static SCIP_RETCODE applyBinaryConstraints(SCIP *scip, SCIP_NODE *basenode, CONSTRAINTLIST *conslist, CONFIGURATION *config, SCIP_Bool *consadded, SCIP_Bool *cutoff, SCIP_Bool *boundchange)
static SCIP_RETCODE scoreContainerFree(SCIP *scip, SCORECONTAINER **scorecontainer)
#define DEFAULT_ADDCLIQUE
#define DEFAULT_REEVALAGE
#define DEFAULT_REEVALAGEFSB
static SCIP_RETCODE constraintListCreate(SCIP *scip, CONSTRAINTLIST **conslist, int startsize)
static SCIP_Real calculateScoreFromDeeperscoreAndCutoffs(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult)
static void scoreContainterResetBestSortedCands(SCORECONTAINER *scorecontainer)
static SCIP_Bool isUsePreviousResult(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
static SCIP_RETCODE ensureScoresPresent(SCIP *scip, STATUS *status, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domainreductions, BINCONSDATA *binconsdata, CANDIDATELIST *allcandidates, BRANCHINGDECISION *decision, SCORECONTAINER *scorecontainer, LEVEL2DATA *level2data, SCIP_Real lpobjval)
static SCIP_RETCODE candidateCreate(SCIP *scip, CANDIDATE **candidate)
#define DEFAULT_MAXNDEEPERCANDS
static SCIP_RETCODE candidateListCreate(SCIP *scip, CANDIDATELIST **candidatelist, int ncandidates)
static SCIP_Bool isBranchFurtherLoopDecrement(STATUS *status, int *loopcounter)
static void binaryVarListAppend(SCIP *scip, BINARYVARLIST *list, SCIP_VAR *vartoadd)
#define level2resultPrint(scip, result)
static SCIP_Bool level2resultEqual(LEVEL2RESULT *result1, LEVEL2RESULT *result2)
static SCIP_Real calculateScore(SCIP *scip, CONFIGURATION *config, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval, SCIP_Real baselpobjval)
static SCIP_RETCODE usePreviousResult(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata, SCIP_RESULT *result)
static SCIP_RETCODE level2resultCreateFromData(SCIP *scip, LEVEL2DATA *data, LEVEL2RESULT **result)
static SCIP_RETCODE candidateListKeep(SCIP *scip, CANDIDATELIST *candidatelist, int nindices)
static SCIP_RETCODE filterCandidates(SCIP *scip, STATUS *status, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domainreductions, BINCONSDATA *binconsdata, CANDIDATELIST *candidatelist, BRANCHINGDECISION *decision, SCORECONTAINER *scorecontainer, LEVEL2DATA *level2data, SCIP_Real lpobjval)
#define DEFAULT_APPLYCHILDBOUNDS
static SCIP_Real calculateScoreFromResult2(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
static SCIP_RETCODE initBranchruleData(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
#define DEFAULT_MINWEIGHT
static int findInsertionPoint(SCIP *scip, SCORECONTAINER *scorecontainer, SCIP_Real scoretoinsert, CANDIDATE **candidates, int ncandidates)
static SCIP_RETCODE candidateFree(SCIP *scip, CANDIDATE **candidate)
static SCIP_RETCODE candidateListGetAllFractionalCandidates(SCIP *scip, CANDIDATELIST **candidatelist)
#define DEFAULT_ADDBINCONSROW
static SCIP_RETCODE selectVarRecursive(SCIP *scip, STATUS *status, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domainreductions, BINCONSDATA *binconsdata, CANDIDATELIST *candidatelist, BRANCHINGDECISION *decision, SCORECONTAINER *scorecontainer, LEVEL2DATA *level2data, int recursiondepth, SCIP_Real lpobjval, SCIP_Real baselpobjval, SCIP_Longint *niterations, int *ndeepestcutoffs, SCIP_Real *bestgain, SCIP_Real *totalgains, int *ntotalgains, int *ndeepestnodes)
static void binaryVarListFree(SCIP *scip, BINARYVARLIST **list)
static SCIP_RETCODE getNIterationsLastLP(SCIP *scip, SCIP_Longint *iterations)
static SCIP_RETCODE binConsDataCreate(SCIP *scip, BINCONSDATA **consdata, int maxdepth, int nstartcons)
static SCIP_RETCODE candidateStoreWarmStartInfo(SCIP *scip, CANDIDATE *candidate, SCIP_Bool down)
#define DEFAULT_LEVEL2AVGSCORE
static SCIP_RETCODE branchOnVar(SCIP *scip, CONFIGURATION *config, BRANCHINGDECISION *decision)
static void statusFree(SCIP *scip, STATUS **status)
static SCIP_RETCODE level2dataCreate(SCIP *scip, LEVEL2DATA **data)
static void applyDeeperDomainReductions(SCIP *scip, SCIP_SOL *baselpsol, int maxstoredomreds, DOMAINREDUCTIONS *targetdomreds, DOMAINREDUCTIONS *downdomreds, DOMAINREDUCTIONS *updomreds)
static void level2dataFree(SCIP *scip, LEVEL2DATA **data)
static SCIP_Bool isUseOldBranching(SCIP *scip, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_VAR *branchvar)
static void addUpperBound(SCIP *scip, SCIP_VAR *var, SCIP_Real upperbound, SCIP_SOL *baselpsol, SCIP_Bool simplechange, DOMAINREDUCTIONS *domainreductions)
static SCIP_RETCODE freePersistent(SCIP *scip, SCIP_BRANCHRULEDATA *branchruledata)
static void branchingDecisionFree(SCIP *scip, BRANCHINGDECISION **decision)
static SCIP_RETCODE level2dataGetResult(SCIP *scip, LEVEL2DATA *data, LEVEL2RESULT **result)
static SCIP_RETCODE candidateFreeWarmStartInfo(SCIP *scip, CANDIDATE *candidate)
static SCIP_Real calculateScoreFromDeeperscore(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult)
static void branchingDecisionCopy(BRANCHINGDECISION *sourcedecision, BRANCHINGDECISION *targetdecision)
SCIP_RETCODE SCIPincludeBranchruleLookahead(SCIP *scip)
static SCIP_RETCODE scoreContainerSetScore(SCIP *scip, SCORECONTAINER *scorecontainer, CANDIDATE *cand, SCIP_Real score, SCIP_Real downgain, SCIP_Real upgain)
#define DEFAULT_REUSEBASIS
static void constraintListFree(SCIP *scip, CONSTRAINTLIST **conslist)
static SCIP_RETCODE addBinaryConstraint(SCIP *scip, CONFIGURATION *config, BINCONSDATA *binconsdata, SCIP_SOL *baselpsol)
#define DEFAULT_RECURSIONDEPTH
static SCIP_RETCODE candidateListFree(SCIP *scip, CANDIDATELIST **candidatelist)
static SCIP_Real calculateWeightedCutoffScore(CONFIGURATION *config, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult)
#define DEFAULT_USEDOMAINREDUCTION
static SCIP_RETCODE warmStartInfoCreate(SCIP *scip, WARMSTARTINFO **warmstartinfo)
static SCIP_Bool isStoreDecision(CONFIGURATION *config, BINCONSDATA *binconsdata, DOMAINREDUCTIONS *domainreductions)
#define DEFAULT_MAXNVIOLATEDCONS
static void applySingleDeeperDomainReductions(SCIP *scip, SCIP_SOL *baselpsol, int maxstoredomreds, DOMAINREDUCTIONS *targetdomreds, DOMAINREDUCTIONS *domreds)
static CANDIDATE * scoreContainerUpdateSortOrder(SCORECONTAINER *scorecontainer, CANDIDATE *candidate, int insertpoint)
static SCIP_RETCODE constraintListAppend(SCIP *scip, CONSTRAINTLIST *list, SCIP_VAR **consvars, int nconsvars, SCIP_Bool violated)
static SCIP_RETCODE binaryVarListCreate(SCIP *scip, BINARYVARLIST **list, int startsize)
static SCIP_RETCODE createBinaryConstraint(SCIP *scip, CONFIGURATION *config, SCIP_CONS **constraint, char *constraintname, SCIP_VAR **consvars, int nconsvars)
static SCIP_Bool candidateHasWarmStartInfo(CANDIDATE *candidate, SCIP_Bool down)
#define DEFAULT_SCORINGSCORINGFUNCTION
static void branchingResultDataFree(SCIP *scip, BRANCHINGRESULTDATA **resultdata)
#define LABdebugMessage(scip, lvl,...)
static SCIP_RETCODE updateOldBranching(SCIP *scip, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_VAR *branchvar, SCIP_Real branchval, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
#define DEFAULT_STOREUNVIOLATEDSOL
static SCIP_Bool isCurrentNodeCutoff(SCIP *scip)
#define DEFAULT_WORSEFACTOR
#define DEFAULT_MAXNVIOLATEDBINCONS
static SCIP_RETCODE level2dataStoreResult(SCIP *scip, LEVEL2DATA *data, SCIP_Real lpobjval, SCIP_Bool cutoff, SCIP_Bool valid, SCIP_Bool *duplicate)
#define DEFAULT_ABBREVPSEUDO
#define DEFAULT_PREFERSIMPLEBOUNDS
static SCIP_Real calculateWeightedGain(SCIP *scip, CONFIGURATION *config, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
#define DEFAULT_FILTERBYMAXGAIN
#define DEFAULT_MAXPROPROUNDS
static void branchingResultDataInit(SCIP *scip, BRANCHINGRESULTDATA *resultdata)
static SCIP_Real calculateRelCutoffScore(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
static SCIP_Real calculateCutoffScore(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
static void sortFirstCandidatesByScore(SCIP *scip, CANDIDATELIST *candidatelist, SCORECONTAINER *scorecontainer, int nbestcandidates)
#define BRANCHRULE_MAXDEPTH
#define DEFAULT_ONLYVIOLDOMREDS
static SCIP_RETCODE branchingDecisionCreate(SCIP *scip, BRANCHINGDECISION **decision)
static SCIP_Real calculateScoreFromResult(SCIP *scip, SCIP_VAR *branchvar, BRANCHINGRESULTDATA *downbranchingresult, BRANCHINGRESULTDATA *upbranchingresult, SCIP_Real lpobjval)
static SCIP_RETCODE getFSBResult(SCIP *scip, STATUS *status, PERSISTENTDATA *persistent, CONFIGURATION *config, SCIP_SOL *baselpsol, DOMAINREDUCTIONS *domainreductions, BINCONSDATA *binconsdata, CANDIDATELIST *candidatelist, BRANCHINGDECISION *decision, SCORECONTAINER *scorecontainer, LEVEL2DATA *level2data, SCIP_Real lpobjval)
#define DEFAULT_ADDNONVIOCONS
static SCIP_Bool branchingDecisionIsValid(BRANCHINGDECISION *decision)
#define BRANCHRULE_MAXBOUNDDIST
static void branchingDecisionInit(SCIP *scip, BRANCHINGDECISION *decision)
static SCIP_RETCODE candidateLoadWarmStartInfo(SCIP *scip, CANDIDATE *candidate, SCIP_Bool down)
#define DEFAULT_MAXNVIOLATEDDOMREDS
#define DEFAULT_LEVEL2ZEROSCORE
#define DEFAULT_MAXNCANDS
lookahead LP branching rule
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
#define SCIP_MAXTREEDEPTH
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPcreateConsLogicor(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_Bool SCIPisExactSolve(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
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_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 SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetBranchruleInit(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
SCIP_RETCODE SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule,)
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,)
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)
int SCIPgetNPseudoBranchCands(SCIP *scip)
SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
int SCIPgetNLPRows(SCIP *scip)
SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
SCIP_Bool SCIPallColsInLP(SCIP *scip)
SCIP_Real SCIPgetLPObjval(SCIP *scip)
#define SCIPfreeBuffer(scip, ptr)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocMemoryArray(scip, ptr, num)
#define SCIPallocClearBufferArray(scip, ptr, num)
int SCIPcalcMemGrowSize(SCIP *scip, int num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPallocMemory(scip, ptr)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPfreeMemoryArray(scip, ptr)
#define SCIPfreeMemory(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPallocBuffer(scip, ptr)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_Real SCIPnodeGetEstimate(SCIP_NODE *node)
int SCIPgetProbingDepth(SCIP *scip)
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPsetProbingLPState(SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_Bool SCIPinProbing(SCIP *scip)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_RETCODE SCIPcreateLPSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Longint SCIPgetNNodeZeroIterationLPs(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNTotalNodes(SCIP *scip)
SCIP_Longint SCIPgetNNodeLPIterations(SCIP *scip)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Longint SCIPgetNNodeLPs(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsumepsilon(SCIP *scip)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisSumLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetCutoffdepth(SCIP *scip)
int SCIPgetDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
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_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
void SCIPenableVarHistory(SCIP *scip)
SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPfreeSol(scip, &heurdata->sol))
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Bool propagate
interface methods for specific LP solvers
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
#define BMSclearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
public methods for branching rules
public methods for message output
public data structures and miscellaneous methods
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 numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
CONSTRAINTLIST * conslist
BINARYVARLIST * binaryvars
SCIP_Real * downlowerbounds
SCIP_Real * upupperbounds
SCIP_Real * uplowerbounds
SCIP_Real * downupperbounds
WARMSTARTINFO * downwarmstartinfo
WARMSTARTINFO * upwarmstartinfo
SCIP_Bool applychildbounds
SCIP_Bool usedomainreduction
SCIP_Bool storeunviolatedsol
SCIP_Longint reevalagefsb
SCIP_Bool mergedomainreductions
SCIP_Bool onlyvioldomreds
SCIP_Bool prefersimplebounds
char deeperscoringfunction
char scoringscoringfunction
SCIP_Bool enforcemaxdomreds
SCIP_Bool updatebranchingresults
SCIP_Bool level2zeroscore
SCIP_Bool filterbymaxgain
SCIP_Shortbool * baselpviolated
LEVEL2RESULT ** level2results
SCIP_Longint * lastbranchid
SCIP_Longint oldnnodelpiterations
SCIP_Longint * lastbranchnlps
BRANCHINGDECISION * olddecision
SCIP_Real * lastbranchlpobjval
SCIP_Longint oldntotalnodes
BRANCHINGRESULTDATA ** lastbranchdownres
BRANCHINGRESULTDATA ** lastbranchupres
CANDIDATE ** bestsortedcands
SCIP_Bool maxnconsreached
#define SCIP_DECL_BRANCHEXECLP(x)
#define SCIP_DECL_BRANCHINIT(x)
#define SCIP_DECL_BRANCHCOPY(x)
#define SCIP_DECL_BRANCHEXIT(x)
#define SCIP_DECL_BRANCHFREE(x)
struct SCIP_BranchruleData SCIP_BRANCHRULEDATA
#define SCIP_DECL_BRANCHEXITSOL(x)
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_TIMELIMIT
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_ITERLIMIT
enum SCIP_VerbLevel SCIP_VERBLEVEL
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS