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

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

SCIP Doxygen Documentation: conflict_graphanalysis.c Source File

FILE* confgraphfile =

;

confgraphnconflictsets = 0;

confgraphWriteNode(

* nodetype,

* fillcolor,

* bordercolor

assert(confgraphfile !=

);

(confgraphfile, (

)(

) idptr, label, nodetype, fillcolor, bordercolor);

(confgraphfile, (

)(

)idptr, label, nodetype, fillcolor, bordercolor);

confgraphWriteEdge(

assert(confgraphfile !=

);

(confgraphfile, (

)(

)source, (

)(

)target, color);

(confgraphfile, (

)(

)source, (

)(

)target,

, color);

(confgraphfile, (

)(

)source, (

)(

)target,

, color);

assert(conflict !=

);

assert(confgraphfile ==

);

confgraphfile = fopen(fname,

);

( confgraphfile ==

)

confgraphWriteNode(

,

,

,

,

);

confgraphcurrentbdchginfo =

;

( confgraphfile !=

)

fclose(confgraphfile);

confgraphfile =

;

confgraphnconflictsets = 0;

confgraphAddBdchg(

* colors[] = {

confgraphWriteNode(bdchginfo, label,

, colors[col],

);

confgraphWriteEdge(bdchginfo, confgraphcurrentbdchginfo,

);

confgraphLinkBdchg(

confgraphWriteEdge(bdchginfo, confgraphcurrentbdchginfo,

);

confgraphSetCurrentBdchg(

confgraphcurrentbdchginfo = bdchginfo;

confgraphMarkConflictset(

assert(conflictset !=

);

confgraphnconflictsets++;

confgraphWriteNode((

*)(

)confgraphnconflictsets, label,

,

,

);

confgraphWriteEdge((

*)(

)confgraphnconflictsets, conflictset->

[i],

);

assert(conflictset !=

);

assert(num <= conflictset->bdchginfossize);

assert(conflictset !=

);

assert(bdchginfo !=

);

assert(idx < INT_MAX/2);

assert((

)boundtype == 0 || (

)boundtype == 1);

sortval = 2*idx + (int)boundtype;

assert(pos == conflictset->

- 1 || sortval < sortvals[pos+1]);

( pos > 0 && sortval == sortvals[pos-1] )

relaxedbds[pos-1] = boundtype ==

?

(relaxedbds[pos-1], relaxedbd) :

(relaxedbds[pos-1], relaxedbd);

assert(conflictset !=

);

( depth > maxdepth[0] )

maxdepth[1] = maxdepth[0];

( depth > maxdepth[1] )

assert(maxdepth[0] >= maxdepth[1]);

assert(conflictset !=

);

assert(tree !=

);

assert(currentdepth == tree->

-1);

depth =

(depth, currentdepth+1);

branchingincluded[depth] =

;

assert(conflictset1 !=

);

assert(conflictset2 !=

);

assert(i2 == 0 || conflictset2->

[i2-1] < conflictset2->

[i2]);

sortval = conflictset2->

[i2];

assert(i1 == 0 || conflictset1->

[i1-1] < conflictset1->

[i1]);

conflictsetPrint(

assert(conflictset !=

);

assert(conflictset !=

);

assert(bdchginfos !=

);

assert(relaxedbds !=

);

( v = conflictset->

- 1; v >= 0; --v )

assert(var !=

);

= relaxedbds[v];

assert(prob !=

);

assert(conflictset !=

);

assert(nbdchgs !=

);

assert(nredvars !=

);

assert(bdchginfos !=

);

assert(relaxedbds !=

);

assert(sortvals !=

);

( v = nbdchginfos - 1; v >= 0; --v )

= relaxedbds[v];

+= (isupper ? -1.0 : +1.0);

bdchginfos[v] = bdchginfos[nbdchginfos - 1];

relaxedbds[v] = relaxedbds[nbdchginfos - 1];

sortvals[v] = sortvals[nbdchginfos - 1];

assert(ntrivialredvars + nbdchginfos == conflictset->

);

(

,

, ntrivialredvars, conflictset->

, (

*)conflictset);

*nredvars = ntrivialredvars;

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

bounds[v] = relaxedbds[v];

( !boundtypes[v] )

bounds[v] += ((!boundtypes[v]) ? +1.0 : -1.0);

( nbinimpls[v] == 0 )

( v == nbdchginfos && ((!

->conf_fullshortenconflict && nzeroimpls < 2) || (

->conf_fullshortenconflict && nzeroimpls < nbdchginfos)) )

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

( v < nbdchginfos - 1 )

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

nbdchgs, redundant, &glbinfeas,

->conf_fullshortenconflict) );

(

,

, (

*) conflictset);

(

,

, (

*) conflictset, *nbdchgs);

(

,

, (

*)conflictset);

( *nredvars > 0 )

assert(bdchginfos == conflictset->

);

assert(relaxedbds == conflictset->

);

assert(sortvals == conflictset->

);

( v = nbdchginfos - 1; v >= 0; --v )

bdchginfos[v] = bdchginfos[nbdchginfos - 1];

relaxedbds[v] = relaxedbds[nbdchginfos - 1];

sortvals[v] = sortvals[nbdchginfos - 1];

assert((*nredvars) + nbdchginfos == conflictset->

);

(

,

, (*nredvars), conflictset->

, (

*)conflictset);

conflictset->nbdchginfos = nbdchginfos;

*nredvars += ntrivialredvars;

assert(conflictset !=

);

assert(conflictset !=

);

(*conflictset)->bdchginfos =

;

(*conflictset)->relaxedbds =

;

(*conflictset)->sortvals =

;

(*conflictset)->bdchginfossize = 0;

nadditionalelems

assert(targetconflictset !=

);

assert(sourceconflictset !=

);

targetsize = sourceconflictset->

+ nadditionalelems;

(*targetconflictset)->bdchginfossize = targetsize;

(*targetconflictset)->nbdchginfos = sourceconflictset->

;

(*targetconflictset)->validdepth = sourceconflictset->

;

(*targetconflictset)->insertdepth = sourceconflictset->

;

(*targetconflictset)->conflictdepth = sourceconflictset->

;

(*targetconflictset)->repropdepth = sourceconflictset->

;

(*targetconflictset)->usescutoffbound = sourceconflictset->

;

(*targetconflictset)->hasrelaxonlyvar = sourceconflictset->

;

(*targetconflictset)->conflicttype = sourceconflictset->

;

assert(conflictset !=

);

assert(*conflictset !=

);

assert(conflictset !=

);

assert(paramdata !=

);

assert(conflicthdlr !=

);

( conflicthdlr->conflictcopy !=

)

( conflicthdlr->conflictcopy(

->scip, conflicthdlr) );

assert(conflicthdlr !=

);

assert(name !=

);

assert(desc !=

);

(*conflicthdlr)->priority = priority;

(*conflicthdlr)->conflictcopy = conflictcopy;

(*conflicthdlr)->conflictfree = conflictfree;

(*conflicthdlr)->conflictinit = conflictinit;

(*conflicthdlr)->conflictexit = conflictexit;

(*conflicthdlr)->conflictinitsol = conflictinitsol;

(*conflicthdlr)->conflictexitsol = conflictexitsol;

(*conflicthdlr)->conflictexec = conflictexec;

(*conflicthdlr)->conflicthdlrdata = conflicthdlrdata;

(*conflicthdlr)->initialized =

;

priority, INT_MIN, INT_MAX, paramChgdConflicthdlrPriority, (

*)(*conflicthdlr)) );

assert(conflicthdlr !=

);

assert(name !=

);

assert(desc !=

);

conflictcopy, conflictfree, conflictinit, conflictexit, conflictinitsol, conflictexitsol, conflictexec,

assert(conflicthdlr !=

);

( *conflicthdlr ==

)

assert(!(*conflicthdlr)->initialized);

( (*conflicthdlr)->conflictfree !=

)

( (*conflicthdlr)->conflictfree(

->scip, *conflicthdlr) );

assert(conflicthdlr !=

);

(

->misc_resetstat )

( conflicthdlr->conflictinit !=

)

( conflicthdlr->conflictinit(

->scip, conflicthdlr) );

assert(conflicthdlr !=

);

( conflicthdlr->conflictexit !=

)

( conflicthdlr->conflictexit(

->scip, conflicthdlr) );

assert(conflicthdlr !=

);

( conflicthdlr->conflictinitsol !=

)

( conflicthdlr->conflictinitsol(

->scip, conflicthdlr) );

assert(conflicthdlr !=

);

( conflicthdlr->conflictexitsol !=

)

( conflicthdlr->conflictexitsol(

->scip, conflicthdlr) );

assert(conflicthdlr !=

);

assert(bdchginfos !=

|| nbdchginfos == 0);

assert(result !=

);

( conflicthdlr->conflictexec !=

)

( conflicthdlr->conflictexec(

->scip, conflicthdlr, node, validnode, bdchginfos, relaxedbds, nbdchginfos,

->conf_removable, resolved, result) );

(

,

conflicthdlr->

, *result);

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

conflicthdlr->conflictcopy = conflictcopy;

assert(conflicthdlr !=

);

conflicthdlr->conflictfree = conflictfree;

assert(conflicthdlr !=

);

conflicthdlr->conflictinit = conflictinit;

assert(conflicthdlr !=

);

conflicthdlr->conflictexit = conflictexit;

assert(conflicthdlr !=

);

conflicthdlr->conflictinitsol = conflictinitsol;

assert(conflicthdlr !=

);

conflicthdlr->conflictexitsol = conflictexitsol;

assert(conflicthdlr !=

);

conflicthdlr->

;

assert(conflicthdlr !=

);

conflicthdlr->

;

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

conflicthdlr->

= priority;

->conflicthdlrssorted =

;

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

assert(conflicthdlr !=

);

( !

->conf_enable || !

->conf_useprop )

(

->nconflicthdlrs == 0 )

assert(conflict !=

);

assert(num <= conflict->tmpbdchginfossize);

assert(conflict !=

);

var, boundtype, oldbound, newbound) );

assert(conflict !=

);

assert(var !=

);

assert(stat !=

);

( insertdepth > 0 )

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

assert(stat !=

);

assert(conflict !=

);

assert(tree !=

);

assert(conflictset !=

);

assert(conflictset->

<= insertdepth);

assert(success !=

);

(

(

, transprob, stat, tree, blkmem, origprob, reopt, lp, conflictset, &nbdchgs, &nredvars, &redundant) );

(

,

, nredvars, oldnbdchginfos, conflictset->

);

(

,

,

conflictsetPrint(conflictset);

assert(var !=

);

reopt, lp, branchcand, eventqueue, cliquetable, var,

, boundtype,

) );

(

= 0;

<

->nconflicthdlrs; ++

)

(

,

,

assert(prob !=

);

maxsize =

(maxsize,

->conf_minmaxvars);

assert(conflict !=

);

assert(stat !=

);

assert(transprob !=

);

assert(tree !=

);

nconflictsetsused;

maxconflictsets;

maxconflictsets = (

->conf_maxconss == -1 ? INT_MAX :

->conf_maxconss);

assert(focusdepth <= currentdepth);

assert(currentdepth == tree->

-1);

(

,

,

conflict->

, focusdepth, maxconflictsets, maxsize);

nconflictsetsused = 0;

cutoffdepth = INT_MAX;

repropdepth = INT_MAX;

repropconflictset =

;

( i = 0; i < conflict->

&& nconflictsetsused < maxconflictsets; ++i )

assert(conflictset !=

);

(

,

,

(

,

,

repropconflictset = conflictset;

branchcand, eventqueue, cliquetable, conflictset, conflictset->

, &success) );

(

,

,

reopt, lp, blkmem) );

(

,

,

(conflictsetPrint(conflictset));

repropconflictset =

;

nconflictsetsused++;

(

->conf_repropagate && repropdepth < cutoffdepth && repropdepth < tree->pathlen )

assert(0 <= repropdepth && repropdepth < tree->pathlen);

assert((

) tree->

[repropdepth]->

== repropdepth);

( repropconflictset !=

)

assert(repropconflictset->

== repropdepth);

branchcand, eventqueue, cliquetable, repropconflictset, repropdepth, &success) );

