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

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

SCIP Doxygen Documentation: reopt.c Source File

assert(eventhdlr !=

);

( eventnode ==

)

assert(eventhdlr !=

);

assert(eventhdlr !=

);

assert(num <= reopt->nmaxactiveconss);

assert(runidx <= reopt->runsize);

assert(num <= reopt->soltree->solssize[runidx]);

(

s = reopt->

; s < newsize; ++s )

assert(num < reopt->runsize);

assert(reopttree !=

);

assert(blkmem !=

);

(

= reopttree->

;

< (

)newsize; ++

)

assert(reoptnode !=

);

assert(blkmem !=

);

assert(var_mem >= 0);

assert(child_mem >= 0);

assert(conss_mem >= 0);

( reoptnode->

< var_mem )

( reoptnode->

< conss_mem )

assert(solnode !=

);

sibling = solnode->

;

( sibling !=

)

assert(reopt !=

);

assert(vars !=

);

(

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

assert(transvar !=

);

assert(0 <= probidx && probidx < reopt->nobjvars);

c1 = reopt->

[obj1_id][probidx];

c2 = reopt->

[obj2_id][probidx];

norm_obj1 +=

(c1);

norm_obj2 +=

(c2);

norm_obj1 = sqrt(norm_obj1);

norm_obj2 = sqrt(norm_obj2);

similarity /= (norm_obj1 * norm_obj2);

similarity =

(similarity, -1.0);

similarity =

(similarity, 1.0);

assert((*reoptnode) !=

);

assert(blkmem !=

);

( (*reoptnode)->consssize > 0 )

assert((*reoptnode)->conss !=

);

(

c = 0; c < (*reoptnode)->nconss; ++c )

assert((*reoptnode)->conss[c] !=

);

assert((*reoptnode)->conss[c]->vals !=

);

assert((*reoptnode)->conss[c]->vars !=

);

(*reoptnode)->nconss = 0;

(*reoptnode)->consssize = 0;

(*reoptnode)->conss =

;

( (*reoptnode)->childids !=

)

(*reoptnode)->nchilds = 0;

(*reoptnode)->allocchildmem = 0;

(*reoptnode)->childids =

;

( (*reoptnode)->dualredscur !=

)

assert((*reoptnode)->dualredscur->varssize > 0);

(*reoptnode)->dualredscur =

;

( (*reoptnode)->dualredsnex !=

)

assert((*reoptnode)->dualredsnex->varssize > 0);

(*reoptnode)->dualredsnex =

;

((*reoptnode)->varboundtypes !=

)

assert((*reoptnode)->varssize > 0);

(*reoptnode)->varboundtypes =

;

((*reoptnode)->varbounds !=

)

assert((*reoptnode)->varssize > 0);

(*reoptnode)->varbounds =

;

((*reoptnode)->vars !=

)

assert((*reoptnode)->varssize > 0);

(*reoptnode)->vars =

;

(*reoptnode)->varssize = 0;

((*reoptnode)->afterdualvarboundtypes !=

)

assert((*reoptnode)->afterdualvarssize > 0);

(*reoptnode)->afterdualvarboundtypes =

;

((*reoptnode)->afterdualvarbounds !=

)

assert((*reoptnode)->afterdualvarssize > 0);

(*reoptnode)->afterdualvarbounds =

;

((*reoptnode)->afterdualvars !=

)

assert((*reoptnode)->afterdualvarssize > 0);

(*reoptnode)->afterdualvars =

;

(*reoptnode)->afterdualvarssize = 0;

(*reoptnode) =

;

assert(reoptnode !=

);

assert(blkmem !=

);

( reoptnode->

> 0 )

(

c = 0; c < reoptnode->

; ++c )

( !reoptnode->

[c]->linear )

assert(reoptnode->

[c]->boundtypes !=

);

reoptnode->

= 0;

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

assert(soltree !=

);

soltree->

[s] = 0;

assert(reopt !=

);

assert(solnode !=

);

assert(blkmem !=

);

child = (*solnode)->

;

( child !=

)

assert(child !=

);

( (*solnode)->sol !=

)

assert(reopt !=

);

assert(blkmem !=

);

assert(blkmem !=

);

assert(curnode !=

);

assert(child !=

&& *child ==

);

*child = curnode->

;

( *child ==

)

solnode->

= curnode;

solnode->

= val;

assert(var !=

);

curnode->

= *child;

(

*) solnode->sibling);

( *child !=

)

(

,

, (

*) *child, (

*) (*child)->

,

(*child)->

, (

*) (*child)->sibling);

( (*child)->sibling ==

)

solnode->

= curnode;

solnode->

= val;

assert(var !=

);

(*child)->sibling = solnode;

(

*) solnode->sibling);

(

,

,

(

*) (*child), (

*) (*child)->child, (

*) (*child)->sibling, (

*) (*child)->sol,

(

*) solnode, (

*) solnode->child, (

*) solnode->sibling, (

*) solnode->sol,

solnode->child = (*child)->child;

(*child)->child =

;

solnode->value = (*child)->value;

(*child)->value = val;

solnode->sol = (*child)->sol;

(*child)->sol =

;

(

,

,

(

*) (*child), (

*) (*child)->child, (

*) (*child)->sibling, (

*) (*child)->sol,

(

*) solnode, (

*) solnode->child, (

*) solnode->sibling, (

*) solnode->sol,

solnode->

= curnode;

solnode->

= val;

assert(var !=

);

(*child)->sibling = solnode;

(

*) solnode->sibling);

*child = (*child)->sibling;

solnode = curnode->

;

assert(solnode !=

);

assert(reopt !=

);

assert(stat !=

);

assert(origprimal !=

);

assert(blkmem !=

);

assert(vars !=

);

assert(sol !=

);

assert(solnode !=

);

(

->reopt_savesols > 0 )

(

varid = 0; varid < nvars; ++varid )

assert(child !=

);

( (*added || bestsol) && !purelp )

cursolnode->

= copysol;

assert(cursolnode->

!=

);

(*solnode) = cursolnode;

assert(node !=

);

child = node->

;

( child !=

)

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

assert(reopttree !=

);

assert(blkmem !=

);

(

= 1;

< reopttree->

; ++id )

assert(reopttree !=

);

(

= 0;

< reopttree->

; ++id )

assert(reopttree !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(blkmem !=

);

reopt->

->varssize = size;

( reopt->

->varssize < size )

reopt->

->varssize = newsize;

assert(reopt !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(node !=

);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

( nconsprops > 0 || npropprops > 0 )

assert(nvars + naddedbndchgs <= reopt->reopttree->reoptnodes[

]->varssize);

*transintoorig =

;

assert(reopt !=

);

assert(blkmem !=

);

assert(node !=

);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

( nbranchvars > 0 )

*transintoorig =

;

(

,

, nbranchvars);

assert(reopt !=

);

assert(lp !=

);

assert(blkmem !=

);

(

= 0;

< nlprows; ++

)

(

c = 0; c < ncutvars; ++c )

assert(cutvars[c] !=

);

( cutvars[c] !=

)

assert(cutvars[c] !=

);

cutvals[c] = cutvals[c]/scalar;

assert(reopt !=

);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

* parentid,

assert(reopt !=

);

nbranchings = 0;

(

->reopt_saveprop )

(*nbndchgs) = (*nbndchgs) + nbranchings + nconsprop + npropprops;

parentid,

childid

assert(reopttree !=

);

assert(blkmem !=

);

nodeid,

parentid

childid;

assert(reopt !=

);

assert(blkmem !=

);

assert(0 < nodeid && nodeid < reopt->reopttree->reoptnodessize);

assert(parentid < reopt->reopttree->reoptnodessize);

assert(0 < childid && childid < reopt->reopttree->reoptnodessize);

assert(reopttree !=

);

assert(blkmem !=

);

assert(id < reopttree->reoptnodessize);

(

,

,

, exitsolve);

childid;

assert(0 < childid && childid < reopttree->reoptnodessize);

( delnodeitself )

assert(reopt !=

);

assert(node !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(reoptnodes !=

);

assert(reoptnodes[

] !=

);

( reoptnodes[

]->childids !=

&& reoptnodes[

]->nchilds > 0 )

parentid = 0;

assert(parentid !=

);

assert(reoptnodes[parentid] !=

);

assert(reoptnodes[parentid]->childids !=

&& reoptnodes[parentid]->nchilds);

( ndomchgs <= set->reopt_maxdiffofnodes )

, reoptnodes[

]->nchilds);

( reoptnodes[parentid]->childids[c] !=

)

assert(c < reoptnodes[parentid]->nchilds);

assert(reoptnodes[parentid]->childids[c] ==

);

--reoptnodes[parentid]->

;

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

childid;

( seenids < nchildids )

assert(childid < reopttree->reoptnodessize);

assert(reoptnode !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(node !=

);

assert(transvars !=

);

assert(node !=

);

*localrestart =

;

assert(id < reopt->reopttree->reoptnodessize);

(

->reopt_objsimdelay > -1 )

(

v = 0; v < ntransvars; ++v )

assert(0 <= idx && idx < ntransvars);

sim += (oldcoef * newcoef);

*localrestart =

;

(

,

, sim, *localrestart ?

:

);

parentid

assert(reopttree !=

);

assert(node !=

);

assert(parent !=

);

assert(1 <=

&& id < reopttree->reoptnodessize);

assert(parentid < reopttree->reoptnodessize);

assert(parentid == 0 || reopttree->

[parentid] !=

);

assert(nbranchvars <= reopttree->reoptnodes[

]->varssize);

assert(nbranchvars <= reopttree->reoptnodes[

]->varssize);

assert(reoptconsdata !=

);

assert(cons !=

);

allocbuffervals =

;

reoptconsdata->linear =

;

reoptconsdata->varssize = reoptconsdata->nvars;

reoptconsdata->boundtypes =

;

assert(conshdlr !=

);

allocbuffervals =

;

(

v = 0; v < reoptconsdata->nvars; ++v )

reoptconsdata->lhs = 1.0;

allocbuffervals =

;

(

v = 0; v < reoptconsdata->nvars; ++v )

reoptconsdata->lhs = 1.0;

reoptconsdata->rhs = 1.0;

reoptconsdata->rhs = 1.0;

reoptconsdata->lhs = 1.0;

assert(vars !=

);

assert(vals !=

);

(

v = 0; v < reoptconsdata->nvars; ++v )

assert(vars[v] !=

);

reoptconsdata->vars[v] = vars[v];

reoptconsdata->vals[v] = vals[v];

reoptconsdata->vals[v] *= scalar;

reoptconsdata->lhs -= constant;

reoptconsdata->rhs -= constant;

( allocbuffervals )

assert(reoptconsdata !=

);

assert(cons !=

);

reoptconsdata->linear =

;

assert(conshdlr !=

);

(

,

reoptconsdata->varssize = reoptconsdata->nvars;

(

v = 0; v < reoptconsdata->nvars; ++v )

assert(reoptconsdata->vars[v] !=

);

reoptconsdata->vals[v] -= constant;

reoptconsdata->vals[v] *= scalar;

assert(node !=

);

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

(

c = nconss; c < naddedconss; ++c )

( strcmp(

,

(addedcons[c])) == 0 )

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(node !=

);

assert(blkmem !=

);

nbndchgs = reopt->

->nvars;

&nbndchgs, reopt->

->varssize);

assert(nbndchgs <= reopt->dualreds->varssize);

reopt->

->nvars = nbndchgs;

(

v = 0; v < nbndchgs; ++v )

reopt->

->vals[v] = (reopt->

->vals[v] - constant) / scalar;

assert(nbndchgs > 0);

cons_is_next =

;

reopt->

->vars, nbndchgs) );

reopt->

->vals, nbndchgs) );

