Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://scip.zib.de/doc/html/branch__lookahead_8c_source.php below:

SCIP Doxygen Documentation: branch_lookahead.c Source File

, __FILE__, __LINE__); \

stage = SCIPgetStage(scip); \

if( stage == SCIP_STAGE_INIT ) \

SCIPverbMessage(scip, lvl, NULL, "Init : "); \

else if( stage == SCIP_STAGE_FREE ) \

SCIPverbMessage(scip, lvl, NULL, "Free : "); \

else if( SCIPinProbing(scip) ) \

SCIPverbMessage(scip, lvl, NULL, "%*sDepth %i: ", \

2 * SCIPgetProbingDepth(scip), "", SCIPgetProbingDepth(scip)); \

SCIPverbMessage(scip, lvl, NULL, "Base : "); \

SCIPverbMessage(scip, lvl, NULL, __VA_ARGS__); \

assert(warmstartinfo !=

);

(*warmstartinfo)->lpistate =

;

(*warmstartinfo)->lpinorms =

;

(*warmstartinfo)->primalfeas =

;

(*warmstartinfo)->dualfeas =

;

assert(warmstartinfo !=

);

( (*warmstartinfo)->lpistate !=

)

( (*warmstartinfo)->lpinorms !=

)

assert(candidate !=

);

(*candidate)->downwarmstartinfo =

;

(*candidate)->upwarmstartinfo =

;

(*candidate)->branchvar =

;

assert(candidate !=

);

assert(candidate !=

);

(*candidate)->upwarmstartinfo !=

, (*candidate)->downwarmstartinfo !=

);

assert(candidate !=

);

assert(candidate !=

);

assert(candidate !=

);

assert(decision !=

);

assert(decision !=

);

assert(sourcedecision !=

);

assert(targetdecision !=

);

targetdecision->

= sourcedecision->

;

targetdecision->

= sourcedecision->

;

assert(decision !=

);

assert(decision !=

);

assert(decision !=

);

( (*decision)->boundssize != 0 )

assert((*decision)->downlowerbounds !=

);

assert((*decision)->downupperbounds !=

);

assert((*decision)->uplowerbounds !=

);

assert((*decision)->upupperbounds !=

);

assert(resultdata !=

);

assert(resultdata !=

);

assert(sourcedata !=

);

assert(targetdata !=

);

assert(resultdata !=

);

assert(data !=

);

assert(result !=

);

assert(result !=

);

,

assert(result !=

);

assert(data !=

);

(*data)->level2results =

;

(*data)->nlevel2results = 0;

(*data)->level2resultssize = 0;

(*data)->branchvar1 = 0;

(*data)->branchvar2 = 0;

(*data)->branchdir1 = 0;

(*data)->branchdir2 = 0;

assert(data !=

);

( (*data)->nlevel2results > 0 )

--(*data)->nlevel2results;

assert((*data)->nlevel2results == 0);

( (*data)->level2results !=

)

assert(data !=

);

assert(data !=

);

assert(result !=

);

assert(data !=

);

assert(duplicate !=

);

result->

= valid;

* getStatusString(

assert(result >= 1);

assert(result <= 18);

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

;

(

, result);

* nsinglecutoffs;

* nlpssolvedfsb;

* nduplicatelps;

* noldbranchused;

* noldbranchusedfsb;

* chosenfsbcand;

* cutoffafterfsb;

* domredafterfsb;

nsinglecandidate;

nsingleafterfilter;

ncutoffproofnodes;

ndomredproofnodes;

STATISTICS* statistics

assert(statistics !=

);

assert(statistics->recursiondepth > 0);

statistics->nsinglecandidate = 0;

statistics->nsingleafterfilter = 0;

statistics->noldcandidate = 0;

statistics->nlperrorcalls = 0;

statistics->nlimitcalls = 0;

statistics->ntotalresults = 0;

statistics->nbinconst = 0;

statistics->nbinconstvio = 0;

statistics->ndomredvio = 0;

statistics->ndepthreached = 0;

statistics->ndomred = 0;

statistics->ndomredcons = 0;

statistics->ncutoffproofnodes = 0;

statistics->ndomredproofnodes = 0;

statistics->ncliquesadded = 0;

( i = 0; i <= MAXRESULT; i++)

statistics->nresults[i] = 0;

( i = 0; i < statistics->recursiondepth; i++ )

statistics->noldbranchused[i] = 0;

statistics->noldbranchusedfsb[i] = 0;

statistics->npropdomred[i] = 0;

statistics->nfullcutoffs[i] = 0;

statistics->nlpssolved[i] = 0;

statistics->nlpssolvedfsb[i] = 0;

statistics->nduplicatelps[i] = 0;

statistics->nlpiterations[i] = 0;

statistics->nlpiterationsfsb[i] = 0;

statistics->nsinglecutoffs[i] = 0;

statistics->stopafterfsb[i] = 0;

statistics->cutoffafterfsb[i] = 0;

statistics->domredafterfsb[i] = 0;

( i = 0; i < statistics->maxnbestcands; i++ )

statistics->chosenfsbcand[i] = 0;

statisticsPrint(

STATISTICS* statistics

assert(statistics !=

);

assert(statistics->recursiondepth > 0);

( statistics->ntotalresults > 0 )

( i = 1; i <= MAXRESULT; i++ )

statistics->nresults[i]);

( i = 0; i < statistics->maxnbestcands; i++ )

( statistics->chosenfsbcand[i] > 0 )

i+1, statistics->chosenfsbcand[i]);