(

,

,

focusdepth, repropconflictset->

);

origprob, reopt, lp, blkmem) );

(

,

,

(conflictsetPrint(repropconflictset));

(

,

,

(

*)tree->

[repropdepth], repropdepth, focusdepth);

assert(conflict !=

);

assert(num <= conflict->conflictsetssize);

assert(conflict !=

);

assert(conflictset !=

);

assert(*conflictset !=

);

assert((*conflictset)->validdepth <= (*conflictset)->insertdepth);

assert(

->conf_allowlocal || (*conflictset)->validdepth == 0);

(

->conf_repropagate )

(*conflictset)->insertdepth =

((*conflictset)->insertdepth, (*conflictset)->repropdepth);

(*conflictset)->repropdepth = INT_MAX;

assert((*conflictset)->insertdepth <= (*conflictset)->repropdepth);

(

,

,

(*conflictset)->validdepth, (*conflictset)->insertdepth, (*conflictset)->conflictdepth, (*conflictset)->repropdepth);

(conflictsetPrint(*conflictset));

( i = pos+1, j = pos+1; i < conflict->

; ++i )

assert(j <= conflict->nconflictsets);

confgraphMarkConflictset(*conflictset);

*conflictset =

;

assert(conflict !=

);

assert(var !=

);

(

,

,

(

,

,

assert(conflict !=

);

(

,

,

( bdchginfo != confgraphcurrentbdchginfo )

confgraphAddBdchg(bdchginfo);

confgraphLinkBdchg(bdchginfo);

assert(conflict !=

);

assert(bdchginfo !=

);

confgraphAddBdchg(bdchginfo);

confgraphLinkBdchg(bdchginfo);

assert(bdchginfo !=

);

(

,

,

* lbchginfoposs,

* ubchginfoposs,

* nreconvliterals

assert(prob !=

);

assert(lbchginfoposs !=

);

assert(ubchginfoposs !=

);

assert(nconss !=

);

assert(nliterals !=

);

assert(nreconvconss !=

);

assert(nreconvliterals !=

);

*nreconvliterals = 0;

vars = prob->

;

nvars = prob->

;

assert(nvars == 0 || vars !=

);

( v = 0; v < nvars && nbdchgs < maxsize; ++v )

assert(var !=

);

assert(-1 <= lbchginfoposs[v] && lbchginfoposs[v] <= var->

);

assert(-1 <= ubchginfoposs[v] && ubchginfoposs[v] <= var->

);

( lbchginfoposs[v] >= 0 )

( ubchginfoposs[v] >= 0 )

(

(conflict, blkmem,

, stat, prob, tree, diving, 0,

, nconss, nliterals, \

nreconvconss, nreconvliterals) );

assert(bdchginfo !=

);

assert(var !=

);

confnbdchginfos;

assert(conflict !=

);

assert(conflictset !=

);

assert(blkmem !=

);

assert(bdchginfos !=

|| nbdchginfos == 0);

( nbdchginfos == 0 )

assert(bdchginfos !=

);

( nbdchginfos == 1 )

bdchginfo = bdchginfos[0];

assert(bdchginfo !=

);

confsortvals = conflictset->

;

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

bdchginfo = bdchginfos[i];

assert(bdchginfo !=

);

assert(idx < INT_MAX/2);

assert((

)boundtype == 0 || (

)boundtype == 1);

sortval = 2*idx + (int)boundtype;

confbdchginfos[confnbdchginfos] = bdchginfo;

confsortvals[confnbdchginfos] = sortval;

assert(confnbdchginfos <= conflictset->nbdchginfos + nbdchginfos);

( confnbdchginfos > conflictset->

)

(confsortvals, (

**)confbdchginfos, confrelaxedbds, confnbdchginfos);

( i < confnbdchginfos )

( confsortvals[k] == confsortvals[i] )

confbdchginfos[k] = confbdchginfos[i];

confrelaxedbds[k] = confrelaxedbds[i];

confsortvals[k] = confsortvals[i];

assert(confsortvals[k] == confsortvals[i]);

confrelaxedbds[k] = (confsortvals[k] % 2 == 0) ?

(confrelaxedbds[k], confrelaxedbds[i]) :

(confrelaxedbds[k], confrelaxedbds[i]);

confbdchginfos[k] = confbdchginfos[i];

confrelaxedbds[k] = confrelaxedbds[i];

confsortvals[k] = confsortvals[i];

assert(k + 1 <= confnbdchginfos);

assert(conflict !=

);

confgraphSetCurrentBdchg(bdchginfo);

assert(conflict !=

);

assert(conflict !=

);

assert(stat !=

);

assert(tree !=

);

assert(success !=

);

assert(nliterals !=

);

( !

->conf_allowlocal && validdepth > 0 )

assert(currentdepth == tree->

-1);

assert(focusdepth <= currentdepth);

assert(0 <= validdepth && validdepth <= currentdepth);

(

,

, nbdchginfos);

(

,

,

( !

->conf_settlelocal )

nforcedbdchgqueue;

assert(conflict !=

);

assert(conflict !=

);

assert(resolved !=

);

assert(actvar !=

);

(

,

,

assert(infercons !=

);

assert(infervar !=

);

(

,

,

( actvar != infervar )

assert(var == actvar);

relaxedbd *= scalar;

relaxedbd += constant;

( inferprop !=

)

assert(infervar !=

);

(

,

,

assert(!(*resolved));

assert((*resolved) || (nforcedbdchgqueue == 0 && nbdchgqueue == 0));

assert(conflict !=

);

assert(conflict !=

);

assert(stat !=

);

assert(prob !=

);

conflict->

++;

( conflict->

== 0 )

conflict->

= 1;

assert(0.0 <

->conf_scorefac &&

->conf_scorefac <= 1.0);

( v = 0; v < prob->

; ++v )

(*bound) -= constant;

assert(bdchginfo !=

);

* nreconvliterals

assert(conflict !=

);

assert(firstuip !=

);

assert(nreconvconss !=

);

assert(nreconvliterals !=

);

assert(currentdepth == tree->

-1);

assert(focusdepth <= currentdepth);

maxvaliddepth = (

->conf_allowlocal ?

(currentdepth-1, focusdepth) : 0);

( validdepth > maxvaliddepth )

(

,

,

( bdchginfo !=

&& validdepth <= maxvaliddepth )

assert(bdchginfo !=

);

assert(bdchgdepth <= firstuipdepth);

( bdchgdepth > validdepth && bdchginfo != nextbdchginfo )

assert(actvar !=

);

( bdchginfo == uip

|| (bdchgdepth == firstuipdepth

&& nextbdchginfo !=

( forceresolve )

assert(bdchgdepth >= validdepth);

validdepth = bdchgdepth;

(

,

,

( bdchginfo != uip )

assert(nextuip ==

);

nextuip = bdchginfo;

assert(nextuip != uip);

( nextuip !=

&& nresolutions >= 2 && bdchginfo ==

&& validdepth <= maxvaliddepth )

(

,

,

(*nreconvliterals) += nlits;

* nreconvliterals

lastconsnresolutions;

lastconsresoldepth;

assert(conflict !=

);

assert(stat !=

);

assert(nconss !=

);

assert(nliterals !=

);

assert(nreconvconss !=

);

assert(nreconvliterals !=

);

assert(currentdepth == tree->

-1);

assert(focusdepth <= currentdepth);

resolvedepth = ((

->conf_fuiplevels >= 0 &&

->conf_fuiplevels <= currentdepth)

? currentdepth -

->conf_fuiplevels + 1 : 0);

assert(0 <= resolvedepth && resolvedepth <= currentdepth + 1);

resolvedepth =

(resolvedepth, currentdepth);

(

,

,

*nreconvliterals = 0;

maxvaliddepth = (

->conf_allowlocal ?

(currentdepth-1, focusdepth) : 0);

( validdepth > maxvaliddepth )

lastconsnresolutions = (mustresolve ? 0 : -1);

lastconsresoldepth = (mustresolve ? currentdepth : INT_MAX);

( bdchginfo !=

&& validdepth <= maxvaliddepth )

assert(0 <= bdchgdepth && bdchgdepth <= currentdepth);

assert(bdchgdepth < tree->pathlen);

assert(tree->

[bdchgdepth] !=

);

assert(nresolutions >= lastconsnresolutions);

( !forceresolve )

( nresolutions == lastconsnresolutions )

lastconsresoldepth = bdchgdepth;

( bdchgdepth < lastconsresoldepth && (

->conf_interconss == -1 || *nconss < set->conf_interconss) )

(

,

,

lastconsnresolutions = nresolutions;

lastconsresoldepth = bdchgdepth;

(*nliterals) += nlits;

assert(bdchginfo !=

);

( bdchgdepth > validdepth && bdchginfo != nextbdchginfo )

assert(actvar !=

);

( (mustresolve && nresolutions == 0)

|| (bdchgdepth >= resolvedepth

&& nextbdchginfo !=

( forceresolve )

assert(bdchgdepth >= validdepth);

validdepth = bdchgdepth;

(

,

,

assert(nfirstuips < 2*(currentdepth+1));

firstuips[nfirstuips] = bdchginfo;

( bdchginfo ==

&& nresolutions > lastconsnresolutions

&& validdepth <= maxvaliddepth

(*nliterals) += nlits;

(

->conf_reconvlevels != 0 && validdepth <= maxvaliddepth )

reconvlevels = (

->conf_reconvlevels == -1 ? INT_MAX :

->conf_reconvlevels);

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

validdepth, firstuips[i], nreconvconss, nreconvliterals) );

score =

->conf_proofscorefac * (1.0 - proofactdelta/(prooflhs - proofact));

score =

(score, 0.0);

( proofcoef > 0.0 )

score +=

->conf_uplockscorefac

score +=

->conf_downlockscorefac

assert(cands !=

);

assert(candssize !=

);

( num > *candssize )

*candssize = newsize;

assert(num <= *candssize);

assert(var !=

);

assert(lbchginfopos !=

);

assert(ubchginfopos !=

);

assert(-1 <= *lbchginfopos && *lbchginfopos <= var->nlbchginfos);

assert(-1 <= *ubchginfopos && *ubchginfopos <= var->nubchginfos);

assert(*lbchginfopos == -1 || *lbchginfopos == var->

assert(*ubchginfopos == -1 || *ubchginfopos == var->

( *lbchginfopos >= 0 && *lbchginfopos < var->nlbchginfos && var->

[*lbchginfopos].

)

( *ubchginfopos >= 0 && *ubchginfopos < var->nubchginfos && var->

[*ubchginfopos].

)

assert(conflict !=

);

assert(stat !=

);

assert(var !=

);

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

( bdchginfo ==

)

assert(conflict !=

);

assert(stat !=

);

assert(var !=

);

( bdchginfo ==

)

nbdchgs = (int) bdchginfo->

;

assert(nbdchgs >= 0);

(

->conf_ignorerelaxedbd )

relaxedbd =

(relaxedbd, newbound);

( nbdchgs > 0 )

(

,

,

relaxedbd =

(relaxedbd, newbound);

( nbdchgs > 0 )

(

,

,

assert(var !=

);

( boundtype )

assert(newlb <= newub);

assert(oldlpbdchgs !=

);

assert(relaxedlpbdchgs !=

);

( !relaxedlpbdchgs->

[c] )

idx = relaxedlpbdchgs->

;

assert(relaxedlpbdchgs->

[idx] == c);

assert(relaxedlpbdchgs->

[idx] >= newlb ||

assert(relaxedlpbdchgs->

[idx] <= newub ||

assert(var !=

);

assert(-1 <= lbchginfopos && lbchginfopos <= var->nlbchginfos);

assert(-1 <= ubchginfopos && ubchginfopos <= var->nubchginfos);

assert(cands !=

);

assert(candscores !=

);

assert(newbounds !=

);

assert(proofactdeltas !=

);

assert(candssize !=

);

assert(ncands !=

);

assert(*ncands <= *candssize);

assert(0 <= firstcand && firstcand <= *ncands);

( proofcoef > 0.0 )

assert(ubchginfopos >= 0);

depth = currentdepth+1;

resolvable =

;

assert(lbchginfopos >= 0);

depth = currentdepth+1;

resolvable =

;

assert(*cands !=

);

assert(*candscores !=

);

assert(*newbounds !=

);

assert(*proofactdeltas !=

);

(

,

,

proofcoef, depth, resolvable,

(proofactdelta), score);

( i = *ncands; i > firstcand && score > (*candscores)[i-1]; --i )

(*cands)[i] = (*cands)[i-1];

(*candscores)[i] = (*candscores)[i-1];

(*newbounds)[i] = (*newbounds)[i-1];

(*proofactdeltas)[i] = (*proofactdeltas)[i-1];

(*candscores)[i] = score;

(*newbounds)[i] = newbound;

(*proofactdeltas)[i] =

(proofactdelta);

* lbchginfoposs,

* ubchginfoposs,

assert(prob !=

);

assert(proofcoefs !=

);

assert(curvarlbs !=

);

assert(curvarubs !=

);

assert(lbchginfoposs !=

);

assert(ubchginfoposs !=

);

( resolve !=

)

vars = prob->

;

nvars = prob->

;

assert(nvars == 0 || vars !=

);

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

( (lbchginfoposs[v] == -1 && ubchginfoposs[v] == -1) )

proofcoefs[v] = 0.0;

( lbchginfoposs[v] >= 0 )

(

,

,

proofcoefs[v], prooflhs, (*proofact));

lbchginfoposs[v] = -1;

( ubchginfoposs[v] >= 0 )

(

,

,

proofcoefs[v], prooflhs, (*proofact));

ubchginfoposs[v] = -1;

( relaxed && oldlpbdchgs !=

)

(

(

, var, curvarlbs[v], curvarubs[v], oldlpbdchgs, relaxedlpbdchgs, lpi) );

( lbchginfoposs[v] >= 0 || ubchginfoposs[v] >= 0 )

(

(

, currentdepth, var, lbchginfoposs[v], ubchginfoposs[v], proofcoefs[v],

prooflhs, (*proofact), &cands, &candscores, &newbounds, &proofactdeltas, &candssize, &ncands, 0) );

proofcoefs[v] = 0.0;

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

assert(proofactdeltas[i] > 0.0);

assert(0 <= v && v < nvars);

assert((lbchginfoposs[v] >= 0) != (ubchginfoposs[v] >= 0));

(

,

,

proofcoefs[v] > 0.0 ? curvarlbs[v] : newbounds[i],

proofcoefs[v] > 0.0 ? newbounds[i] : curvarubs[v],

proofcoefs[v], prooflhs, (*proofact), proofactdeltas[i]);

( proofcoefs[v] > 0.0 )

assert(ubchginfoposs[v] >= 0);

assert(lbchginfoposs[v] == -1);

curvarubs[v] = newbounds[i];

assert(lbchginfoposs[v] >= 0);

assert(ubchginfoposs[v] == -1);

curvarlbs[v] = newbounds[i];

( oldlpbdchgs !=

)

(

(

, cands[i], curvarlbs[v], curvarubs[v], oldlpbdchgs, relaxedlpbdchgs, lpi) );

(*proofact) += proofactdeltas[i];

( lbchginfoposs[v] >= 0 || ubchginfoposs[v] >= 0 )

(

(

, currentdepth, cands[i], lbchginfoposs[v], ubchginfoposs[v], proofcoefs[v],

prooflhs, (*proofact), &cands, &candscores, &newbounds, &proofactdeltas, &candssize, &ncands, i+1) );

proofcoefs[v] = 0.0;

* lbchginfoposs,

* ubchginfoposs,

assert(prob !=

);

assert(lp !=

);

assert(curvarlbs !=

);

assert(curvarubs !=

);

assert(lbchginfoposs !=

);

assert(ubchginfoposs !=

);

assert(valid !=

);

assert(resolve !=

);

curvarlbs, curvarubs, lbchginfoposs, ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, resolve, lpi) );

(*lpbdchgs)->nbdchgs = 0;

assert(sidechginds !=

);

assert(sidechgoldlhss !=

);

assert(sidechgoldrhss !=

);

assert(sidechgnewlhss !=

);

assert(sidechgnewrhss !=

);

assert(sidechgssize !=

);

( num > *sidechgssize )

*sidechgssize = newsize;

assert(num <= *sidechgssize);

assert(sidechginds !=

);

assert(sidechgoldlhss !=

);

assert(sidechgoldrhss !=

);

assert(sidechgnewlhss !=

);

assert(sidechgnewrhss !=

);

assert(sidechgssize !=

);

assert(nsidechgs !=

);

sidechgssize, (*nsidechgs)+1) );

assert(*nsidechgs < *sidechgssize);

assert(*sidechginds !=

);

assert(*sidechgoldlhss !=

);

assert(*sidechgoldrhss !=

);

assert(*sidechgnewlhss !=

);

assert(*sidechgnewrhss !=

);

(*sidechgoldlhss)[*nsidechgs] = -lpiinfinity;

(*sidechgnewlhss)[*nsidechgs] = -lpiinfinity;

(*sidechgoldlhss)[*nsidechgs] = lhs - constant;

(*sidechgnewlhss)[*nsidechgs] = -lpiinfinity;

(*sidechgoldrhss)[*nsidechgs] = lpiinfinity;

(*sidechgnewrhss)[*nsidechgs] = lpiinfinity;

(*sidechgoldrhss)[*nsidechgs] = rhs - constant;

(*sidechgnewrhss)[*nsidechgs] = lpiinfinity;

assert(lpbdchgs !=

);

* lbchginfoposs,

* ubchginfoposs,

assert(prob !=

);

assert(lp !=

);

assert(curvarlbs !=

);

assert(curvarubs !=

);

assert(lbchginfoposs !=

);

assert(ubchginfoposs !=

);

assert(valid !=

);

assert(resolve !=

);

lbchginfoposs, ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, resolve, lpi) );

* lbchginfoposs,

* ubchginfoposs,

ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, valid, &resolve, proofcoefs, *prooflhs, proofactivity) );

oldlpbdchgs, relaxedlpbdchgs, valid, &resolve, proofcoefs, *prooflhs, proofactivity) );

solvelp = (

->conf_maxlploops != 0 &&

->conf_lpiterations != 0);

( (*valid) && resolve && solvelp )

maxlploops = (

->conf_maxlploops >= 0 ?

->conf_maxlploops : INT_MAX);

lpiterations = (

->conf_lpiterations >= 0 ?

->conf_lpiterations : INT_MAX);

assert(nrows == 0 || rows !=

);

sidechgssize = nrows;

(

= 0;

< nrows; ++

)

&sidechgnewlhss, &sidechgnewrhss, &sidechgssize, &nsidechgs) );

( nsidechgs > 0 )

globalinfeasible =

;

( (*valid) && resolve && nloops < maxlploops )

assert(!globalinfeasible);

(

,

, nloops, relaxedlpbdchgs->

);

assert(relaxedlpbdchgs->

>= 0);

( relaxedlpbdchgs->

> 0 )

(*iterations) += iter;

curvarlbs, curvarubs, valid) );

(

->conf_useinflp ==

||

->conf_useinflp ==

)

farkasrow, validdepth, curvarlbs, curvarubs,

, &globalinfeasible, dualproofsuccess) );

(*proofactivity) = -(*proofactivity);

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

ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, valid, &resolve, proofcoefs, (*prooflhs), proofactivity) );

curvarlbs, curvarubs, valid) );

(*proofactivity) = -(*proofactivity);

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

ubchginfoposs, oldlpbdchgs, relaxedlpbdchgs, valid, &resolve, proofcoefs, *prooflhs, proofactivity) );

assert(!resolve || (*valid));

assert(!resolve || relaxedlpbdchgs->

> 0);

(

,

,

nloops, iter, relaxedlpbdchgs->

);

(

,

,

nloops, (*valid), oldlpbdchgs->

);

( oldlpbdchgs->

> 0 )

( nsidechgs > 0 )

( oldlpbdchgs->

> 0 || nsidechgs > 0 )

( marklpunsolved )

nreconvliterals;

assert(conflict !=

);

assert(prob !=

);

( success !=

)

(

(conflict, blkmem,

, stat, prob, tree,

, validdepth,

, &nconss, &nliterals, \

&nreconvconss, &nreconvliterals) );

( success !=

)

*success = (nconss > 0);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockEnableOrDisable(SCIP_CLOCK *clck, SCIP_Bool enable)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockReset(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

internal methods for conflict analysis

SCIP_RETCODE SCIPconflictAnalyzeDualProof(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_AGGRROW *proofrow, int validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool initialproof, SCIP_Bool *globalinfeasible, SCIP_Bool *success)

internal methods for dual proof conflict analysis

SCIP_RETCODE SCIPgetFarkasProof(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)

SCIP_RETCODE SCIPgetDualProof(SCIP_SET *set, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_LPI *lpi, SCIP_TREE *tree, SCIP_AGGRROW *farkasrow, SCIP_Real *farkasact, int *validdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, SCIP_Bool *valid)

void SCIPconflictsetFree(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)

static SCIP_Bool conflictsetIsRedundant(SCIP_CONFLICTSET *conflictset1, SCIP_CONFLICTSET *conflictset2)

static SCIP_RETCODE detectImpliedBounds(SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_CONFLICTSET *conflictset, int *nbdchgs, int *nredvars, SCIP_Bool *redundant)

SCIP_RETCODE SCIPconflictFlushConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)

static SCIP_RETCODE ensureSidechgsSize(SCIP_SET *set, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int num)

static SCIP_RETCODE conflictQueueBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_RETCODE undoBdchgsDualsol(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *dualcoefs, SCIP_Real duallhs, SCIP_Real *dualactivity)

static void conflictClear(SCIP_CONFLICT *conflict)

void SCIPconflicthdlrEnableOrDisableClocks(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_Bool enable)

SCIP_RETCODE conflictCreateTmpBdchginfo(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound, SCIP_BDCHGINFO **bdchginfo)

SCIP_RETCODE SCIPconflictAnalyzeRemainingBdchgs(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int *lbchginfoposs, int *ubchginfoposs, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)

static SCIP_RETCODE conflictEnsureTmpbdchginfosMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)

static SCIP_Bool isBoundchgUseless(SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo)

SCIP_RETCODE SCIPconflicthdlrCreate(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)

static void conflictsetCalcConflictDepth(SCIP_CONFLICTSET *conflictset)

SCIP_RETCODE SCIPconflicthdlrExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

static SCIP_Bool bdchginfoIsInvalid(SCIP_CONFLICT *conflict, SCIP_BDCHGINFO *bdchginfo)

static SCIP_Real calcBdchgScore(SCIP_Real prooflhs, SCIP_Real proofact, SCIP_Real proofactdelta, SCIP_Real proofcoef, int depth, int currentdepth, SCIP_VAR *var, SCIP_SET *set)

void SCIPconflicthdlrSetInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINIT((*conflictinit)))