reopt->

->boundtypes, nbndchgs) );

(

,

,

reopt->

->vars, nbndchgs) );

reopt->

->vals, nbndchgs) );

reopt->

->boundtypes, nbndchgs) );

(

,

,

parentid = 0;

assert(reopt !=

);

assert(blkmem !=

);

assert(node !=

);

(

->reopt_maxsavednodes == 0 )

assert(!isrootnode);

assert(id < reopt->reopttree->reoptnodessize);

assert(parent !=

);

assert(parent !=

);

assert(parentid == 0

transintoorig =

;

(

->reopt_usecuts )

( saveafterdual )

(

->reopt_saveprop )

( transintoorig )

( reopttype )

(

->reopt_shrinkinner )

(

->reopt_reducetofrontier )

(

->reopt_reducetofrontier )

(

->reopt_usecuts )

( reopttype )

(

,

, reopttype,

(

->reopt_reducetofrontier )

(

,

, reopttype,

(

->reopt_reducetofrontier )

(

,

, reopttype,

assert(

>= 1 && id < reopt->reopttree->reoptnodessize);

assert(!isrootnode);

assert(parent !=

);

( saveafterdual )

(

->reopt_usecuts )

(

,

,

( reopttype )

assert(reopt !=

);

assert(reoptnode !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(vars !=

);

assert(vals !=

);

assert(nbinvars + nintvars == nvars);

reoptconsdata =

;

reoptconsdata = reopt->

[nglbconss];

reoptconsdata->varssize = (int)(nbinvars+2*nintvars);

reoptconsdata->nvars = 0;

assert(reopt->

[nglbconss]->nvars == 0);

assert(reopt->

[nglbconss]->varssize > 0);

reoptconsdata = reopt->

[nglbconss];

( reoptconsdata->varssize < nbinvars+2*nintvars )

(

)(nbinvars+2*nintvars)) );

(

)(nbinvars+2*nintvars)) );

(

)(nbinvars+2*nintvars)) );

reoptconsdata->varssize = (int)(nbinvars+2*nintvars);

assert(reoptconsdata !=

);

reoptconsdata->lhs = 1.0;

reoptconsdata->linear =

;

(

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

assert(nvarsadded < reoptconsdata->varssize);

assert(vars[v] !=

);

reoptconsdata->vars[nvarsadded] = vars[v];

reoptconsdata->vals[nvarsadded] = 0.0;

reoptconsdata->vals[nvarsadded] = 1.0;

assert(boundtypes !=

);

reoptconsdata->vals[nvarsadded] = vals[v];

reoptconsdata->vars[nvarsadded] = vars[v];

reoptconsdata->vals[nvarsadded] = ubglb - 1.0;

reoptconsdata->vals[nvarsadded] = lbglb + 1.0;

( boundtypes !=

)

reoptconsdata->vals[nvarsadded] = roundedval + 1.0;

reoptconsdata->vals[nvarsadded] = roundedval - 1.0;

reoptconsdata->vals[nvarsadded] = roundedval - 1.0;

reoptconsdata->vars[nvarsadded] = vars[v];

reoptconsdata->vals[nvarsadded] = roundedval + 1.0;

assert(nvars <= nvarsadded);

assert(nvarsadded == nbinvars + 2 * nintvars);

reoptconsdata->nvars = nvarsadded;

assert(reopt !=

);

assert(node !=

);

( allocmem < nbranchvars )

allocmem = nbranchvars;

(

v = 0; v < nbranchvars; ++v )

assert(nbinvars + nintvars == nbranchvars);

assert(reopttree !=

);

assert(blkmem !=

);

assert(id1 < reopttree->reoptnodessize);

assert(id2 < reopttree->reoptnodessize);

(

c = 0; c < nchilds_id1; ++c )

(

k = 0; k < nchilds_id2; ++k )

assert(reopt !=

);

assert(stat !=

);

assert(transprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(branchcand !=

);

assert(eventqueue !=

);

assert(cliquetable !=

);

assert(node !=

);

assert(blkmem !=

);

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

assert(reoptnode !=

);

(

v = 0; v < reoptnode->

; ++v )

var = reoptnode->

[v];

nvars = reoptnode->

;

++reoptnode->

;

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(stat !=

);

assert(blkmem !=

);

assert(transprob !=

);

assert(origprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(branchcand !=

);

assert(eventqueue !=

);

assert(node !=

);

assert(!reoptconsdata->linear);

assert(reoptconsdata->vars !=

);

assert(reoptconsdata->vals !=

);

assert(reoptconsdata->boundtypes !=

);

var = reoptconsdata->vars[0];

newbound = reoptconsdata->vals[0];

boundtype = reoptconsdata->boundtypes[0];

newbound = reoptconsdata->vals[0] - 1.0;

newbound = reoptconsdata->vals[0] + 1.0;

assert(!reoptconsdata->linear);

assert(reoptconsdata->vars !=

);

assert(reoptconsdata->vals !=

);

assert(reoptconsdata->boundtypes !=

);

(

v = 0; v < reoptconsdata->nvars; ++v )

(

,

( reoptconsdata->nvars == nbinvars )

(

v = 0; v < reoptconsdata->nvars; ++v )

consvars[v] = reoptconsdata->vars[v];

consval = reoptconsdata->vals[v];

assert(nintvars > 0 || ncontvars > 0);

(

v = 0; v < reoptconsdata->nvars; ++v )

consvars[v] = reoptconsdata->vars[v];

consvals[v] = reoptconsdata->vals[v];

consboundtypes[v] = reoptconsdata->boundtypes[v];

consvals,

,

,

,

,

,

,

,

,

,

) );

assert(reopt !=

);

assert(stat !=

);

assert(transprob !=

);

assert(origprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(branchcand !=

);

assert(eventqueue !=

);

assert(cliquetable !=

);

assert(node !=

);

assert(blkmem !=

);

assert(reopttree !=

);

assert(0 <

&& id < reopttree->reoptnodessize);

assert(reoptnode !=

);

(

v = 0; v < reoptnode->

->nvars; ++v )

boundtype = reoptnode->

->boundtypes[v];

pos = reoptnode->

;

reoptnode->

[pos] = var;

++reoptnode->

;

( updatedualconss )

assert(reopt !=

);

assert(stat !=

);

assert(transprob !=

);

assert(origprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(branchcand !=

);

assert(eventqueue !=

);

assert(cliquetable !=

);

assert(node !=

);

assert(perm !=

);

assert(vars !=

);

assert(vals !=

);

assert(boundtypes !=

);

assert(blkmem !=

);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

assert(reopttree !=

);

assert(reoptnode !=

);

nbndchgs =

(negbndchg, nvars);

(

v = 0; v < nbndchgs; ++v )

var = vars[perm[v]];

val = vals[perm[v]];

boundtype = boundtypes[perm[v]];

( v == nbndchgs-1 )

assert(reopt !=

);

assert(stat !=

);

assert(blkmem !=

);

assert(node !=

);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

assert(reoptconsdata !=

);

assert(reoptconsdata->nvars > 0);

assert(reoptconsdata->varssize >= reoptconsdata->nvars);

( reoptconsdata->linear )

reoptconsdata->lhs, reoptconsdata->rhs,

,

,

,

,

,

,

,

,

,

) );

assert(reoptconsdata->boundtypes !=

);

reoptconsdata->vals,

,

,

,

,

,

,

,

,

,

) );

assert(reopt !=

);

* cutoffchilds;

ncutoffchilds = 0;

* redchilds;

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

( c = 0; c < reoptnode->

; ++c )

* redundantvars;

childid;

childid = reoptnode->

[c];

assert(childid < reopt->reopttree->reoptnodessize);

assert(child !=

);

( child->

> 0 )

(

v = 0; v < child->

&& !cutoff; ++v )

transvar = child->

[v];

(

,

,

(

,

,

redundantvars[nredundantvars] = v;

( !cutoff && nredundantvars > 0 )

(

v = 0; v < nredundantvars; ++v )

child->

[redundantvars[v]] = child->

[child->

-1];

( child->

== 0 )

cutoffchilds[ncutoffchilds] = childid;

( redundant )

redchilds[nredchilds] = childid;

(

,

, nredchilds, ncutoffchilds);

( ncutoffchilds > 0 )

( reoptnode->

[c] != cutoffchilds[ncutoffchilds-1] && c < reoptnode->nchilds )

assert(reoptnode->

[c] == cutoffchilds[ncutoffchilds-1]);

( nredchilds > 0 )

( reoptnode->

[c] != redchilds[nredchilds-1] && c < reoptnode->nchilds )

assert(reoptnode->

[c] == redchilds[nredchilds-1]);

(

cc = 0; cc < ncc; ++cc )

assert(reopttree !=

);

assert(id < reopttree->reoptnodessize);

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

childid;

assert(childid < reopt->reopttree->reoptnodessize);

* leaves,

assert(reopt !=

);

assert(leavessize > 0 && leaves !=

);

assert((*nleaves) >= 0);

assert(id < reopt->reopttree->reoptnodessize);

childid;

assert(*nleaves <= leavessize);

assert(childid < reopt->reopttree->reoptnodessize);

(*nleaves) += nleaves2;

assert(reopt !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(origvars !=

);

assert(norigvars >= 0);

( reopt->

< norigvars )

(

i = 0; i < reopt->

-1; ++i )

(

v = reopt->

-1; v < norigvars; ++v )

reopt->

[i][v] = 0.0;

(

v = 0; v < norigvars; ++v )

(

i = 0; i < reopt->

; ++i )

(

j = reopt->

; j < newsize; ++j )

reopt->

[i][j] = 0.0;

assert(0 <= probidx && probidx < reopt->nobjvars);

( reopt->

== -1 && reopt->

[reopt->

-1][probidx] != 0 )

( reopt->

-1 >= 1 )

assert(perm !=

);

assert(vars !=

);

assert(bounds !=

);

assert(boundtypes !=

);

(

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

assert(reopt !=

);

assert(sol !=

);

assert(blkmem !=

);

assert(stat !=

);

assert(vars !=

);

(

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

assert(nbinvars + nintvars ==

);

origvars[v] = vars[v];

assert(origvars[v] !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

(*reopt)->simtolastobj = -2.0;

(*reopt)->simtofirstobj = -2.0;

(*reopt)->firstobj = -1;

(*reopt)->currentnode = -1;

(*reopt)->lastbranched = -1;

(*reopt)->dualreds =

;

(*reopt)->glbconss =

;

(*reopt)->nglbconss = 0;

(*reopt)->allocmemglbconss = 0;

(*reopt)->ncheckedsols = 0;

(*reopt)->nimprovingsols = 0;

(*reopt)->noptsolsbyreoptsol = 0;

(*reopt)->nglbrestarts = 0;

(*reopt)->nlocrestarts = 0;

(*reopt)->ntotallocrestarts = 0;

(*reopt)->firstrestart = -1;

(*reopt)->lastrestart = 0;

(*reopt)->nobjvars = 0;

(*reopt)->objhaschanged =

;

(*reopt)->consadded =

;

(*reopt)->addedconss =

;

(*reopt)->naddedconss = 0;

(*reopt)->addedconsssize = 0;

(*reopt)->glblb =

;

(*reopt)->glbub =

;

(*reopt)->nactiveconss = 0;

(*reopt)->nmaxactiveconss = 0;

(*reopt)->activeconss =

;

(*reopt)->activeconssset =

;

(

i = 0; i < (*reopt)->runsize; ++i )

(*reopt)->objs[i] =

;

(*reopt)->prevbestsols[i] =

;

(*reopt)->varhistory[i] =

;

eventInitsolReopt, eventExitsolReopt,

, eventExecReopt,

) );

assert(eventhdlr !=

);

assert(reopt !=

);

assert(*reopt !=

);

assert(blkmem !=

);

(

p = (*reopt)->run-1; p >= 0; --p )

( (*reopt)->soltree->sols[p] !=

)

(*reopt)->soltree->sols[p] =

;

(

->reopt_storevarhistory && (*reopt)->varhistory[p] !=

)

(*reopt)->varhistory[p] =

;

(

->reopt_sepabestsol && (*reopt)->prevbestsols[p] !=

)

( (*reopt)->objs[p] !=

)

( (*reopt)->dualreds !=

)

( (*reopt)->dualreds->varssize > 0 )

assert(!(*reopt)->dualreds->linear);

(*reopt)->dualreds =

;

( (*reopt)->glbconss !=

&& (*reopt)->allocmemglbconss > 0 )

(

c = 0; c < (*reopt)->allocmemglbconss; ++c )

( (*reopt)->glbconss[c] !=

)

( (*reopt)->glbconss[c]->varssize > 0 )

(*reopt)->glbconss[c]->varssize = 0;

--(*reopt)->nglbconss;

assert((*reopt)->nglbconss == 0);

(*reopt)->allocmemglbconss = 0;

( (*reopt)->activeconssset !=

)

( (*reopt)->glblb !=

)

(*reopt)->glblb =

;

(*reopt)->glbub =

;

assert((*reopt)->glbub ==

);

assert(reopt !=

);

assert(node !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(reopt !=

);

assert(sol !=

);

(

(reopt,

, stat, origprimal, blkmem, vars, sol, &solnode, nvars, bestsol, added) );

assert(solnode !=

);

reopt->

->

[run-1][insertpos] = solnode;

assert(reopt !=

);

assert(reopt->

-1 >= 0);

assert(sol !=

);

assert(blkmem !=

);

assert(stat !=

);

assert(origprimal !=

);

(

->reopt_sepabestsol )

assert(reopt !=

);

assert(blkmem !=

);

assert(origvars !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(0 < run && run <= reopt->runsize);

assert(reopt !=

);

(

= 0;

< reopt->

; ++

)

assert(reopt !=

);

assert(run > 0 && run <= reopt->run);

assert(sols !=

);

assert(solssize > 0);

assert(nsols !=

);

(

s = 0; s < reopt->

->

[run-1]; ++s )

( solssize < (*nsols) )

(

s = 0; s < reopt->

->

[run-1]; ++s )

assert(reopt !=

);

assert(reopt !=

);

assert(blkmem !=

);

assert(transvars !=

);

assert(ntransvars >= 0);

assert(restart !=

);

( reopt->

> 1 &&

->reopt_objsimdelay > -1.0 )

(

,

);

(

,

,

assert(reopt !=

);

assert(reopt !=

);

assert(reopt !=

);

assert(run1 > 0 && run1 <= reopt->run);

assert(run2 > 0 && run2 <= reopt->run);

assert(origvars !=

);

assert(norigvars >= 0);

assert(reopt !=

);

( reopt->

-2 < 0 )

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(reopt !=

);

assert(0 < run && run <= reopt->runsize);

reopt->

[run-1][idx];

assert(reopt !=

);

assert(0 < run && run <= reopt->run);

assert(reopt !=

);

assert(blkmem !=

);

assert(cons !=

);

assert(reopt !=

);

( child !=

)

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(0 <

&& id < reopt->reopttree->reoptnodessize);

assert(reoptnode !=

);

assert(reoptnode !=

);

reoptnode->

;

assert(reoptnode !=

);

assert(reoptnode !=

);

assert(reoptnode !=

);

assert(reoptnode !=

);

assert(reoptnode !=

);

assert(vars !=

);

assert(bounds !=

);

assert(boundtypes !=

);

assert(nvars !=

);

assert(nconss !=

);

(*nconss) = reoptnode->

;

( mem < *nconss )

(

c = 0; c < *nconss; ++c )

assert(vars[c] !=

);

assert(bounds[c] !=

);

vars[c] = reoptnode->

[c]->vars;

bounds[c] = reoptnode->

[c]->vals;

boundtypes[c] = reoptnode->

[c]->boundtypes;

nvars[c] = reoptnode->

[c]->nvars;

parentid

assert(reoptnode !=

);

assert(parentid <= 536870911);

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

childid;

assert(childid < reopt->reopttree->reoptnodessize);

assert(reopt !=

);

assert(blkmem !=

);

assert(node !=

);

(

->reopt_sepaglbinfsubtrees )

effectiverootdepth

assert(reopt !=

);

assert(blkmem !=

);

assert(lp !=

);

assert(node !=

);

lowerbound =

(lowerbound, cutoffbound);

isrootnode, lowerbound) );

(

,

, strongbranched ?

:

);

( eventtype )

assert(isfocusnode);

( strongbranched )

assert(isfocusnode);

( strongbranched )

( strongbranched )

assert(reopt !=

);

assert(node !=

);

allocmem = reopt->

->nvars + resizelength;

assert(reopt->

->varssize > 0);

assert(reopt->

->nvars >= 0);

newval = (newval - constant) / scalar;

oldval = (oldval - constant) / scalar;

(

, oldval, newval);

ndualbndchgs = 0;

assert(reopt !=

);

assert(node !=

);

ndualbndchgs = reopt->

->nvars;

ndualbndchgs;

* childs,

assert(reopt !=

);

assert(childssize > 0 && childs !=

);

assert(nchilds !=

);

assert(id < reopt->reopttree->reoptnodessize);

( childssize < *nchilds )

(

c = 0; c < *nchilds; ++c )

* leaves,

assert(reopt !=

);

assert(leavessize > 0 && leaves !=

);

assert((*nleaves) >= 0);

(

== 0 && node !=

)

assert(id < reopt->reopttree->reoptnodessize);

(

i = 0; i < leavessize; ++i )

childid;

assert(*nleaves + 1 <= leavessize);

assert(childid < reopt->reopttree->reoptnodessize);

(*nleaves) += nleaves2;

assert(reopt !=

);

assert(blkmem !=

);

assert(nleaves >= 0);

assert(nleaves == 0 || leaves !=

);

assert(nchilds >= 0);

assert(nchilds == 0 || childs !=

);

assert(nsiblings >= 0);

assert(nsiblings == 0 || siblings !=

);

(

,

, nleaves, nchilds, nsiblings);

(

n = 0; n < nleaves; ++n )

(

n = 0; n < nchilds; ++n )

(

n = 0; n < nsiblings; ++n )

assert(reopt !=

);

assert(stat !=

);

( !

->reopt_storevarhistory )

bestrun = reopt->

-2;

(

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

assert(transvar !=

);

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

(

d = 0; d <= 1; ++d )

(d == 0 ?

:

), avginference[d], avgcutoff[d]);

assert(reopt !=

);

assert(stat !=

);

assert(blkmem !=

);

( !

->reopt_storevarhistory )

(

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

(

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

assert(idx >= 0 && idx < nvars);

assert(transvar !=

);

nrepresentatives,

assert(reopt !=

);

assert(blkmem !=

);

assert(representatives !=

);

assert(nrepresentatives > 0);

(

= 0;

< nrepresentatives; ++

)

assert(1 <=

&& id < reopttree->reoptnodessize);

( representatives[

]->nvars > 0 )

assert(representatives[

]->nvars <= representatives[

]->varssize);

(

v = 0; v < representatives[

]->

; ++v )

( representatives[

]->nconss > 0 )

assert(representatives[

]->nconss <= representatives[

]->consssize);

(

c = 0; c < representatives[

]->

; ++c )

representatives[

]->

[c]->vals, representatives[

]->

[c]->boundtypes,

representatives[

]->

[c]->lhs, representatives[

]->

[c]->rhs,

representatives[

]->

[c]->nvars, representatives[

]->

[c]->constype,

representatives[

]->

[c]->linear) );

(

,

,

assert(reopt !=

);

assert(blkmem !=

);

assert(consdata !=

);

assert(dualreds !=

);

consdata->boundtypes =

;

consdata->varssize = dualreds->nvars;

consdata->nvars = dualreds->nvars;

consdata->linear =

;

consdata->lhs = 1.0;

(

v = 0; v < consdata->nvars; ++v )

assert(consdata->vars[v] !=

);

consdata->vals[v] = 1.0;

consdata->vals[v] = -1.0;

consdata->lhs -= 1.0;

assert(reopt !=

);

assert(blkmem !=

);

assert(consdata !=

);

assert(dualreds !=

);

consdata->varssize = dualreds->nvars;

consdata->nvars = dualreds->nvars;

consdata->linear =

;

(

v = 0; v < consdata->nvars; ++v )

assert(consdata->vars[v] !=

);

consdata->vals[v] =

(consdata->vals[v]+1.0, glbbd);

consdata->vals[v] =

(glbbd, consdata->vals[v]-1.0);

* ncreatedchilds,

assert(reopt !=

);

assert(stat !=

);

assert(blkmem !=

);

assert(reopttree !=

);

assert(reoptnodes !=

);

assert(reoptnodes[0] !=

);

assert(reoptnodes[0]->dualreds);

nchilds = reoptnodes[0]->

;

assert(reoptnodes[0]->dualredscur !=

);

(*ncreatedchilds) = 0;

assert(reoptnodes[

] ==

|| reoptnodes[

]->nvars == 0);

assert(reoptnodes[

]->varssize >= nbndchgs);

assert(reoptnodes[

]->nvars == 0);

assert(reoptnodes[

]->vars !=

);

assert(reoptnodes[

]->varbounds !=

);

assert(reoptnodes[

]->varboundtypes !=

);

( !

->reopt_usesplitcons )

assert(perm ==

);

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

++reoptnodes[id]->

;

( !

->reopt_usesplitcons )

assert(reoptnodes[

]->nvars == reoptnodes[0]->dualredscur->

);

assert(reoptnodes[0]->nchilds == 0);

++(*ncreatedchilds);

(

->reopt_usesplitcons )

assert(*ncreatedchilds == 1);

consdata = reoptnodes[id]->

[0];

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

( nbinvars == nbndchgs )

assert(nintvars > 0 || ncontvars > 0);

++reoptnodes[id]->

;

++(*ncreatedchilds);

assert(*ncreatedchilds == 1);

assert(perm !=

);

boundtypes = reoptnodes[0]->

->boundtypes;

assert(perm[0] == 0 && perm[nvars-1] == nvars-1);

(

->reopt_varorderinterdiction)

(

c = 0; c < nvars; ++c )

assert(reoptnodes[

] ==

|| reoptnodes[

]->nvars == 0);

assert(reoptnodes[

]->varssize >= perm[c]+1);

assert(reoptnodes[

]->nvars == 0);

assert(reoptnodes[

]->vars !=

);

assert(reoptnodes[

]->varbounds !=

);

assert(reoptnodes[

]->varboundtypes !=

);

(

->reopt_varorderinterdiction ==

)

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

reoptnodes[id]->

[v] = vars[v];

reoptnodes[id]->

[v] = bounds[v];

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

reoptnodes[id]->

[v] = vars[perm[v]];

reoptnodes[id]->

[v] = bounds[perm[v]];

reoptnodes[id]->

+= c;

reoptnodes[id]->

[c] = vars[perm[c]];

reoptnodes[id]->

[c] = bounds[perm[c]];

++reoptnodes[id]->

;

++(*ncreatedchilds);

assert(*ncreatedchilds == nvars+1);

assert(perm ==

);

assert(reoptnodes[0]->dualredscur->

!=

);

assert(reoptnodes[0]->dualredscur->vals !=

);

assert(reoptnodes[0]->dualredscur->boundtypes !=

);

assert(reopt !=

);

assert(node !=

);

assert(id < reopt->reopttree->reoptnodessize);

* nbndchgsafterdual

nafterdualvars2;

assert(reopt !=

);

assert(reoptnode !=

);

assert(vars !=

);

assert(vals !=

);

assert(boundtypes !=

);

(*nbndchgs) = reoptnode->

;

( varssize == 0 || varssize < *nbndchgs + *nbndchgsafterdual )

( v = 0; v < *nbndchgs; ++v )

vars[v] = reoptnode->

[v];

( ; v < *nbndchgs + *nbndchgsafterdual; ++v )

(reopt, parent, &vars[v], &vals[v], &boundtypes[v], varssize, &nvars2, &nafterdualvars2);

(*nbndchgs) += nvars2;

(*nbndchgsafterdual) += nafterdualvars2;

assert(reopt !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(blkmem !=

);

* ncreatedchilds,

assert(reopt !=

);

assert(stat !=

);

assert(transprob !=

);

assert(origprob !=

);

assert(tree !=

);

assert(lp !=

);

assert(branchcand !=

);

assert(eventqueue !=

);

assert(cliquetable !=

);

assert(blkmem !=

);

assert(reoptnode !=

);

assert(childnodes !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(success !=

);

(

->reopt_usesplitcons )

(*ncreatedchilds) = 1;

(*ncreatedchilds) = 2;

( childnodessize < *ncreatedchilds )

(

c = 0; c < *ncreatedchilds; ++c )

cliquetable, blkmem, childnodes[c],

, c == 1) );

(

(reopt,

,

, stat, blkmem, transprob, origprob, tree, lp, branchcand,

eventqueue, cliquetable, childnodes[c],

) );

( reoptnode->

== 0 )

(

(reopt,

, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,

blkmem, childnodes[c],

,

) );

boundtypes = reoptnode->

->boundtypes;

*ncreatedchilds = nvars+1;

( childnodessize < *ncreatedchilds )

(

c = 0; c < nvars; ++c )

(

->reopt_varorderinterdiction)

(

c = nvars; c >= 0; --c )

cliquetable, blkmem, childnodes[c],

,

) );

(

(reopt,

, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,

blkmem, childnodes[c],

,

) );

(

(reopt,

, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,

blkmem, childnodes[c],

, perm, vars, bounds, boundtypes, nvars, c) );

(*ncreatedchilds) = 1;

( childnodessize < *ncreatedchilds )

cliquetable, blkmem, childnodes[0],

,

) );

assert(reopt !=

);

assert(reopt !=

);

assert(stat !=

);

assert(blkmem !=

);

(

c = reopt->

-1; c >= 0; --c )

assert(reopt->

[c]->nvars > 0);

(

v = 0; v < reopt->

[c]->nvars; ++v )

(

,

( nbinvars == reopt->

[c]->nvars )

(

v = 0; v < reopt->

[c]->nvars; ++v )

consvars[v] = reopt->

[c]->vars[v];

consvars,

,

,

,

,

,

,

,

,

,

) );

assert(reopt->

[c]->nvars == nbinvars + 2*nintvars);

(

,

, nbinvars, (

) (2*nintvars));

assert(reopt !=

);

assert(node !=

);

assert(sepastore !=

);

assert(blkmem !=

);

assert(stat !=

);

assert(eventqueue !=

);

assert(eventfilter !=

);

assert(lp !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(reoptnode !=

);

(

c = reoptnode->

-1; c >= 0; --c )

cons = reoptnode->

[c];

assert(cons !=

);

(

v = 0; v < cons->nvars; ++v )

assert(transvar !=

);

vals[ncols] = cons->vals[v];

assert(cols[ncols] !=

);

assert(ncols == cons->nvars);

infeasible =

;

(

(&cut, blkmem,

, stat, cutname, ncols, cols, vals, cons->lhs, cons->rhs,

(

,

, cutname,

(

(&cut, blkmem,

, stat, cutname, ncols, cols, vals, cons->lhs, cons->rhs,

(

(sepastore, blkmem,

, stat, eventqueue, eventfilter, lp, cut,

, root,

(

,

, cutname,

(

i = c-1; i >= 0; --i )

assert(reopt !=

);

assert(node !=

);

assert(id < reopt->reopttree->reoptnodessize);

assert(reoptnode !=

);

reoptnode->

= 0;

assert(reopt !=

);

assert(blkmem !=

);

assert(reoptnode !=

);

assert(reoptnode !=

);

assert(blkmem !=

);

assert(reoptnode !=

);

assert(var !=

);

assert(blkmem !=

);

nvars = reoptnode->

;

reoptnode->

[nvars] = var;

++reoptnode->

;

assert(reoptnode !=

);

assert(vars !=

);

assert(bounds !=

);

assert(blkmem !=

);

(

,

);

assert(boundtypes !=

);

newbound = bounds[0] + 1.0;

newbound = bounds[0] - 1.0;

nconss = reoptnode->

;

( boundtypes !=

)

reoptnode->

[nconss]->boundtypes =

;

reoptnode->

[nconss]->varssize = nvars;

reoptnode->

[nconss]->nvars = nvars;

reoptnode->

[nconss]->lhs = lhs;

reoptnode->

[nconss]->rhs = rhs;

reoptnode->

[nconss]->constype = constype;

reoptnode->

[nconss]->linear = linear;

assert(reopt !=

);

assert(blkmem !=

);

assert(cons !=

);

assert(reopt !=

);

assert(transprob !=

);

(

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

assert(reopt !=

);

assert(transprob !=

);

(

i = 0; i < nconss; ++i )

assert(reopt !=

);

assert(transprob !=

);

(

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

assert(reopt !=

);

assert(cons !=

);

assert(reopt !=

);

assert(cons !=

);

void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)

void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)

SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)

void SCIPclockFree(SCIP_CLOCK **clck)

SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)

internal methods for clocks and timing issues

void SCIPconsCapture(SCIP_CONS *cons)

SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)

SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)

SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)

internal methods for constraints and constraint handlers

constraint handler for bound disjunction constraints

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

Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...

Constraint handler for the set partitioning / packing / covering constraints .

SCIP_RETCODE SCIPcutpoolAddRow(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_ROW *row)

internal methods for storing cuts in a cut pool

common defines and data types used in all packages of SCIP

#define SCIP_LONGINT_FORMAT

SCIP_RETCODE SCIPeventhdlrCreate(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

internal methods for managing events

SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_Real * SCIPgetBoundsBounddisjunction(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsBasicBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)

SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsBounddisjunctionRedundant(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, 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_BOUNDTYPE * SCIPgetBoundtypesBounddisjunction(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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_VAR ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)

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_VAR ** SCIPgetVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)

@ SCIP_SETPPCTYPE_PARTITIONING

@ SCIP_SETPPCTYPE_COVERING

@ SCIP_SETPPCTYPE_PACKING

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPgetNOrigVars(SCIP *scip)

void SCIPhashmapFree(SCIP_HASHMAP **hashmap)

SCIP_Real SCIPhashmapGetImageReal(SCIP_HASHMAP *hashmap, void *origin)

SCIP_RETCODE SCIPhashmapInsertReal(SCIP_HASHMAP *hashmap, void *origin, SCIP_Real image)

SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)

SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)

void SCIPhashsetFree(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem)

SCIP_Bool SCIPhashsetExists(SCIP_HASHSET *hashset, void *element)

void SCIPhashsetRemoveAll(SCIP_HASHSET *hashset)

SCIP_RETCODE SCIPhashsetInsert(SCIP_HASHSET *hashset, BMS_BLKMEM *blkmem, void *element)

SCIP_RETCODE SCIPhashsetCreate(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem, int size)

SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)

void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)

void SCIPrandomPermuteIntArray(SCIP_RANDNUMGEN *randnumgen, int *array, int begin, int end)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)

const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)

SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)

SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)

SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)

SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)

SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)

const char * SCIPheurGetName(SCIP_HEUR *heur)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

void SCIPnodeGetAncestorBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)

void SCIPnodeSetReopttype(SCIP_NODE *node, SCIP_REOPTTYPE reopttype)

void SCIPnodeSetReoptID(SCIP_NODE *node, unsigned int id)

void SCIPnodeGetAncestorBranchingsPart(SCIP_NODE *node, SCIP_NODE *parent, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)

SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)

SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)

void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)

SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)

SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)

int SCIPnodeGetNAddedConss(SCIP_NODE *node)

void SCIPnodeGetAddedConss(SCIP_NODE *node, SCIP_CONS **addedconss, int *naddedconss, int addedconsssize)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_REOPTTYPE SCIPnodeGetReopttype(SCIP_NODE *node)

unsigned int SCIPnodeGetReoptID(SCIP_NODE *node)

SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)

SCIP_Bool SCIPisReoptEnabled(SCIP *scip)

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

int SCIProwGetAge(SCIP_ROW *row)

int SCIProwGetNLPNonz(SCIP_ROW *row)

int SCIProwGetLPPos(SCIP_ROW *row)

SCIP_Real SCIProwGetConstant(SCIP_ROW *row)

SCIP_Real * SCIProwGetVals(SCIP_ROW *row)

SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)

SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)

SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)

SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

int SCIPgetEffectiveRootDepth(SCIP *scip)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)

SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

int SCIPvarGetIndex(SCIP_VAR *var)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)

SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)

SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)

int SCIPqueueNElems(SCIP_QUEUE *queue)

unsigned int SCIPqueueRemoveUInt(SCIP_QUEUE *queue)

void SCIPqueueFree(SCIP_QUEUE **queue)

SCIP_RETCODE SCIPqueueInsertUInt(SCIP_QUEUE *queue, unsigned int elem)

SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)

void SCIPqueueClear(SCIP_QUEUE *queue)

SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)

void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)

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

void SCIPhistoryReset(SCIP_HISTORY *history)

SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)

SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)

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

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

void SCIPhistoryIncNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, int depth)

void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)

void SCIPhistoryUnite(SCIP_HISTORY *history, SCIP_HISTORY *addhistory, SCIP_Bool switcheddirs)

internal methods for branching and inference history

SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)

SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_Real SCIPlpGetCutoffbound(SCIP_LP *lp)

SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)

int SCIPlpGetNRows(SCIP_LP *lp)

SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

internal methods for LP management

methods for block memory pools and memory buffers

memory allocation routines

#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)

#define BMSfreeMemory(ptr)

#define BMSfreeBlockMemory(mem, ptr)