( i = 0; i < statistics->recursiondepth; i++ )

i, statistics->stopafterfsb[i], statistics->cutoffafterfsb[i], statistics->domredafterfsb[i]);

i, statistics->nfullcutoffs[i], statistics->nsinglecutoffs[i]);

i, statistics->nlpssolved[i], statistics->nlpssolvedfsb[i], statistics->nduplicatelps[i]);

, i, statistics->nlpiterations[i],

statistics->nlpiterationsfsb[i]);

, i, statistics->npropdomred[i]);

i, statistics->noldbranchused[i], statistics->noldbranchusedfsb[i]);

statistics->nsinglecandidate, statistics->nsingleafterfilter);

statistics->noldcandidate);

statistics->nlperrorcalls);

statistics->nlimitcalls);

statistics->ndomredcons);

statistics->nbinconst, statistics->nbinconstvio);

statistics->ndomred, statistics->ndomredvio);

statistics->ncliquesadded);

statistics->ncutoffproofnodes);

statistics->ndomredproofnodes);

ncutoffproofnodes;

LOCALSTATISTICS** localstats

assert(localstats !=

);

(*localstats)->ncutoffproofnodes = 0;

localStatisticsFree(

LOCALSTATISTICS** localstats

assert(localstats !=

);

SCIP_BranchruleData

STATISTICS* statistics;

assert(conslist !=

);

assert(startsize > 0);

(*conslist)->nelements = 0;

(*conslist)->memorysize = startsize;

(*conslist)->nviolatedcons = 0;

assert(list !=

);

assert(consvars !=

);

assert(nconsvars > 0);

assert(conslist !=

);

( i = 0; i < (*conslist)->nelements; i++ )

assert(list !=

);

assert(startsize > 0);

(*list)->nbinaryvars = 0;

(*list)->memorysize = startsize;

assert(list !=

);

assert(vartoadd !=

);

assert(list !=

);

assert(list !=

);

assert(consdata !=

);

assert(maxdepth > 0);

assert(nstartcons > 0);

assert(consdata !=

);

assert(candidatelist !=

);

assert(ncandidates >= 0);

( ncandidates > 0 )

(*candidatelist)->candidates =

;

(*candidatelist)->ncandidates = ncandidates;

assert(candidatelist !=

);

assert(lpcands !=

);

assert(lpcandssol !=

);

assert(lpcandsfrac !=

);

( i = 0; i < nlpcands; i++ )

assert(candidate !=

);

candidate->

= lpcandsfrac[i];

(*candidatelist)->candidates[i] = candidate;

assert(candidatelist !=

);

assert((*candidatelist)->ncandidates > 0 || (*candidatelist)->candidates ==

);

( (*candidatelist)->candidates !=

)

( i = (*candidatelist)->ncandidates - 1; i >= 0; i-- )

* cand = (*candidatelist)->candidates[i];

assert(candidatelist !=

);

assert(0 < nindices);

assert(nindices <= candidatelist->ncandidates);

( i = nindices; i < candidatelist->

; i++ )

* lowerboundnproofs;

* upperboundnproofs;

assert(domreds !=

);

( v = 0; v < ntotalvars; ++v )

(*domreds)->nviolatedvars = 0;

(*domreds)->nchangedvars = 0;

(*domreds)->nsimplebounds = 0;

assert(domreds !=

);

assert(status !=

);

(*status)->addedbinconss =

;

(*status)->depthtoosmall =

;

(*status)->lperror =

;

(*status)->cutoff =

;

(*status)->domred =

;

(*status)->domredcutoff =

;

(*status)->limitreached =

;

(*status)->maxnconsreached =

;

assert(status !=

);

assert(scorecontainer !=

);

assert(scorecontainer !=

);

assert(config !=

);

(*scorecontainer)->nbestsortedcands = ncands;

(*scorecontainer)->scoresum = 0.0;

(*scorecontainer)->nsetscores = 0;

( i = 0; i < ntotalvars; i++ )

(*scorecontainer)->scores[i] = -1.0;

(*scorecontainer)->downgains[i] = -1.0;

(*scorecontainer)->upgains[i] = -1.0;

right = ncandidates - 1;

assert(scorecontainer !=

);

assert(candidates !=

);

assert(ncandidates >= 0);

( left <= right )

mid = left + ((right - left) / 2);

( midcand !=

)

midscore = scorecontainer->

[midindex];

assert(scorecontainer !=

);

assert(candidate !=

);

assert(insertpoint >= 0);

assert(scorecontainer !=

);

assert(cand !=

);

assert(probindex >= 0);

( scorecontainer->

[probindex] < -0.5 )

scorecontainer->

+= score;

scorecontainer->

+= (score - scorecontainer->

[probindex]);

scorecontainer->

[probindex] = score;

scorecontainer->

[probindex] = downgain;

scorecontainer->

[probindex] = upgain;

( droppedcandidate !=

)

assert(scorecontainer !=

);

* ndeepestcutoffs,

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

#ifdef SCIP_STATISTIC

assert(var !=

);

assert(baselpsol !=

);

assert(domainreductions !=

);

assert(nproofnodes >= 0);

(

(

, domainreductions->lowerbounds[varindex], lowerbound) )

domainreductions->lowerbounds[varindex] = lowerbound;

domainreductions->nchangedvars++;

domainreductions->nsimplebounds++;

domainreductions->lowerboundnproofs[varindex] = nproofnodes;

(

(

, domainreductions->lowerbounds[varindex], lowerbound) &&

(force || domainreductions->lowerboundnproofs[varindex] > nproofnodes) )

domainreductions->lowerboundnproofs[varindex] = nproofnodes;

(

(

, domainreductions->lowerbounds[varindex], basesolutionval)

&& !domainreductions->baselpviolated[varindex] )

domainreductions->baselpviolated[varindex] =

;

domainreductions->nviolatedvars++;

#ifdef SCIP_STATISTIC

assert(var !=

);

assert(baselpsol !=

);

assert(domainreductions !=

);

assert(nproofnodes >= 0);

(

(

, domainreductions->upperbounds[varindex], upperbound) )

(

(

, domainreductions->upperbounds[varindex], upperbound) &&

(force || domainreductions->upperboundnproofs[varindex] > nproofnodes) )

domainreductions->upperboundnproofs[varindex] = nproofnodes;

domainreductions->upperbounds[varindex] = upperbound;

domainreductions->nchangedvars++;

domainreductions->nsimplebounds++;

domainreductions->upperboundnproofs[varindex] = nproofnodes;

(

(

, domainreductions->upperbounds[varindex], basesolutionval)

&& !domainreductions->baselpviolated[varindex] )

domainreductions->baselpviolated[varindex] =

;

domainreductions->nviolatedvars++;

maxstoredomreds,

assert(baselpsol !=

);

assert(targetdomreds !=

);

assert(domreds !=

);

assert(vars !=

);

( i = 0; i < nvars; i++ )

domreds->lowerboundnproofs[i],

);