int conflictCalcMaxsize(SCIP_SET *set, SCIP_PROB *prob)

void SCIPconflicthdlrSetPriority(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, int priority)

SCIP_RETCODE SCIPconflictAddBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx)

static SCIP_RETCODE conflictAddConflictCons(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_CONFLICTSET *conflictset, int insertdepth, SCIP_Bool *success)

SCIP_RETCODE SCIPconflicthdlrFree(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set)

SCIP_RETCODE SCIPconflictAnalyze(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, int validdepth, SCIP_Bool *success)

static SCIP_RETCODE undoBdchgsDualfarkas(SCIP_SET *set, SCIP_PROB *prob, SCIP_LP *lp, int currentdepth, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *valid, SCIP_Bool *resolve, SCIP_Real *farkascoefs, SCIP_Real farkaslhs, SCIP_Real *farkasactivity)

static SCIP_RETCODE addCand(SCIP_SET *set, int currentdepth, SCIP_VAR *var, int lbchginfopos, int ubchginfopos, SCIP_Real proofcoef, SCIP_Real prooflhs, SCIP_Real proofact, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int *ncands, int firstcand)

static SCIP_RETCODE addBdchg(SCIP_SET *set, SCIP_VAR *var, SCIP_Real newlb, SCIP_Real newub, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_LPI *lpi)

