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);
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
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
1309 (*localstats)->ncutoffproofnodes = 0;
1329struct SCIP_BranchruleData
1333 SCIP_Bool isinitialized;
1334#ifdef SCIP_STATISTIC
1369 (*conslist)->nelements = 0;
1371 (*conslist)->nviolatedcons = 0;
1392 if(
list->memorysize ==
list->nelements )
1404 list->nconsvars[
list->nelements] = nconsvars;
1405 list->violated[
list->nelements] = violated;
1423 for(
i = 0;
i < (*conslist)->nelements;
i++ )
1464 (*list)->nbinaryvars = 0;
1486 list->nbinaryvars++;
1500 list->nbinaryvars--;
1579 assert(ncandidates >= 0);
1583 if( ncandidates > 0 )
1588 (*candidatelist)->candidates =
NULL;
1590 (*candidatelist)->ncandidates = ncandidates;
1651 assert((*candidatelist)->ncandidates > 0 || (*candidatelist)->candidates ==
NULL);
1653 if( (*candidatelist)->candidates !=
NULL )
1655 for(
i = (*candidatelist)->ncandidates - 1;
i >= 0;
i-- )
1712#ifdef SCIP_STATISTIC
1741#ifdef SCIP_STATISTIC
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;
1890 (*scorecontainer)->scores[
i] = -1.0;
1891 (*scorecontainer)->downgains[
i] = -1.0;
1892 (*scorecontainer)->upgains[
i] = -1.0;
1913 int right = ncandidates - 1;
1918 assert(ncandidates >= 0);
1920 while( left <= right )
1922 int mid = left + ((right - left) / 2);
2069 SCIP_Longint* niterations,
2070 int* ndeepestcutoffs,
2071 SCIP_Real* bestgain,
2072 SCIP_Real* totalgains,
2088 SCIP_Real lowerbound,
2106#ifdef SCIP_STATISTIC
2123#ifdef SCIP_STATISTIC
2153 SCIP_Real upperbound,
2171#ifdef SCIP_STATISTIC
2182#ifdef SCIP_STATISTIC
2197#ifdef SCIP_STATISTIC
2249#ifdef SCIP_STATISTIC
2260#ifdef SCIP_STATISTIC
2312 SCIP_Real newupperbound;
2323#ifdef SCIP_STATISTIC
2337#ifdef SCIP_STATISTIC
2357 SCIP_Bool* domredcutoff,
2367#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2377#ifdef SCIP_STATISTIC
2382 *domredcutoff =
FALSE;
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
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
2501#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
2514#ifdef SCIP_STATISTIC
2681 SCIP_Longint* iterations
2714 SCIP_Real oldupperbound;
2719 SCIP_Real branchval;
2759 oldupperbound, newbound, oldupperbound);
2811 SCIP_Longint ndomredsfound = 0;
2815 if( ndomredsfound > 0 )
2832 SCIP_Real lowerbound;
2833 SCIP_Real upperbound;
2839#ifdef SCIP_STATISTIC
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) );
2961 for(
i = 1;
i < nbinaryvars;
i++ )
3024 binconsdata->binaryvars->nbinaryvars, violated) );
3036#ifdef SCIP_STATISTIC
3054 SCIP_Bool* consadded,
3065#ifdef SCIP_STATISTIC
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
3167#ifdef SCIP_STATISTIC
3181 SCIP_Real lowerbound,
3182 SCIP_Real upperbound
3316 SCIP_Real branchval,
3382#ifdef SCIP_STATISTIC
3418 for(
i = 0;
i < ncands;
i++ )
3889 char scoringfunction;
3904 switch( scoringfunction )
3934 assert(scoringfunction ==
'd');
4189#ifdef SCIP_STATISTIC
4259#ifdef SCIP_STATISTIC
4382 SCIP_Real branchval;
4459#ifdef SCIP_STATISTIC
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",
4496#ifdef SCIP_STATISTIC
4554 if( recursiondepth > 1 && !config->
inscoring )
4570#ifdef SCIP_STATISTIC
4579#ifdef SCIP_STATISTIC
4603#ifdef SCIP_STATISTIC
4631#ifdef SCIP_STATISTIC
4640 statistics->cutoffafterfsb[probingdepth+1]++;
4644 statistics->domredafterfsb[probingdepth+1]++;
4652#ifdef SCIP_STATISTIC
4661#ifdef SCIP_STATISTIC
4673 if( recursiondepth == 1 && !config->
inscoring )
4687 &&
binconsdata->binaryvars->nbinaryvars == (probingdepth + 1) )
4689#ifdef SCIP_STATISTIC
4722 SCIP_Longint* niterations,
4723 int* ndeepestcutoffs,
4724 SCIP_Real* bestgain,
4725 SCIP_Real* totalgains,
4761 assert(recursiondepth >= 1);
4762#ifdef SCIP_STATISTIC
4836 SCIP_Real branchval;
4860#ifdef SCIP_STATISTIC
4870#ifdef SCIP_STATISTIC
4886#ifdef SCIP_STATISTIC
4888 statistics->noldbranchusedfsb[probingdepth]++;
4911 for(
k = 0;
k < 2; ++
k )
4921#ifdef SCIP_STATISTIC
4939 "The %s branching changed the cutoffbound and rendered the %s branching result infeasible.\n",
4940 down ?
"down" :
"up",
down ?
"up" :
"down");
4956 if( niterations !=
NULL )
4967 if( ndeepestcutoffs !=
NULL )
4970 if( ndeepestnodes !=
NULL )
4979#ifdef SCIP_STATISTIC
4989 *bestgain =
MAX(*bestgain, score);
4993 (*totalgains) += score;
5006#ifdef SCIP_STATISTIC
5022#ifdef SCIP_STATISTIC
5037#ifdef SCIP_STATISTIC
5052#ifdef SCIP_STATISTIC
5067#ifdef SCIP_STATISTIC
5119#ifdef SCIP_STATISTIC
5139#ifdef SCIP_STATISTIC
5254#ifdef SCIP_STATISTIC
5336#ifdef SCIP_STATISTIC
5348#ifdef SCIP_STATISTIC
5355 assert(recursiondepth > 0);
5363#ifdef SCIP_STATISTIC
5384#ifdef SCIP_STATISTIC
5417#ifdef SCIP_STATISTIC
5439#ifdef SCIP_STATISTIC
5459#ifdef SCIP_STATISTIC
5461 decision,
scorecontainer,
level2data, recursiondepth, lpobjval, lpobjval,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
5465 decision,
scorecontainer,
level2data, recursiondepth, lpobjval, lpobjval,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL) );
5487#ifdef SCIP_STATISTIC
5509 int probingdepth = 0;
5539#ifdef SCIP_STATISTIC
5561#ifdef SCIP_STATISTIC
5577#if defined(SCIP_DEBUG) || defined(SCIP_STATISTIC)
5584#ifdef SCIP_STATISTIC
5593#ifdef SCIP_STATISTIC
5598 else if( status->
cutoff )
5609#ifdef SCIP_STATISTIC
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;
5918#ifdef SCIP_STATISTIC
5960 if( branchruledata->isinitialized )
5986 config = branchruledata->config;
6001#ifdef SCIP_STATISTIC
6002 branchruledata->statistics->noldcandidate++;
6011#ifdef SCIP_STATISTIC
6032#ifdef SCIP_STATISTIC
6045#ifdef SCIP_STATISTIC
6046 branchruledata->statistics->ncutoffproofnodes +=
localstats->ncutoffproofnodes;
6053 else if( status->
domred )
6059#ifdef SCIP_STATISTIC
6060 ++branchruledata->statistics->nlperrorcalls;
6078#ifdef SCIP_STATISTIC
6081 ++branchruledata->statistics->nlimitcalls;
6120 "problem is infeasible.\n");
6129 "lookahead branching.\n");
6137#ifdef SCIP_STATISTIC
6151#ifdef SCIP_STATISTIC
6154 branchruledata->statistics->ntotalresults++;
6155 branchruledata->statistics->nresults[*
result]++;
6162 sum = branchruledata->statistics->nsinglecandidate + branchruledata->statistics->nsingleafterfilter
6163 + branchruledata->statistics->noldcandidate + branchruledata->statistics->nlperrorcalls
6164 + branchruledata->statistics->nlimitcalls;
6166 for(
i = 0;
i < branchruledata->statistics->maxnbestcands;
i++ )
6168 sum += branchruledata->statistics->chosenfsbcand[
i];
6170 if( sum != branchruledata->statistics->nresults[
SCIP_BRANCHED] )
6172 printf(
"branched = %d != sum = %d (%d/%d/%d/%d/%d)\n",
6174 branchruledata->statistics->nsinglecandidate, branchruledata->statistics->nsingleafterfilter,
6175 branchruledata->statistics->noldcandidate,
6176 branchruledata->statistics->nlperrorcalls, branchruledata->statistics->nlimitcalls);
6183 branchruledata->statistics->ncutoffproofnodes, branchruledata->statistics->ndomredproofnodes);
6208 branchruledata->persistent->restartindex = 0;
6209 branchruledata->isinitialized =
FALSE;
6210 branchruledata->config->inscoring =
FALSE;
6228 "branching/lookahead/useimpliedbincons",
6229 "should binary constraints be collected and applied?",
6232 "branching/lookahead/addbinconsrow",
6233 "should binary constraints be added as rows to the base LP? (0: no, 1: separate, 2: as initial rows)",
6236 "how many constraints that are violated by the base lp solution should be gathered until the rule is stopped and "\
6237 "they are added? [0 for unrestricted]",
6240 "how many binary constraints that are violated by the base lp solution should be gathered until the rule is "\
6241 "stopped and they are added? [0 for unrestricted]",
6244 "how many domain reductions that are violated by the base lp solution should be gathered until the rule is "\
6245 "stopped and they are added? [0 for unrestricted]",
6248 "branching/lookahead/reevalage",
6249 "max number of LPs solved after which a previous prob branching results are recalculated",
6252 "branching/lookahead/reevalagefsb",
6253 "max number of LPs solved after which a previous FSB scoring results are recalculated",
6256 "the max depth of LAB.",
6259 "branching/lookahead/usedomainreduction",
6260 "should domain reductions be collected and applied?",
6263 "branching/lookahead/mergedomainreductions",
6264 "should domain reductions of feasible siblings should be merged?",
6267 "branching/lookahead/prefersimplebounds",
6268 "should domain reductions only be applied if there are simple bound changes?",
6271 "branching/lookahead/onlyvioldomreds",
6272 "should only domain reductions that violate the LP solution be applied?",
6275 "branching/lookahead/addnonviocons",
6276 "should binary constraints, that are not violated by the base LP, be collected and added?",
6279 "branching/lookahead/abbreviated",
6280 "toggles the abbreviated LAB.",
6283 "if abbreviated: The max number of candidates to consider at the node.",
6286 "if abbreviated: The max number of candidates to consider per deeper node.",
6289 "branching/lookahead/reusebasis",
6290 "if abbreviated: Should the information gathered to obtain the best candidates be reused?",
6293 "branching/lookahead/storeunviolatedsol",
6294 "if only non violating constraints are added, should the branching decision be stored till the next call?",
6297 "branching/lookahead/abbrevpseudo",
6298 "if abbreviated: Use pseudo costs to estimate the score of a candidate.",
6301 "branching/lookahead/level2avgscore",
6302 "should the average score be used for uninitialized scores in level 2?",
6305 "branching/lookahead/level2zeroscore",
6306 "should uninitialized scores in level 2 be set to 0?",
6309 "branching/lookahead/addclique",
6310 "add binary constraints with two variables found at the root node also as a clique",
6313 "branching/lookahead/propagate",
6314 "should domain propagation be executed before each temporary node is solved?",
6317 "branching/lookahead/uselevel2data",
6318 "should branching data generated at depth level 2 be stored for re-using it?",
6321 "branching/lookahead/applychildbounds",
6322 "should bounds known for child nodes be applied?",
6325 "branching/lookahead/enforcemaxdomreds",
6326 "should the maximum number of domain reductions maxnviolateddomreds be enforced?",
6329 "branching/lookahead/updatebranchingresults",
6330 "should branching results (and scores) be updated w.r.t. proven dual bounds?",
6333 "branching/lookahead/maxproprounds",
6334 "maximum number of propagation rounds to perform at each temporary node (-1: unlimited, 0: SCIP default)",
6337 "branching/lookahead/scoringfunction",
6338 "scoring function to be used at the base level",
6341 "branching/lookahead/deeperscoringfunction",
6342 "scoring function to be used at deeper levels",
6345 "branching/lookahead/scoringscoringfunction",
6346 "scoring function to be used during FSB scoring",
6349 "branching/lookahead/minweight",
6350 "if scoringfunction is 's', this value is used to weight the min of the gains of two child problems in the convex combination",
6353 "branching/lookahead/worsefactor",
6354 "if the FSB score is of a candidate is worse than the best by this factor, skip this candidate (-1: disable)",
6357 "branching/lookahead/filterbymaxgain",
6358 "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 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