domreds->upperboundnproofs[i],

);

maxstoredomreds,

assert(baselpsol !=

);

assert(targetdomreds !=

);

assert(downdomreds !=

);

assert(updomreds !=

);

assert(vars !=

);

( i = 0; i < nvars; i++ )

assert(vars[i] !=

);

(4, downdomreds->lowerboundnproofs[i] + updomreds->lowerboundnproofs[i] + 2),

);

(4, downdomreds->upperboundnproofs[i] + updomreds->upperboundnproofs[i] + 2),

);

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

nboundsadded = 0;

nboundsaddedvio = 0;

assert(baselpsol !=

);

assert(domreds !=

);

assert(domredcutoff !=

);

assert(domred !=

);

assert(statistics !=

);

*domredcutoff =

;

assert(probvars !=

);

assert(nprobvars > 0);

( i = 0; i < nprobvars && !(*domredcutoff); i++ )

assert(var !=

);

*domredcutoff =

;

( tightened )

statistics->ndomredproofnodes += domreds->lowerboundnproofs[i];

*domredcutoff =

;

( tightened )

statistics->ndomredproofnodes += domreds->upperboundnproofs[i];

statistics->ndomred += nboundsadded;

statistics->ndomredvio += nboundsaddedvio;

, nboundsadded, nboundsaddedvio);