static SCIP_RETCODE conflictCreateReconvergenceConss(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_BDCHGINFO *firstuip, int *nreconvconss, int *nreconvliterals)

SCIP_RETCODE SCIPconflicthdlrExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

SCIP_Bool SCIPconflictApplicable(SCIP_SET *set)

SCIP_RETCODE SCIPrunBoundHeuristic(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_Real *proofcoefs, SCIP_Real *prooflhs, SCIP_Real *proofactivity, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, int *iterations, SCIP_Bool marklpunsolved, SCIP_Bool *dualproofsuccess, SCIP_Bool *valid)

static SCIP_RETCODE conflictResolveBound(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd, int validdepth, SCIP_Bool *resolved)

static void conflictsetClear(SCIP_CONFLICTSET *conflictset)

SCIP_RETCODE SCIPconflictAddRelaxedBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd)

void SCIPconflicthdlrSetFree(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTFREE((*conflictfree)))

static SCIP_Real conflictsetCalcScore(SCIP_CONFLICTSET *conflictset, SCIP_SET *set)

void SCIPconflicthdlrSetExitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)))

static SCIP_RETCODE conflictAddConflictBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_RETCODE lpbdchgsCreate(SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set, int ncols)

static SCIP_RETCODE doConflicthdlrCreate(SCIP_CONFLICTHDLR **conflicthdlr, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, const char *name, const char *desc, int priority, SCIP_DECL_CONFLICTCOPY((*conflictcopy)), SCIP_DECL_CONFLICTFREE((*conflictfree)), SCIP_DECL_CONFLICTINIT((*conflictinit)), SCIP_DECL_CONFLICTEXIT((*conflictexit)), SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)), SCIP_DECL_CONFLICTEXITSOL((*conflictexitsol)), SCIP_DECL_CONFLICTEXEC((*conflictexec)), SCIP_CONFLICTHDLRDATA *conflicthdlrdata)