#define BMSallocBlockMemory(mem, ptr)

#define BMSreallocMemoryArray(ptr, num)

#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)

#define BMSallocMemoryArray(ptr, num)

#define BMSfreeMemoryArray(ptr)

#define BMSallocBlockMemoryArray(mem, ptr, num)

#define BMSfreeBlockMemoryNull(mem, ptr)

#define BMSfreeBlockMemoryArray(mem, ptr, num)

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

#define BMSallocClearBlockMemoryArray(mem, ptr, num)

#define BMSclearMemoryArray(ptr, num)

#define BMSallocClearMemoryArray(ptr, num)

struct BMS_BlkMem BMS_BLKMEM

#define BMSallocMemory(ptr)

void SCIPrandomFree(SCIP_RANDNUMGEN **randnumgen, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPrandomCreate(SCIP_RANDNUMGEN **randnumgen, BMS_BLKMEM *blkmem, unsigned int initialseed)

internal miscellaneous methods

internal methods for collecting primal CIP solutions and primal informations

SCIP_CONS ** SCIPprobGetConss(SCIP_PROB *prob)

int SCIPprobGetNConss(SCIP_PROB *prob)

int SCIPprobGetNVars(SCIP_PROB *prob)

SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)

SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)

internal methods for storing and manipulating the main problem