assert(lpsol !=

);

assert(decision !=

);

assert(config !=

);

assert(bestvar !=

);

assert(downchild !=

);

assert(upchild !=

);

( i = 0; i < nvars; i++ )

assert(var !=

);

(

(

, newub, currentub) && var != bestvar )

(

(

, newlb, currentlb) && var != bestvar)

assert(iterations !=

);

assert(candidate !=

);

assert(resultdata !=

);

assert(status !=

);

assert(config !=

);

assert(status !=

);

assert(branchvar !=

);

( downbranching )

( downbranching )

,

(branchvar), newbound, oldlowerbound,

oldupperbound, oldlowerbound, newbound);

,

(branchvar), newbound, oldlowerbound,

oldupperbound, newbound, oldupperbound);

( (downbranching && newbound < oldlowerbound - 0.5)

|| (!downbranching && newbound > oldupperbound + 0.5) )

assert(!resultdata->

);

( downbranching )

( ndomredsfound > 0 )

( domreds !=

)

assert(problemvars !=

);

( i = 0; i < nproblemvars; i++ )

assert(var !=

);

( !resultdata->

)

( resultdata->

)

* constraintname,

assert(config !=

);

assert(constraint !=

);

assert(constraintname !=

);

assert(consvars !=

);

assert(nconsvars > 0);

check, propagate, local, modifiable, dynamic, removable, stickingatnode) );

* constraintname

assert(binaryvars !=

);

assert(nbinaryvars > 0);

assert(constraintname !=

);

assert(binaryvars[0] !=

);

( i = 1; i < nbinaryvars; i++ )

assert(var !=

);

oldlen = strlen(constraintname);

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

assert(config !=

);

assert(binconsdata !=

);

assert(baselpsol !=

);

assert(var !=

);

violated = (lhssum < 1);

assert(statistics !=

);

statistics->ndomredcons++;

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

nvioconsadded = 0;

assert(statistics !=

);

assert(basenode !=

);

assert(conslist !=

);

assert(config !=

);

assert(consadded !=

);

assert(cutoff !=

);

assert(boundchange !=

);

( i = 0; i < conslist->

; i++ )

assert(vars !=

);

( v = 0; v < nvars; ++v )

assert(vars[v] !=

);

statistics->ncliquesadded++;

*boundchange =

;

( nconsadded > 0 )

statistics->nbinconst += nconsadded;

statistics->nbinconstvio += nvioconsadded;

assert(var !=

);

assert(status !=

);

assert(status !=

);

assert(loopcounter !=

);

( !branchfurther )

branchfurther;

assert(config !=

);

assert(branchvar !=

);

assert(persistent !=

);

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

assert(oldlpobjval !=

);

downgain =

(downbranchingresult->

- *oldlpobjval, 0);

upgain =

(upbranchingresult->

- *oldlpobjval, 0);

assert(persistent !=

);

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

assert(config !=

);

assert(candidatelist !=

);

assert(status !=

);

assert(scorecontainer !=

);

binconsdata, candidatelist, decision, scorecontainer, level2data, 1,

statistics, localstats,

,

) );

binconsdata, candidatelist, decision, scorecontainer, level2data, 1,