static SCIP_RETCODE conflictsetCopy(SCIP_CONFLICTSET **targetconflictset, BMS_BLKMEM *blkmem, SCIP_CONFLICTSET *sourceconflictset, int nadditionalelems)

static SCIP_RETCODE conflictsetAddBound(SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

static SCIP_Bool conflictMarkBoundCheckPresence(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

SCIP_RETCODE SCIPconflicthdlrCopyInclude(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

void SCIPconflicthdlrSetExit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTEXIT((*conflictexit)))

SCIP_RETCODE SCIPundoBdchgsProof(SCIP_SET *set, SCIP_PROB *prob, int currentdepth, SCIP_Real *proofcoefs, SCIP_Real prooflhs, SCIP_Real *proofact, SCIP_Real *curvarlbs, SCIP_Real *curvarubs, int *lbchginfoposs, int *ubchginfoposs, SCIP_LPBDCHGS *oldlpbdchgs, SCIP_LPBDCHGS *relaxedlpbdchgs, SCIP_Bool *resolve, SCIP_LPI *lpi)

static SCIP_RETCODE conflictsetAddBounds(SCIP_CONFLICT *conflict, SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BDCHGINFO **bdchginfos, int nbdchginfos)

static SCIP_RETCODE addSideRemoval(SCIP_SET *set, SCIP_ROW *row, SCIP_Real lpiinfinity, int **sidechginds, SCIP_Real **sidechgoldlhss, SCIP_Real **sidechgoldrhss, SCIP_Real **sidechgnewlhss, SCIP_Real **sidechgnewrhss, int *sidechgssize, int *nsidechgs)

static SCIP_RETCODE convertToActiveVar(SCIP_VAR **var, SCIP_SET *set, SCIP_BOUNDTYPE *boundtype, SCIP_Real *bound)

static SCIP_RETCODE incVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BOUNDTYPE boundtype, SCIP_Real value, SCIP_Real weight)

static SCIP_Bool bdchginfoIsResolvable(SCIP_BDCHGINFO *bdchginfo)

SCIP_RETCODE conflictAnalyze(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_TREE *tree, SCIP_Bool diving, int validdepth, SCIP_Bool mustresolve, int *nconss, int *nliterals, int *nreconvconss, int *nreconvliterals)

void SCIPconflicthdlrSetCopy(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTCOPY((*conflictcopy)))

static SCIP_Bool checkRedundancy(SCIP_SET *set, SCIP_CONFLICTSET *conflictset)

static void lpbdchgsReset(SCIP_LPBDCHGS *lpbdchgs, int ncols)

SCIP_RETCODE SCIPconflictIsVarUsed(SCIP_CONFLICT *conflict, SCIP_VAR *var, SCIP_SET *set, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool *used)

static SCIP_RETCODE conflictAddBound(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGINFO *bdchginfo, SCIP_Real relaxedbd)

SCIP_RETCODE SCIPconflictsetCreate(SCIP_CONFLICTSET **conflictset, BMS_BLKMEM *blkmem)

static SCIP_RETCODE conflictsetCalcInsertDepth(SCIP_CONFLICTSET *conflictset, SCIP_SET *set, SCIP_TREE *tree)

static SCIP_BDCHGINFO * conflictRemoveCand(SCIP_CONFLICT *conflict)

static SCIP_DECL_PARAMCHGD(paramChgdConflicthdlrPriority)

static SCIP_RETCODE conflictsetEnsureBdchginfosMem(SCIP_CONFLICTSET *conflictset, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

static SCIP_BDCHGINFO * conflictFirstCand(SCIP_CONFLICT *conflict)

SCIP_RETCODE SCIPconflictInit(SCIP_CONFLICT *conflict, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound)

static SCIP_RETCODE ensureCandsSize(SCIP_SET *set, SCIP_VAR ***cands, SCIP_Real **candscores, SCIP_Real **newbounds, SCIP_Real **proofactdeltas, int *candssize, int num)

SCIP_RETCODE SCIPconflicthdlrExec(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set, SCIP_NODE *node, SCIP_NODE *validnode, SCIP_BDCHGINFO **bdchginfos, SCIP_Real *relaxedbds, int nbdchginfos, SCIP_CONFTYPE conftype, SCIP_Bool usescutoffbound, SCIP_Bool resolved, SCIP_RESULT *result)

SCIP_RETCODE SCIPconflicthdlrInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

static void skipRedundantBdchginfos(SCIP_VAR *var, int *lbchginfopos, int *ubchginfopos)

static SCIP_RETCODE conflictInsertConflictset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONFLICTSET **conflictset)

static SCIP_RETCODE conflictEnsureConflictsetsMem(SCIP_CONFLICT *conflict, SCIP_SET *set, int num)

static void lpbdchgsFree(SCIP_LPBDCHGS **lpbdchgs, SCIP_SET *set)

SCIP_RETCODE SCIPconflicthdlrInit(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_SET *set)

static SCIP_RETCODE conflictAddConflictset(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, int validdepth, SCIP_Bool diving, SCIP_Bool repropagate, SCIP_Bool *success, int *nliterals)

static void conflictFreeTmpBdchginfos(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem)

void SCIPconflicthdlrSetInitsol(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_DECL_CONFLICTINITSOL((*conflictinitsol)))

static SCIP_RETCODE updateStatistics(SCIP_CONFLICT *conflict, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONFLICTSET *conflictset, int insertdepth)

methods and datastructures for conflict analysis

SCIP_RETCODE SCIPconsResolvePropagation(SCIP_CONS *cons, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)

internal methods for constraints and constraint handlers

Constraint handler for linear constraints in their most general form, .

methods for the aggregation rows

#define SCIPquadprecProdQD(r, a, b)

#define SCIPquadprecSumDD(r, a, b)

#define SCIPdebugCheckConflict(blkmem, set, node, bdchginfos, relaxedbds, nliterals)

#define SCIPdebugCheckConflictFrontier(blkmem, set, node, bdchginfo, bdchginfos, relaxedbds, nliterals, bdchgqueue, forcedbdchgqueue)

#define SCIP_LONGINT_FORMAT

#define SCIP_CALL_FINALLY(x, y)

void SCIPdotWriteOpening(FILE *file)

void SCIPdotWriteClosing(FILE *file)

void SCIPdotWriteArc(FILE *file, int source, int target, const char *color)

void SCIPgmlWriteNode(FILE *file, unsigned int id, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteClosing(FILE *file)

void SCIPdotWriteNode(FILE *file, int node, const char *label, const char *nodetype, const char *fillcolor, const char *bordercolor)

void SCIPgmlWriteOpening(FILE *file, SCIP_Bool directed)

void SCIPgmlWriteEdge(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

void SCIPgmlWriteArc(FILE *file, unsigned int source, unsigned int target, const char *label, const char *color)

SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)

SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)

SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)

SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)

SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)

SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)

SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)

SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)

SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)

void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)

void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)

void SCIPpqueueClear(SCIP_PQUEUE *pqueue)

SCIP_RETCODE SCIPpqueueInsert(SCIP_PQUEUE *pqueue, void *elem)

int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)

void * SCIPpqueueRemove(SCIP_PQUEUE *pqueue)

void * SCIPpqueueFirst(SCIP_PQUEUE *pqueue)

int SCIPcolGetLPPos(SCIP_COL *col)

int SCIPcolGetNNonz(SCIP_COL *col)

SCIP_BOUNDTYPE SCIPboundtypeOpposite(SCIP_BOUNDTYPE boundtype)

SCIP_CONFLICTHDLRDATA * SCIPconflicthdlrGetData(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_DECL_SORTPTRCOMP(SCIPconflicthdlrComp)

int SCIPconflicthdlrGetPriority(SCIP_CONFLICTHDLR *conflicthdlr)

const char * SCIPconflicthdlrGetName(SCIP_CONFLICTHDLR *conflicthdlr)

void SCIPconflicthdlrSetData(SCIP_CONFLICTHDLR *conflicthdlr, SCIP_CONFLICTHDLRDATA *conflicthdlrdata)

SCIP_Bool SCIPconflicthdlrIsInitialized(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_Real SCIPconflicthdlrGetTime(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_Real SCIPconflicthdlrGetSetupTime(SCIP_CONFLICTHDLR *conflicthdlr)

const char * SCIPconflicthdlrGetDesc(SCIP_CONFLICTHDLR *conflicthdlr)

SCIP_RETCODE SCIPsetConflicthdlrPriority(SCIP *scip, SCIP_CONFLICTHDLR *conflicthdlr, int priority)

int SCIPconsGetValidDepth(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsGlobal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)

SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)

void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)

int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)