#define SCIPdebugPrintCons(x, y, z)

static SCIP_RETCODE reoptMoveIDs(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id1, unsigned int id2)

SCIP_RETCODE SCIPreoptUpdateVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_VAR **vars, int nvars)

static SCIP_RETCODE changeReopttypeOfSubtree(SCIP_REOPTTREE *reopttree, unsigned int id, SCIP_REOPTTYPE reopttype)

int SCIPreoptGetNDualBndchgs(SCIP_REOPT *reopt, SCIP_NODE *node)

SCIP_RETCODE SCIPreoptSaveActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)

static int soltreeNInducedSols(SCIP_SOLNODE *solnode)

int SCIPreoptGetNTotalPrunedNodes(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptnodeReset(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTNODE *reoptnode)

SCIP_RETCODE SCIPreoptAddRun(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **origvars, int norigvars, int size)

SCIP_RETCODE SCIPreoptAddCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons)

int SCIPreoptGetNTotalFeasNodes(SCIP_REOPT *reopt)

void SCIPreoptAddNCheckedSols(SCIP_REOPT *reopt, int ncheckedsols)

static SCIP_RETCODE ensureSolsSize(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int num, int runidx)

static SCIP_RETCODE reopttreeDeleteNode(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id, SCIP_Bool softreset)

int SCIPreoptGetFirstRestarts(SCIP_REOPT *reopt)

static SCIP_RETCODE saveAfterDualBranchings(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool *transintoorig)

SCIP_RETCODE SCIPreoptAddSol(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem, SCIP_SOL *sol, SCIP_Bool bestsol, SCIP_Bool *added, SCIP_VAR **vars, int nvars, int run)

int SCIPreoptGetNTotalRestartsLocal(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptCheckCutoff(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_EVENTTYPE eventtype, SCIP_LP *lp, SCIP_LPSOLSTAT lpsolstat, SCIP_Bool isrootnode, SCIP_Bool isfocusnode, SCIP_Real lowerbound, int effectiverootdepth)

static SCIP_RETCODE transformDualredsToBounddisjunction(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTCONSDATA *consdata, SCIP_REOPTCONSDATA *dualreds)

static SCIP_RETCODE transformIntoOrig(SCIP_REOPT *reopt, unsigned int id)

static SCIP_RETCODE saveLocalConssData(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id)

int SCIPreoptGetNImprovingSols(SCIP_REOPT *reopt)

static SCIP_RETCODE addGlobalCut(SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int nvars, int nbinvars, int nintvars)

static SCIP_RETCODE addNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_REOPTTYPE reopttype, SCIP_Bool saveafterdual, SCIP_Bool isrootnode, SCIP_Real lowerbound)