printCandidates(

assert(candidatelist !=

);

LABdebugMessagePrint(

, lvl,

);

( i = 0; i < ncands; i++ )

assert(cand !=

);

LABdebugMessagePrint(

, lvl,

);

LABdebugMessagePrint(

, lvl,

);

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

( !downbranchingresult->

)

downgain =

(downgain, downbranchingresult->

- lpobjval);

( !upbranchingresult->

)

upgain =

(upgain, upbranchingresult->

- lpobjval);

downgain = 100.0 * downgain;

upgain = 100.0 * upgain;

( downbranchingresult->

)

downgain = 2 * upgain;

( upbranchingresult->

)

upgain = 2 * downgain;

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

( !downbranchingresult->

)

downgain =

(downgain, downbranchingresult->

- lpobjval);

( !upbranchingresult->

)

upgain =

(upgain, upbranchingresult->

- lpobjval);

downgain = 100.0 * downgain;

upgain = 100.0 * upgain;

( downbranchingresult->

)

downgain = 2 * upgain;

( upbranchingresult->

)

upgain = 2 * downgain;

( !downbranchingresult->

)

( !upbranchingresult->

)

downgain = 100.0 * downgain;

upgain = 100.0 * upgain;

( downbranchingresult->

)

downgain = 2 * upgain;

( upbranchingresult->

)

upgain = 2 * downgain;

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

downscore = sqrt(downbranchingresult->

);

( downbranchingresult->

)

downscore = 2 * upscore;

( upbranchingresult->

)

upscore = 2 * downscore;

ntotaldowngains;

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

totaldowngains = downbranchingresult->

;

totalupgains = upbranchingresult->

;

downscore = sqrt(downbranchingresult->

);

( downbranchingresult->

)

downscore = 2 * upscore;

( upbranchingresult->

)

upscore = 2 * downscore;

downscore = sqrt(totaldowngains/ntotaldowngains);

upscore = sqrt(totalupgains/ntotalupgains);

assert(config !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

( !downbranchingresult->

)

downgain =

(0, downbranchingresult->

- lpobjval);

( !upbranchingresult->

)

upgain =

(0, upbranchingresult->

- lpobjval);

( downbranchingresult->

)

( upbranchingresult->

)

( downbranchingresult->

)

( upbranchingresult->

)

nlowestlevelcutoffs;

ntotaldowngains;

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

bestdowngain = downbranchingresult->

;

bestupgain = upbranchingresult->

;

totaldowngains = downbranchingresult->

;

totalupgains = upbranchingresult->

;

bestdowngain + bestupgain + (totaldowngains/ntotaldowngains + totalupgains/ntotalupgains)*nlowestlevelcutoffs;

ntotaldowngains;

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

bestdowngain = downbranchingresult->

;

bestupgain = upbranchingresult->

;

totaldowngains = downbranchingresult->

;

totalupgains = upbranchingresult->

;

config->

*

(bestdowngain, bestupgain) + (1.0 - config->

)*

(bestdowngain, bestupgain) + (totaldowngains/ntotaldowngains + totalupgains/ntotalupgains)*nlowestlevelcutoffs;

nlowestlevelcutoffs;

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

nlowestlevelcutoffs = 0;

( !downbranchingresult->

)

downgain =

(downgain, downbranchingresult->

- lpobjval);

( !upbranchingresult->

)

upgain =

(upgain, upbranchingresult->

- lpobjval);

( downbranchingresult->

)

downgain = 2 * upgain;

( upbranchingresult->

)

upgain = 2 * downgain;

downgain = downgain/gap;

upgain = upgain/gap;

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

factor = factor * factor;

( !downbranchingresult->

)

downgain =

(downgain, downbranchingresult->

- lpobjval);

( !upbranchingresult->

)

upgain =

(upgain, upbranchingresult->

- lpobjval);

( downbranchingresult->

)

downgain = 2 * upgain;

( upbranchingresult->

)

upgain = 2 * downgain;

downgain = downgain/gap;

upgain = upgain/gap;

scoringfunction;

assert(config !=

);

assert(branchvar !=

);

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

( scoringfunction )

assert(scoringfunction ==

);

assert(lpcand !=

);

printCandidateList(

assert(candidatelist !=

);

assert(scorecontainer !=

);

( i = 0; i < candidatelist->

; i++ )

assert(var !=

);

assert(candidatelist !=

);

assert(scorecontainer !=

);

assert(nbestcandidates <= candidatelist->ncandidates);

( i = 1; i < candidatelist->

; i++ )

assert(movecand !=

);

movescore = scorecontainer->

[moveprobindex];

nsorted =

(i, nbestcandidates);

assert(insertionindex <= nsorted);

( insertionindex != i && insertionindex < nsorted )

( j = insertionindex; j < nsorted; j++ )

assert(oldcand !=

);

candidatelist->

[j] = reordercand;

reordercand = oldcand;

candidatelist->

[i] = reordercand;

, candidatelist->

, nbestcandidates);

printCandidateList(

, candidatelist, scorecontainer);

assert(branchvar !=

);

size =

(downsize, upsize);

size >= reliable;

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

nunscoredcandidates = 0;

* candidateunscored;

assert(config !=

);

assert(status !=

);

assert(allcandidates !=

);

assert(scorecontainer !=

);

( i = 0; i < allcandidates->

; i++ )

assert(lpcand !=

);

assert(branchvar !=

);

candidateunscored[nunscoredcandidates] = i;

nunscoredcandidates++;

( nunscoredcandidates > 0 )

( i = 0; i < nunscoredcandidates; i++ )

candindex = candidateunscored[i];

allcandidates->

, nunscoredcandidates);

(

(

, status, persistent, config, baselpsol, domainreductions, binconsdata, unscoredcandidates,

decision, scorecontainer, level2data, lpobjval, statistics, localstats) );

(

(

, status, persistent, config, baselpsol, domainreductions, binconsdata, unscoredcandidates,

decision, scorecontainer, level2data, lpobjval) );

( i = 0; i < nunscoredcandidates; i++ )

assert(allcandidates->

[candidateunscored[i]] == unscoredcandidates->

[i]);

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

assert(config !=

);

assert(status !=

);

assert(candidatelist !=

);

assert(scorecontainer !=

);

decision, scorecontainer, level2data, lpobjval, statistics, localstats) );