int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)

static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)

int SCIPnodeGetDepth(SCIP_NODE *node)

const char * SCIPpropGetName(SCIP_PROP *prop)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

int SCIProwGetLPPos(SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

const char * SCIProwGetName(SCIP_ROW *row)

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_RETCODE SCIPshrinkDisjunctiveVarSet(SCIP *scip, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_Bool *boundtypes, SCIP_Bool *redundants, int nvars, int *nredvars, int *nglobalred, SCIP_Bool *setredundant, SCIP_Bool *glbinfeas, SCIP_Bool fullshortening)

SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

int SCIPvarGetNVlbs(SCIP_VAR *var)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_Bool SCIPbdchginfoIsRedundant(SCIP_BDCHGINFO *bdchginfo)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_Bool SCIPbdchgidxIsEarlier(SCIP_BDCHGIDX *bdchgidx1, SCIP_BDCHGIDX *bdchgidx2)

SCIP_BDCHGIDX * SCIPbdchginfoGetIdx(SCIP_BDCHGINFO *bdchginfo)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_PROP * SCIPbdchginfoGetInferProp(SCIP_BDCHGINFO *bdchginfo)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPbdchginfoGetDepth(SCIP_BDCHGINFO *bdchginfo)

int SCIPbdchginfoGetInferInfo(SCIP_BDCHGINFO *bdchginfo)

int SCIPvarGetIndex(SCIP_VAR *var)

SCIP_CONS * SCIPbdchginfoGetInferCons(SCIP_BDCHGINFO *bdchginfo)

int SCIPbdchginfoGetPos(SCIP_BDCHGINFO *bdchginfo)

SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)

int SCIPvarGetNVubs(SCIP_VAR *var)

SCIP_Real SCIPbdchginfoGetOldbound(SCIP_BDCHGINFO *bdchginfo)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_BOUNDTYPE SCIPbdchginfoGetInferBoundtype(SCIP_BDCHGINFO *bdchginfo)

SCIP_BDCHGINFO * SCIPvarGetBdchgInfo(SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)

SCIP_Bool SCIPbdchginfoIsTighter(SCIP_BDCHGINFO *bdchginfo1, SCIP_BDCHGINFO *bdchginfo2)

int SCIPvarGetMultaggrNVars(SCIP_VAR *var)

int SCIPvarGetNCliques(SCIP_VAR *var, SCIP_Bool varfixing)

SCIP_BOUNDCHGTYPE SCIPbdchginfoGetChgtype(SCIP_BDCHGINFO *bdchginfo)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_VAR * SCIPbdchginfoGetInferVar(SCIP_BDCHGINFO *bdchginfo)

SCIP_Bool SCIPbdchginfoHasInferenceReason(SCIP_BDCHGINFO *bdchginfo)

SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_BDCHGINFO * SCIPvarGetBdchgInfoLb(SCIP_VAR *var, int pos)

SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)

SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)

SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_BDCHGINFO * SCIPvarGetBdchgInfoUb(SCIP_VAR *var, int pos)

SCIP_Real * SCIPvarGetMultaggrScalars(SCIP_VAR *var)

SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)

void SCIPsortedvecInsertIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int keyval, void *field1val, SCIP_Real field2val, int *len, int *pos)

void SCIPsortIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int len)

void SCIPsortLongPtrRealRealBool(SCIP_Longint *longarray, void **ptrarray, SCIP_Real *realarray, SCIP_Real *realarray2, SCIP_Bool *boolarray, int len)

void SCIPsortedvecDelPosIntPtrReal(int *intarray, void **ptrarray, SCIP_Real *realarray, int pos, int *len)

int SCIPsnprintf(char *t, int len, const char *s,...)

void SCIPhistoryIncNActiveConflicts(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real length)

void SCIPhistoryScaleVSIDS(SCIP_HISTORY *history, SCIP_Real scalar)

void SCIPhistoryIncVSIDS(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)

internal methods for branching and inference history

SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)

SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)

int SCIPlpGetNCols(SCIP_LP *lp)

SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)

static const SCIP_Real scalars[]

int SCIPlpGetNRows(SCIP_LP *lp)

internal methods for LP management

interface methods for specific LP solvers

static const char * paramname[]

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSduplicateMemoryArray(ptr, source, num)

#define BMSclearMemory(ptr)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMScopyMemoryArray(ptr, source, num)

#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)

#define BMSclearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSfreeMemoryArrayNull(ptr)

#define BMSallocMemory(ptr)

SCIP_PARAMDATA * SCIPparamGetData(SCIP_PARAM *param)

int SCIPparamGetInt(SCIP_PARAM *param)

methods commonly used for presolving

const char * SCIPprobGetName(SCIP_PROB *prob)

int SCIPprobGetNVars(SCIP_PROB *prob)

SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)

SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)

SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)

internal methods for storing and manipulating the main problem

SCIP_RETCODE SCIPpropResolvePropagation(SCIP_PROP *prop, SCIP_SET *set, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE inferboundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)

internal methods for propagators

public methods for conflict analysis handlers

public methods for managing constraints

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

public methods for handling parameter settings

public methods for propagators

public methods for branch and bound tree

public methods for problem variables

public methods for conflict handler plugins and conflict analysis

public methods for constraint handler plugins and constraints

public methods for memory management

public methods for message handling

public methods for solutions

public methods for SCIP variables

SCIP_RETCODE SCIPsetAddIntParam(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, 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_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsPositive(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)

SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)

void SCIPsetSortConflicthdlrs(SCIP_SET *set)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetFreeCleanBufferArray(set, ptr)

#define SCIPsetDebugMsgPrint

#define SCIPsetAllocBufferArray(set, ptr, num)

#define SCIPsetFreeBuffer(set, ptr)

#define SCIPsetAllocCleanBufferArray(set, ptr, num)

#define SCIPsetAllocBuffer(set, ptr)

#define SCIPsetReallocBufferArray(set, ptr, num)

internal methods for storing primal CIP solutions

unsigned int hasrelaxonlyvar

SCIP_BDCHGINFO ** bdchginfos

SCIP_CONFTYPE conflicttype

unsigned int usescutoffbound

SCIP_Real * conflictsetscores

SCIP_Longint nappliedglbconss

SCIP_Longint npropconfconss

SCIP_CLOCK * propanalyzetime

SCIP_PQUEUE * forcedbdchgqueue

SCIP_Longint nappliedglbliterals

SCIP_CONFLICTSET ** conflictsets

SCIP_Longint npropsuccess

SCIP_Longint nappliedlocconss

SCIP_Longint npropreconvliterals

SCIP_BDCHGINFO ** tmpbdchginfos

SCIP_Longint npropconfliterals

SCIP_CONFLICTSET * conflictset

SCIP_Longint nappliedlocliterals

SCIP_Longint npropreconvconss

SCIP_CONFLICTHDLRDATA * conflicthdlrdata

SCIP_CLOCK * conflicttime

SCIP_BOUNDCHG * boundchgs

SCIP_Bool strongbranching

SCIP_Longint nconflictlps

SCIP_HISTORY * glbhistory

SCIP_Longint lastconflictnode

SCIP_HISTORY * glbhistorycrun

SCIP_Longint nconflictlpiterations

SCIP_CLOCK * conflictlptime

SCIP_BDCHGINFO * lbchginfos

SCIP_Real conflictrelaxedub

SCIP_BDCHGINFO * ubchginfos

SCIP_Real conflictrelaxedlb

datastructures for conflict analysis

data structures for LP management

datastructures for storing and manipulating the main problem

datastructures for global SCIP settings

datastructures for problem statistics

data structures for branch and bound tree

datastructures for problem variables

SCIP_RETCODE SCIPnodeCutoff(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_REOPT *reopt, SCIP_LP *lp, BMS_BLKMEM *blkmem)

int SCIPtreeGetFocusDepth(SCIP_TREE *tree)

void SCIPnodePropagateAgain(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)

int SCIPtreeGetEffectiveRootDepth(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeAddBoundchg(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_Bool probingchange)

int SCIPtreeGetCurrentDepth(SCIP_TREE *tree)

internal methods for branch and bound tree

#define SCIP_DECL_CONFLICTEXIT(x)

#define SCIP_DECL_CONFLICTCOPY(x)

#define SCIP_DECL_CONFLICTEXEC(x)

#define SCIP_DECL_CONFLICTINITSOL(x)

#define SCIP_DECL_CONFLICTFREE(x)

@ SCIP_CONFTYPE_BNDEXCEEDING

@ SCIP_CONFTYPE_PROPAGATION

#define SCIP_DECL_CONFLICTINIT(x)

enum SCIP_ConflictType SCIP_CONFTYPE

struct SCIP_ConflicthdlrData SCIP_CONFLICTHDLRDATA

#define SCIP_DECL_CONFLICTEXITSOL(x)

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BranchDir SCIP_BRANCHDIR

enum SCIP_BoundType SCIP_BOUNDTYPE

@ SCIP_LPSOLSTAT_NOTSOLVED

struct SCIP_ParamData SCIP_PARAMDATA

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_BOUNDCHGTYPE_PROPINFER

@ SCIP_BOUNDCHGTYPE_BRANCHING

@ SCIP_BOUNDCHGTYPE_CONSINFER

@ SCIP_VARSTATUS_MULTAGGR

@ SCIP_VARSTATUS_AGGREGATED

SCIP_DOMCHGBOUND domchgbound

void SCIPbdchginfoFree(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPvarIncVSIDS(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real weight)

SCIP_RETCODE SCIPvarIncNActiveConflicts(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Real length)

void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)

SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)

SCIP_RETCODE SCIPvarScaleVSIDS(SCIP_VAR *var, SCIP_Real scalar)

SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)

int SCIPbdchgidxGetPos(SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPbdchginfoCreate(SCIP_BDCHGINFO **bdchginfo, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_Real oldbound, SCIP_Real newbound)

SCIP_RETCODE SCIPvarGetProbvarSum(SCIP_VAR **var, SCIP_SET *set, SCIP_Real *scalar, SCIP_Real *constant)

void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)

SCIP_Real SCIPbdchginfoGetRelaxedBound(SCIP_BDCHGINFO *bdchginfo)

internal methods for problem variables

void SCIPvisualFoundConflict(SCIP_VISUAL *visual, SCIP_STAT *stat, SCIP_NODE *node)

methods for creating output for visualization tools (VBC, BAK)

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