static SCIP_RETCODE shrinkNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node, unsigned int id, SCIP_Bool *shrank, BMS_BLKMEM *blkmem)

static void deleteLastDualBndchgs(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptAddInfNode(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node)

static SCIP_RETCODE clearReoptnodes(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool softreset)

static SCIP_RETCODE reoptResetTree(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool softreset)

SCIP_RETCODE SCIPreoptApplyCuts(SCIP_REOPT *reopt, SCIP_NODE *node, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool root)

static SCIP_RETCODE reopttreeCheckMemory(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)

SCIP_SOL * SCIPreoptGetLastBestSol(SCIP_REOPT *reopt)

static SCIP_RETCODE separateSolution(SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_VAR **vars, int nvars)

SCIP_RETCODE SCIPreoptnodeAddBndchg(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE boundtype)

SCIP_RETCODE SCIPreoptnodeAddCons(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, SCIP_Real lhs, SCIP_Real rhs, int nvars, REOPT_CONSTYPE constype, SCIP_Bool linear)

SCIP_RETCODE SCIPreoptSplitRoot(SCIP_REOPT *reopt, SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, int *ncreatedchilds, int *naddedconss)

#define DEFAULT_MEM_DUALCONS

static SCIP_RETCODE createSolTree(SCIP_SOLTREE *soltree, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPreoptGetSolsRun(SCIP_REOPT *reopt, int run, SCIP_SOL **sols, int solssize, int *nsols)

static SCIP_DECL_EVENTEXITSOL(eventExitsolReopt)

static void resetStats(SCIP_REOPT *reopt)

static SCIP_RETCODE reoptRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)

static SCIP_RETCODE fixBounds(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool updatedualconss)

SCIP_Bool SCIPreoptConsCanBeDeleted(SCIP_REOPT *reopt, SCIP_CONS *cons)

static SCIP_RETCODE freeReoptTree(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)

int SCIPreoptGetNPrunedNodes(SCIP_REOPT *reopt)

int SCIPreoptGetNFeasNodes(SCIP_REOPT *reopt)

static SCIP_RETCODE reoptnodeDelete(SCIP_REOPTNODE **reoptnode, BMS_BLKMEM *blkmem)

static int reoptGetNLeaves(SCIP_REOPT *reopt, unsigned int id)

static SCIP_RETCODE saveGlobalCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, REOPT_CONSTYPE consttype)

static SCIP_RETCODE deleteChildrenBelow(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id, SCIP_Bool delnodeitself, SCIP_Bool exitsolve)

SCIP_RETCODE SCIPreoptDeleteNode(SCIP_REOPT *reopt, SCIP_SET *set, unsigned int id, BMS_BLKMEM *blkmem)

SCIP_Real SCIPreoptnodeGetLowerbound(SCIP_REOPTNODE *reoptnode)

static SCIP_RETCODE reoptnodeReset(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem)

int SCIPreoptGetNRestartsLocal(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptReleaseData(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPreoptResetDualBndchgs(SCIP_REOPT *reopt, SCIP_NODE *node, BMS_BLKMEM *blkmem)

void SCIPreoptResetSolMarks(SCIP_REOPT *reopt)

static SCIP_RETCODE getInferenceOrder(SCIP_SET *set, SCIP_STAT *stat, int *perm, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int nvars)

static SCIP_RETCODE freeSolTree(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)

int SCIPreoptGetNSols(SCIP_REOPT *reopt)

int SCIPreoptGetNSolsRun(SCIP_REOPT *reopt, int run)

void SCIPreoptnodeSetParentID(SCIP_REOPTNODE *reoptnode, unsigned int parentid)

SCIP_Real SCIPreoptGetSimToFirst(SCIP_REOPT *reopt)

static SCIP_RETCODE saveConsBounddisjuction(SCIP_REOPTCONSDATA *reoptconsdata, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons, SCIP_Bool *success)

static SCIP_RETCODE reoptAddChild(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int parentid, unsigned int childid)

SCIP_RETCODE SCIPreoptApply(SCIP_REOPT *reopt, SCIP *scip, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_REOPTNODE *reoptnode, unsigned int id, SCIP_Real estimate, SCIP_NODE **childnodes, int *ncreatedchilds, int *naddedconss, int childnodessize, SCIP_Bool *success)

#define DEFAULT_MEM_VARAFTERDUAL

int SCIPreoptGetNSavedSols(SCIP_REOPT *reopt)

#define DEFAULT_MEM_NODES

SCIP_Real SCIPreoptGetOldObjCoef(SCIP_REOPT *reopt, int run, int idx)

static void soltreeResetMarks(SCIP_SOLNODE *node)

static SCIP_RETCODE reoptnodeCheckMemory(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, int var_mem, int child_mem, int conss_mem)

static SCIP_RETCODE cleanActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)

static SCIP_DECL_EVENTEXEC(eventExecReopt)

int SCIPreoptGetNCheckedSols(SCIP_REOPT *reopt)

static SCIP_RETCODE reoptGetLeaves(SCIP_REOPT *reopt, unsigned int id, unsigned int *leaves, int leavessize, int *nleaves)

static SCIP_RETCODE getLastSavedNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node, SCIP_NODE **parent, unsigned int *parentid, int *nbndchgs)

static SCIP_RETCODE reoptCheckLocalRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR **transvars, int ntransvars, SCIP_Bool *localrestart)

static SCIP_RETCODE storeCuts(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_LP *lp, unsigned int id)

static SCIP_RETCODE transformDualredsToLinear(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTCONSDATA *consdata, SCIP_REOPTCONSDATA *dualreds)

SCIP_RETCODE SCIPreoptFree(SCIP_REOPT **reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)

static SCIP_RETCODE addLocalConss(SCIP *scip, SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id)

int SCIPreoptnodeGetNConss(SCIP_REOPTNODE *reoptnode)

static SCIP_RETCODE solnodeAddChild(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_SOLNODE *curnode, SCIP_SOLNODE **child, SCIP_VAR *var, SCIP_Real val, SCIP_Bool *added)

void SCIPreoptnodeGetConss(SCIP_REOPTNODE *reoptnode, SCIP_VAR ***vars, SCIP_Real **bounds, SCIP_BOUNDTYPE **boundtypes, int mem, int *nconss, int *nvars)

static SCIP_RETCODE checkMemGlbCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int mem)

int SCIPreoptGetLastRestarts(SCIP_REOPT *reopt)

static SCIP_RETCODE reoptnodeResetDualConss(SCIP_REOPTNODE *reoptnode, BMS_BLKMEM *blkmem)

static SCIP_RETCODE createReopttree(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)

int SCIPreoptnodeGetNVars(SCIP_REOPTNODE *reoptnode)

static SCIP_RETCODE ensureActiveconssSize(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int num)

int SCIPreoptGetNTotalCutoffReoptnodes(SCIP_REOPT *reopt)

static int reopttreeGetNNodes(SCIP_REOPTTREE *reopttree, unsigned int id)

static SCIP_RETCODE createReoptnode(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id)

void SCIPreoptnodeGetPath(SCIP_REOPT *reopt, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int varssize, int *nbndchgs, int *nbndchgsafterdual)

SCIP_RETCODE SCIPreoptAddOptSol(SCIP_REOPT *reopt, SCIP_SOL *sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, SCIP_VAR **vars, int nvars)

SCIP_REOPTTYPE SCIPreoptnodeGetType(SCIP_REOPTNODE *reoptnode)

int SCIPreoptGetNNodes(SCIP_REOPT *reopt, SCIP_NODE *node)

static SCIP_RETCODE moveChildrenUp(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int nodeid, unsigned int parentid)