decision, scorecontainer, level2data, lpobjval) );

( i = 1; i < nusedcands; ++i )

( bestmaxgain == 0.0 )

( i = nusedcands - 1; i >= 1; --i )

( i < nusedcands )

candidatelist->

[nusedcands] = tmp;

( i = 1; i < nusedcands; ++i )

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

assert(status !=

);

assert(config !=

);

assert(candidate !=

);

assert(branchingresult !=

);

branchvalfrac = candidate->

;

assert(branchvar !=

);

( binconsdata !=

&& varisbinary )

( downbranching )

assert(negbranchvar !=

);

( level2data !=

)

( result !=

)

statistics->nduplicatelps[probingdepth]++;

,

statistics->nlpssolved[probingdepth]++;

statistics->nlpiterations[probingdepth] += branchingresult->

;

statistics->nlpssolvedfsb[probingdepth]++;

statistics->nlpiterationsfsb[probingdepth] += branchingresult->

;

( branchingresult->

)

, branchingresult->

, localbaselpsolval);

localgain =

(0, branchingresult->

- localbaselpsolval);

( downbranching )

( recursiondepth > 1 && !config->

)

assert(candidatelist !=

);

LOCALSTATISTICS* deeperlocalstats;

( localStatisticsAllocate(

, &deeperlocalstats) );

deeperdecision, scorecontainer, level2data, deeperlpobjval,

statistics, localstats) );

deeperdecision, scorecontainer, level2data, deeperlpobjval) );

( deeperstatus->

)

deeperlocalstats->ncutoffproofnodes = 0;

binconsdata, candidatelist, deeperdecision, scorecontainer, level2data, recursiondepth - 1,

statistics, deeperlocalstats,

,

) );

binconsdata, candidatelist, deeperdecision, scorecontainer, level2data, recursiondepth - 1,

statistics->stopafterfsb[probingdepth+1]++;

( deeperstatus->

)

statistics->cutoffafterfsb[probingdepth+1]++;

( deeperstatus->

)

statistics->domredafterfsb[probingdepth+1]++;

( deeperstatus->

)

localstats->ncutoffproofnodes += deeperlocalstats->ncutoffproofnodes;

, downbranching ?

:

);

localStatisticsFree(

, &deeperlocalstats);

( recursiondepth == 1 && !config->

)

( branchingresult->

)

( binconsdata !=

&& varisbinary )

* ndeepestcutoffs,

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

assert(status !=

);

assert(config !=

);

assert(candidatelist !=

);

assert(decision !=

);

assert(recursiondepth >= 1);

assert(statistics !=

);

( firstscoreptr !=

)

*firstscoreptr = -1.0;

( bestscoreptr !=

)

*bestscoreptr = -1.0;

assert(probingdepth >= 0 && probingdepth < config->recursiondepth);

decision->

= lpobjval;

decision->

= lpobjval;

decision->

= 0.0;

assert(downbranchingresult !=

);

assert(upbranchingresult !=

);

stopafterinfeasible = !stopafterinfeasible;

( i = 0, c = start;

assert(candidate !=

);

assert(branchvar !=

);

statistics->npropdomred[probingdepth]++;

localstats->ncutoffproofnodes = 0;

useoldbranching =

;

statistics->noldbranchusedfsb[probingdepth]++;

statistics->noldbranchused[probingdepth]++;

( k = 0; k < 2; ++k )

localdomainreductions = down ? downdomainreductions : updomainreductions;

localbranchingresult = down ? downbranchingresult : upbranchingresult;

otherbranchingresult = down ? upbranchingresult : downbranchingresult;

recursiondepth, localdomainreductions, binconsdata, level2data, localbranchingresult, scorecontainer,

down, statistics, localstats) );

recursiondepth, localdomainreductions, binconsdata, level2data, localbranchingresult, scorecontainer,

,

down ?

:

, down ?

:

);

( stopafterinfeasible && k == 0 && localbranchingresult->

)

, downbranchingresult->

,

( niterations !=

)

( persistent !=

&& !upbranchingresult->

&& !downbranchingresult->

&& (config->

|| probingdepth == 0) )

upbranchingresult, lpobjval) );

( ndeepestcutoffs !=

)

( ndeepestnodes !=

)

scoringlpobjval = useoldbranching ? oldlpobjval : lpobjval;

scoringlpobjval, baselpobjval);

( i == 0 && firstscoreptr !=

)

*firstscoreptr = score;

assert(totalgains !=

);

assert(ntotalgains !=

);

*bestgain =

(*bestgain, score);

( !downbranchingresult->

&& !upbranchingresult->

)

(*totalgains) += score;

statistics->nfullcutoffs[probingdepth]++;

localstats->ncutoffproofnodes += 2;

assert(localstats->ncutoffproofnodes == 0 || localstats->ncutoffproofnodes == 2);

2 + localstats->ncutoffproofnodes,

);

statistics->nsinglecutoffs[probingdepth]++;

assert(localstats->ncutoffproofnodes == 0 || localstats->ncutoffproofnodes == 2);

2 + localstats->ncutoffproofnodes,

);

statistics->nsinglecutoffs[probingdepth]++;

maxstoredomreds = INT_MAX;

assert(downdomainreductions !=

);

updomainreductions);

( upbranchingresult->

&& !downbranchingresult->

)

( downbranchingresult->

&& !upbranchingresult->

)

bestscoringlpobjval, baselpobjval);

( newscore > bestscore )

bestscore = newscore;

( bestscoreptr !=

)

*bestscoreptr = newscore;

decision->

= newscore;

( bestscoreptr !=

)

*bestscoreptr = score;

decision->

= score;

assert(downdomainreductions !=

);

bestscorelowerbound = branchlb;

bestscoreupperbound = branchub;

bestscoringlpobjval = scoringlpobjval;

assert(!

(

, bestscorelowerbound, bestscoreupperbound));

, c, nlpcands,

(branchvar), branchval,

(downbranchingresult->

- scoringlpobjval, 0),

(downbranchingresult->

- scoringlpobjval, 0),

(upbranchingresult->

- scoringlpobjval, 0),

(upbranchingresult->

- scoringlpobjval, 0),

assert(scorecontainer !=

);

downbranchingresult->

- scoringlpobjval, upbranchingresult->

- scoringlpobjval) );

( probingdepth == 0 && (binconsdata !=

|| domainreductions !=

) && !useoldbranching

( binconsdata !=

)

assert(binconsdata !=

);

( domainreductions !=

)

assert(domainreductions !=

);

statistics->npropdomred[probingdepth]++;

( updomainreductions !=

)

assert(downdomainreductions !=

);

assert(config !=

);

#ifdef SCIP_STATISTIC

,STATISTICS* statistics

,LOCALSTATISTICS* localstats

chosencandnr = -1;

assert(config !=

);

assert(status !=

);

assert(decision !=

);

assert(candidatelist !=

);

assert(statistics !=

);

assert(recursiondepth > 0);

statistics->ndepthreached++;

decision->

= lpobjval;

decision->

= lpobjval;

statistics->nsinglecandidate++;

decision, scorecontainer, level2data, lpobjval,

statistics, localstats) );

decision, scorecontainer, level2data, lpobjval) );

decision->

= lpobjval;

decision->

= lpobjval;

statistics->nsingleafterfilter++;

decision, scorecontainer, level2data, recursiondepth, lpobjval, lpobjval,

,

,

,

,

,

,

statistics, localstats, &firstscore, &bestscore) );

decision, scorecontainer, level2data, recursiondepth, lpobjval, lpobjval,

,

,

,

,

,

) );

( level2data !=

)

assert(candidatelist->

<= statistics->maxnbestcands);

( chosencandnr = 0; chosencandnr < candidatelist->

; ++chosencandnr )

assert(chosencandnr < candidatelist->ncandidates);

probingdepth = 0;

statistics->stopafterfsb[probingdepth]++;

statistics->cutoffafterfsb[probingdepth]++;

statistics->domredafterfsb[probingdepth]++;

( domainreductions !=

)

&status->

, statistics) );

( binconsdata !=

)

statistics->nsingleafterfilter--;

statistics->nsingleafterfilter--;

( status->

)

( chosencandnr >= 0 )

++statistics->chosenfsbcand[chosencandnr];

bestscore, firstscore);

assert(!performedlab);

( baselpsol !=

)

assert(branchruledata !=

);

persistent = branchruledata->persistent;

assert(persistent !=

);

,

assert(branchruledata !=

);

assert(result !=

);

assert(branchruledata->config !=

);

assert(branchruledata->persistent !=

);

assert(branchruledata->persistent->olddecision !=

);

(branchruledata->persistent->olddecision->branchvar));

branchruledata->persistent->olddecision->branchvar =

;

assert(branchruledata !=

);

persistent = branchruledata->persistent;

assert(persistent !=

);

nvars = persistent->

;

( i = nvars - 1; i >= 0; i--)