SCIP_Real SCIPreoptGetSavingtime(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptResetActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPreoptnodeDelete(SCIP_REOPTNODE **reoptnode, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPreoptCreate(SCIP_REOPT **reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)

int SCIPreoptGetNTotalInfNodes(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptAddDualBndchg(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newval, SCIP_Real oldval)

static SCIP_Real reoptSimilarity(SCIP_REOPT *reopt, SCIP_SET *set, int obj1_id, int obj2_id, SCIP_VAR **vars, int nvars)

static SCIP_RETCODE collectDualInformation(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_REOPTTYPE reopttype)

SCIP_Real SCIPreoptGetSimilarity(SCIP_REOPT *reopt, SCIP_SET *set, int run1, int run2, SCIP_VAR **origvars, int norigvars)

static SCIP_RETCODE ensureRunSize(SCIP_REOPT *reopt, SCIP_SET *set, int num, BMS_BLKMEM *blkmem)

static SCIP_RETCODE dryBranch(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool *runagain, unsigned int id)

static SCIP_RETCODE soltreefreeNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SOLNODE **solnode)

SCIP_RETCODE SCIPreoptGetLeaves(SCIP_REOPT *reopt, SCIP_NODE *node, unsigned int *leaves, int leavessize, int *nleaves)

static SCIP_RETCODE updatePropagation(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool *transintoorig)

static SCIP_RETCODE soltreeAddSol(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem, SCIP_VAR **vars, SCIP_SOL *sol, SCIP_SOLNODE **solnode, int nvars, SCIP_Bool bestsol, SCIP_Bool *added)

int SCIPreoptGetNAddedConss(SCIP_REOPT *reopt, SCIP_NODE *node)

SCIP_RETCODE SCIPreoptMergeVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **vars, int nvars)

static SCIP_DECL_EVENTINITSOL(eventInitsolReopt)

static SCIP_RETCODE checkMemDualCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int size)

static SCIP_RETCODE fixInterdiction(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, int *perm, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int nvars, int negbndchg)

SCIP_RETCODE SCIPreoptSaveGlobalBounds(SCIP_REOPT *reopt, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)

SCIP_REOPTNODE * SCIPreoptGetReoptnode(SCIP_REOPT *reopt, unsigned int id)

void SCIPreoptAddNImprovingSols(SCIP_REOPT *reopt, int nimprovingsols)

static SCIP_RETCODE reoptnodeUpdateDualConss(SCIP_REOPTNODE *reoptnode, BMS_BLKMEM *blkmem)

SCIP_Bool SCIPreoptGetSolveLP(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node)

SCIP_RETCODE SCIPreoptCheckRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR **transvars, int ntransvars, SCIP_Bool *restart)

static SCIP_RETCODE addSplitcons(SCIP_REOPT *reopt, SCIP *scip, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_NODE *node, unsigned int id)

int SCIPreoptGetNCutoffReoptnodes(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptInstallBounds(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem)

static SCIP_RETCODE reoptSaveNewObj(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **origvars, int norigvars)

int SCIPreoptnodeGetNChildren(SCIP_REOPTNODE *reoptnode)

SCIP_RETCODE SCIPreoptApplyGlbConss(SCIP *scip, SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPreoptApplyCompression(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTNODE **representatives, int nrepresentatives, SCIP_Bool *success)

static SCIP_RETCODE changeAncestorBranchings(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool afterdualbranching)

int SCIPreoptnodeGetNDualBoundChgs(SCIP_REOPTNODE *reoptnode)

SCIP_Real SCIPreoptGetSimToPrevious(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptReset(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)

SCIP_RETCODE SCIPreoptGetChildIDs(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int *childs, int childssize, int *nchilds)

static SCIP_RETCODE saveAncestorBranchings(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_NODE *parent, unsigned int id, unsigned int parentid)

int SCIPreoptGetNRestartsGlobal(SCIP_REOPT *reopt)

SCIP_RETCODE SCIPreoptSaveOpenNodes(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_NODE **leaves, int nleaves, SCIP_NODE **childs, int nchilds, SCIP_NODE **siblings, int nsiblings)

static SCIP_RETCODE saveConsLinear(SCIP_REOPTCONSDATA *reoptconsdata, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons, SCIP_Bool *success)

SCIP_SOL * SCIPreoptGetBestSolRun(SCIP_REOPT *reopt, int run)

void SCIPreoptnodeInit(SCIP_REOPTNODE *reoptnode, SCIP_SET *set)

int SCIPreoptGetNLeaves(SCIP_REOPT *reopt, SCIP_NODE *node)

int SCIPreoptGetNInfNodes(SCIP_REOPT *reopt)

data structures and methods for collecting reoptimization information

SCIP_RETCODE SCIPsepastoreAddCut(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool root, SCIP_Bool *infeasible)

internal methods for storing separated cuts

SCIP_Bool SCIPsetIsGE(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 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_Real SCIPsetInfinity(SCIP_SET *set)

SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)

SCIP_RETCODE SCIPsetIncludeEventhdlr(SCIP_SET *set, SCIP_EVENTHDLR *eventhdlr)

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_BRANCHRULE * SCIPsetFindBranchrule(SCIP_SET *set, const char *name)

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

SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)

int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)

SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)

unsigned int SCIPsetInitializeRandomSeed(SCIP_SET *set, unsigned int initialseedvalue)

internal methods for global SCIP settings

#define SCIPsetFreeBufferArray(set, ptr)

#define SCIPsetAllocBufferArray(set, ptr, num)

#define SCIPsetReallocBufferArray(set, ptr, num)

SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)

SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)

SCIP_RETCODE SCIPsolCopy(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_SOL *sourcesol)

internal methods for storing primal CIP solutions

SCIP_Real pscostweightedmean[2]

SCIP_Real pscostvariance[2]

SCIP_VAR ** afterdualvars

SCIP_REOPTCONSDATA * dualredscur

SCIP_REOPTCONSDATA * dualredsnex

SCIP_BOUNDTYPE * afterdualvarboundtypes

SCIP_BOUNDTYPE * varboundtypes

SCIP_Real * afterdualvarbounds

SCIP_REOPTCONSDATA ** conss

unsigned int reoptnodessize

SCIP_REOPTNODE ** reoptnodes

int ntotalcutoffreoptnodes

SCIP_REOPTCONSDATA ** glbconss

SCIP_REOPTTREE * reopttree

SCIP_REOPTCONSDATA * dualreds

SCIP_Longint lastbranched

SCIP_RANDNUMGEN * randnumgen

SCIP_Longint lastseennode

SCIP_HASHSET * activeconssset

SCIP_HISTORY *** varhistory

void SCIPnodeGetDualBoundchgs(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int *nvars, int varssize)

void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)

void SCIPnodeGetPropsAfterDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *nvars, int varssize)

SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)

SCIP_RETCODE SCIPnodeCreateChild(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real nodeselprio, SCIP_Real estimate)

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 SCIPnodeGetNDualBndchgs(SCIP_NODE *node)

void SCIPnodeGetPropsBeforeDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *npropvars, int propvarssize)

internal methods for branch and bound tree

#define SCIP_EVENTTYPE_NODEFEASIBLE

#define SCIP_EVENTTYPE_GBDCHANGED

#define SCIP_EVENTTYPE_NODEINFEASIBLE

#define SCIP_EVENTTYPE_NODEBRANCHED

#define SCIP_EVENTTYPE_FORMAT

@ SCIP_BRANCHDIR_DOWNWARDS

enum SCIP_BranchDir SCIP_BRANCHDIR

enum SCIP_LPSolStat SCIP_LPSOLSTAT

@ SCIP_ROWORIGINTYPE_REOPT

@ SCIP_ROWORIGINTYPE_SEPA

enum SCIP_BoundType SCIP_BOUNDTYPE

@ SCIP_LPSOLSTAT_NOTSOLVED

@ SCIP_LPSOLSTAT_INFEASIBLE

@ SCIP_LPSOLSTAT_OBJLIMIT

@ SCIP_REOPTTYPE_INFSUBTREE

@ SCIP_REOPTTYPE_LOGICORNODE

@ SCIP_REOPTTYPE_FEASIBLE

@ SCIP_REOPTTYPE_STRBRANCHED

enum SCIP_ReoptType SCIP_REOPTTYPE

struct SCIP_ReoptConsData SCIP_REOPTCONSDATA

@ REOPT_CONSTYPE_DUALREDS

@ REOPT_CONSTYPE_INFSUBTREE

enum Reopt_ConsType REOPT_CONSTYPE

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_NODETYPE_PROBINGNODE

@ SCIP_NODETYPE_FOCUSNODE

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

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

SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)

SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)

SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)

SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)

SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)

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

SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)

internal methods for problem variables

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