branchruledata->isinitialized =

;

assert(branchruledata !=

);

( branchruledata->isinitialized &&

( branchruledata->isinitialized )

branchruledata->persistent->nvars = nvars;

branchruledata->persistent->oldntotalnodes = -1;

branchruledata->persistent->oldnnodelpiterations = -1;

branchruledata->persistent->oldnnodelps = -1;

( i = 0; i < nvars; i++ )

branchruledata->persistent->lastbranchid[i] = -1;

branchruledata->persistent->lastbranchnlps[i] = 0;

branchruledata->isinitialized =

;

assert(branchrule !=

);

assert(branchruledata !=

);

assert(branchruledata->config !=

);

assert(branchruledata->persistent !=

);

assert(branchrule !=

);

assert(branchruledata !=

);

assert(branchruledata->persistent !=

);

branchruledata->persistent->restartindex = 0;

recursiondepth = branchruledata->config->recursiondepth;

maxncands = branchruledata->config->maxncands;

branchruledata->statistics->recursiondepth = recursiondepth;

branchruledata->statistics->maxnbestcands = maxncands;

statisticsInit(branchruledata->statistics);

STATISTICS* statistics;

assert(branchruledata !=

);

statistics = branchruledata->statistics;

assert(statistics !=

);

statisticsPrint(

, statistics);

assert(branchruledata !=

);

( branchruledata->isinitialized )

assert(branchrule !=

);

assert(result !=

);

assert(branchruledata !=

);

config = branchruledata->config;

branchruledata->statistics->noldcandidate++;

LOCALSTATISTICS* localstats;

scorecontainer, candidatelist, branchruledata->statistics, localstats) );

scorecontainer, candidatelist) );

branchruledata->statistics->ncutoffproofnodes += localstats->ncutoffproofnodes;

( status->

)

++branchruledata->statistics->nlperrorcalls;

++branchruledata->statistics->nlimitcalls;

);

);

localStatisticsFree(

, &localstats);

( scorecontainer !=

)

assert(*result >= 1);

assert(*result <= MAXRESULT);

branchruledata->statistics->ntotalresults++;

branchruledata->statistics->nresults[*result]++;

sum = branchruledata->statistics->nsinglecandidate + branchruledata->statistics->nsingleafterfilter

+ branchruledata->statistics->noldcandidate + branchruledata->statistics->nlperrorcalls

+ branchruledata->statistics->nlimitcalls;

( i = 0; i < branchruledata->statistics->maxnbestcands; i++ )

sum += branchruledata->statistics->chosenfsbcand[i];

( sum != branchruledata->statistics->nresults[

] )

printf(

,

branchruledata->statistics->nsinglecandidate, branchruledata->statistics->nsingleafterfilter,

branchruledata->statistics->noldcandidate,

branchruledata->statistics->nlperrorcalls, branchruledata->statistics->nlimitcalls);

assert(sum == branchruledata->statistics->nresults[

]);

branchruledata->statistics->ncutoffproofnodes, branchruledata->statistics->ndomredproofnodes);

branchruledata->persistent->restartindex = 0;

branchruledata->isinitialized =

;

branchruledata->config->inscoring =

;

assert(branchrule !=

);

,

,

,

,

\

,

\

,

\

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

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_DECL_BRANCHFREE(branchFreeLookahead)

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_DECL_BRANCHINIT(branchInitLookahead)

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)

static SCIP_DECL_BRANCHEXIT(branchExitLookahead)

#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_DECL_BRANCHEXECLP(branchExeclpLookahead)

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_DECL_BRANCHCOPY(branchCopyLookahead)

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 SCIP_DECL_BRANCHEXITSOL(branchExitSolLookahead)

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 SCIPsetBranchruleExit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXIT((*branchexit)))

SCIP_RETCODE SCIPsetBranchruleExecLp(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXECLP((*branchexeclp)))

SCIP_RETCODE SCIPsetBranchruleCopy(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHCOPY((*branchcopy)))

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 SCIPsetBranchruleFree(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHFREE((*branchfree)))

SCIP_RETCODE SCIPsetBranchruleExitsol(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHEXITSOL((*branchexitsol)))

SCIP_RETCODE SCIPsetBranchruleInit(SCIP *scip, SCIP_BRANCHRULE *branchrule, SCIP_DECL_BRANCHINIT((*branchinit)))

void SCIPbranchruleSetData(SCIP_BRANCHRULE *branchrule, SCIP_BRANCHRULEDATA *branchruledata)

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 SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)

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,...)

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

struct SCIP_BranchruleData SCIP_BRANCHRULEDATA

@ 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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4