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

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

SCIP Doxygen Documentation: cons_varbound.c Source File

presolved:1;

varboundsadded:1;

changed:1;

tightened:1;

SCIP_ConshdlrData

assert(elem1 !=

);

assert(elem2 !=

);

assert(consdata1 !=

);

assert(consdata2 !=

);

&& !consdata1->changed && consdata2->changed) )

&& (consdata1->changed == consdata2->changed) )

assert(conshdlrdata !=

);

(*conshdlrdata)->eventhdlr = eventhdlr;

assert(conshdlrdata !=

);

assert(*conshdlrdata !=

);

assert(cons !=

);

assert(eventhdlr !=

);

assert(consdata !=

);

assert(cons !=

);

assert(eventhdlr !=

);

assert(consdata !=

);

assert(consdata !=

);

(

);

(*consdata)->var = var;

(*consdata)->vbdvar = vbdvar;

(*consdata)->vbdcoef = vbdcoef;

(*consdata)->lhs = lhs;

(*consdata)->rhs = rhs;

(*consdata)->row =

;

(*consdata)->nlrow =

;

(*consdata)->presolved =

;

(*consdata)->varboundsadded =

;

(*consdata)->changed =

;

(*consdata)->tightened =

;

assert(consdata !=

);

assert(*consdata !=

);

( (*consdata)->row !=

)

( (*consdata)->nlrow !=

)

assert(consdata !=

);

assert(consdata->row ==

);

assert(consdata !=

);

( conshdlr ==

)

assert(conshdlrdata !=

);

( consdata->row ==

)

assert(consdata->row !=

);

assert(consdata !=

);

( consdata->nlrow ==

)

assert(consdata->lhs <= consdata->rhs);

vars[0] = consdata->var;

vars[1] = consdata->vbdvar;

coefs[1] = consdata->vbdcoef;

assert(consdata->nlrow !=

);

assert(consdata !=

);

(

,

,

absviol =

(consdata->lhs - sum, sum - consdata->rhs);

relviol =

(lhsrelviol, rhsrelviol);

assert(consdata !=

);

assert(var !=

);

vbdvar = consdata->vbdvar;

assert(vbdvar !=

);

vbdcoef = consdata->vbdcoef;

assert(infervar == var);

assert(infervar == vbdvar);

assert(infervar == var);

assert(infervar == vbdvar);

( usebdwidening )

relaxedub = inferbd - 1.0;

assert(consdata !=

);

assert(infervar == consdata->var);

abscoef =

(consdata->vbdcoef);

inferbd = inferbd + 1.0;

assert(consdata !=

);

assert(infervar == consdata->var);

abscoef =

(consdata->vbdcoef);

( usebdwidening )

relaxedlb = inferbd + 1.0;

assert(consdata !=

);

assert(infervar == consdata->var);

abscoef =

(consdata->vbdcoef);

inferbd = inferbd - 1.0;

assert(consdata !=

);

assert(infervar == consdata->var);

abscoef =

(consdata->vbdcoef);

assert(cons !=

);

assert(result !=

);

assert(consdata !=

);

( conshdlr ==

)

var = consdata->var;

vbdvar = consdata->vbdvar;

vbdcoef = consdata->vbdcoef;

&cutoff, &tightened) );

( tightened )

&cutoff, &tightened) );

( tightened )

( consdata->row ==

)

assert(consdata->row !=

);

assert(cons !=

);

assert(consdata !=

);

assert(consdata->var !=

&& consdata->vbdvar !=

);

assert(consdata->row ==

);

consdata->rhs = lhs;

( consdata->vbdcoef > 0.0 )

( consdata->vbdcoef > 0.0 )

consdata->varboundsadded =

;

consdata->tightened =

;

consdata->presolved =

;

consdata->lhs = lhs;

consdata->changed =

;

assert(cons !=

);

assert(consdata !=

);

assert(consdata->var !=

&& consdata->vbdvar !=

);

assert(consdata->row ==

);

consdata->lhs = rhs;

( consdata->vbdcoef > 0.0 )

( consdata->vbdcoef > 0.0 )

consdata->varboundsadded =

;

consdata->tightened =

;

consdata->presolved =

;

consdata->rhs = rhs;

consdata->changed =

;

assert(cutoff !=

);

assert(nchgbds !=

);

assert(consdata !=

);

(

,

,

tightenedround =

;

( consdata->vbdcoef > 0.0 )

tightenedround =

;

( consdata->vbdcoef > 0.0 )

( newlb > ylb + 0.5 )

tightenedround =

;

( newub < yub - 0.5 )

tightenedround =

;

( consdata->vbdcoef > 0.0 )

tightenedround =

;

( consdata->vbdcoef > 0.0 )

( newub < yub - 0.5 )

tightenedround =

;

( newlb > ylb + 0.5 )

tightenedround =

;

( tightenedround );

((consdata->vbdcoef > 0.0 &&

(

, xlb + consdata->vbdcoef * ylb, consdata->lhs))

|| (consdata->vbdcoef < 0.0 &&

(

, xlb + consdata->vbdcoef * yub, consdata->lhs))) )

((consdata->vbdcoef > 0.0 &&

(

, xub + consdata->vbdcoef * yub, consdata->rhs))

|| (consdata->vbdcoef < 0.0 &&

(

, xub + consdata->vbdcoef * ylb, consdata->rhs))) )

|| (consdata->vbdcoef > 0.0 &&

(

, xlb + consdata->vbdcoef * ylb, consdata->lhs))

|| (consdata->vbdcoef < 0.0 &&

(

, xlb + consdata->vbdcoef * yub, consdata->lhs)))

|| (consdata->vbdcoef > 0.0 &&

(

, xub + consdata->vbdcoef * yub, consdata->rhs))

|| (consdata->vbdcoef < 0.0 &&

(

, xub + consdata->vbdcoef * ylb, consdata->rhs))) )

(

,

,

( ndelconss !=

)

assert(var !=

);

assert(vbdvar !=

);

assert(sideequal !=

);

assert(cons0sidered !=

);

assert(cons1sidered !=

);

assert(coef0 * coef1 > 0.0);

*sideequal =

;

redundant0 = cons1sidered;

redundant1 = cons0sidered;

redundant0 = cons0sidered;

redundant1 = cons1sidered;

( !*redundant0 && !*redundant1 )

boundxlb1 = side0 - lbvbdvar * coef0;

boundxlb2 = side1 - lbvbdvar * coef1;

boundylb1 = (side0 - lbvar) / coef0;

boundylb2 = (side1 - lbvar) / coef1;

boundxub1 = side0 - ubvbdvar * coef0;

boundxub2 = side1 - ubvbdvar * coef1;

boundyub1 = (side0 - ubvar) / coef0;

boundyub2 = (side1 - ubvar) / coef1;

boundvaluex1 =

(boundxlb1, boundxlb2);

boundvaluex2 =

(boundxub1, boundxub2);

boundvaluex1 =

(boundxlb1, boundxlb2);

boundvaluex2 =

(boundxub1, boundxub2);

valuex1 =

(boundvaluex1, ubvar);

valuex1 =

(valuex1, lbvar);

valuex2 =

(boundvaluex2, lbvar);

valuex2 =

(valuex2, ubvar);

valuex1 =

(boundvaluex1, lbvar);

valuex1 =

(valuex1, ubvar);

valuex2 =

(boundvaluex2, ubvar);

valuex2 =

(valuex2, lbvar);

valuey1 = side0 / coef0;

valuey2 = side1 / coef1;

( valuex1 > 0.0 )

valuey1 = (side0 - valuex1) / coef0;

valuey2 = (side1 - valuex1) / coef1;

( coef0 > 0.0 )

( valuey1 < valuey2 )

*redundant1 =

;

*redundant0 =

;

( valuey1 < valuey2 )

*redundant0 =

;

*redundant1 =

;

valuey1 = side0 / coef0;

valuey2 = side1 / coef1;

( valuex2 > 0.0 )

valuey1 = (side0 - valuex2) / coef0;

valuey2 = (side1 - valuex2) / coef1;

assert(!(*redundant0));

assert(!(*redundant1));

*sideequal =

;

*redundant1 =

;

*sideequal =

;

*redundant0 =

;

( ( *redundant1 &&

(

, valuey1, valuey2) )

|| ( *redundant0 &&

(

, valuey1, valuey2) ) )

*redundant0 =

;

*redundant1 =

;

assert(!(*redundant0));

assert(!(*redundant1));

*sideequal =

;

*redundant0 =

;

*sideequal =

;

*redundant1 =

;

( ( *redundant0 &&

(

, valuey1, valuey2) )

|| ( *redundant1 &&

(

, valuey1, valuey2) ) )

*redundant0 =

;

*redundant1 =

;

assert(*sideequal || *redundant0 || *redundant1);

boundvaluey1 =

(boundylb1, boundylb2);

boundvaluey2 =

(boundyub1, boundyub2);

boundvaluey1 =

(boundylb1, boundylb2);

boundvaluey2 =

(boundyub1, boundyub2);

valuey1 =

(boundvaluey1, ubvbdvar);

valuey1 =

(valuey1, lbvbdvar);

valuey2 =

(boundvaluey2, lbvbdvar);

valuey2 =

(valuey2, ubvbdvar);

boundvaluey1 =

(boundylb1, boundylb2);

boundvaluey2 =

(boundyub1, boundyub2);

boundvaluey1 =

(boundylb1, boundylb2);

boundvaluey2 =

(boundyub1, boundyub2);

valuey1 =

(boundvaluey1, lbvbdvar);

valuey1 =

(valuey1, ubvbdvar);

valuey2 =

(boundvaluey2, ubvbdvar);

valuey2 =

(valuey2, lbvbdvar);

( valuey1 > 0.0 )

valuex1 = side0 - valuey1 * coef0;

valuex2 = side1 - valuey1 * coef1;

assert(!(*redundant0));

assert(!(*redundant1));

*sideequal =

;

*redundant1 =

;

*sideequal =

;

*redundant0 =

;

( ( *redundant1 &&

(

, valuex1, valuex2) )

|| ( *redundant0 &&

(

, valuex1, valuex2) ) )

*redundant0 =

;

*redundant1 =

;

( valuey2 > 0.0 )

valuex1 = side0 - valuey2 * coef0;

valuex2 = side1 - valuey2 * coef1;

assert(!(*redundant0));

assert(!(*redundant1));

*sideequal =

;

*redundant1 =

;

*sideequal =

;

*redundant0 =

;

( ( *redundant1 &&

(

, valuex1, valuex2) )

|| ( *redundant0 &&

(

, valuex1, valuex2) ) )

*redundant0 =

;

*redundant1 =

;

assert(*redundant0 || *redundant1 || *sideequal);

assert(conss !=

);

assert(cutoff !=

);

assert(nchgbds !=

);

assert(ndelconss !=

);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

((

**)sortedconss, consVarboundComp, nconss);

( c = nconss - 1; c > 0 && !(*cutoff); --c )

cons0 = sortedconss[c];

assert(consdata0 !=

);

assert(consdata0->var !=

);

assert(consdata0->vbdvar !=

);

( !consdata0->changed )

consdata0->changed =

;

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

cons1 = sortedconss[s];

assert(consdata1 !=

);

assert(consdata1->var !=

);

assert(consdata1->vbdvar !=

);

lhs = consdata0->lhs;

rhs = consdata0->rhs;

coef = consdata0->vbdcoef;

( consdata0->var == consdata1->vbdvar && consdata0->vbdvar == consdata1->var &&

scalar = (1.0 - coef * consdata1->vbdcoef);

bnd = (lhs - coef * consdata1->rhs)/scalar;

bnd = (lhs - coef * consdata1->lhs)/scalar;

bnd = (rhs - coef * consdata1->lhs)/scalar;

bnd = (rhs - coef * consdata1->rhs)/scalar;

bnd = (consdata1->lhs - consdata1->vbdcoef * rhs)/scalar;

bnd = (consdata1->lhs - consdata1->vbdcoef * lhs)/scalar;

bnd = (consdata1->rhs - consdata1->vbdcoef * lhs)/scalar;

bnd = (consdata1->rhs - consdata1->vbdcoef * rhs)/scalar;

( consdata0->var != consdata1->var || consdata0->vbdvar != consdata1->vbdvar )

deletecons1 =

;

lhs =

(consdata1->lhs, lhs);

rhs =

(consdata1->rhs, rhs);

lhs =

(consdata1->lhs, lhs);

coef = lhs -

(consdata1->lhs - consdata1->vbdcoef, consdata0->lhs - coef);

rhs =

(consdata1->rhs, rhs);

coef = rhs -

(consdata1->rhs - consdata1->vbdcoef, consdata0->rhs - coef);

(

, consdata0->var, consdata0->vbdvar, coef, consdata1->vbdcoef, lhs, consdata1->lhs, &lhsequal, &cons0lhsred, &cons1lhsred,

);

(

, consdata0->var, consdata0->vbdvar, coef, consdata1->vbdcoef, rhs, consdata1->rhs, &rhsequal, &cons0rhsred, &cons1rhsred,

);

( (lhsequal || cons0lhsred) && (rhsequal || cons0rhsred) )

( cons1lhsred && cons1rhsred )

deletecons1 =

;

deletecons1 =

;

rhs = (lhs + rhs)/2;

( consdata0->vbdcoef * coef < 0.0 )

( consdata0->vbdcoef > 0.0 )

consdata0->varboundsadded =

;

consdata0->tightened =

;

consdata0->presolved =

;

consdata0->changed =

;

consdata0->vbdcoef = coef;

assert(conss !=

|| nconss == 0);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

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

assert(conss !=

);

assert(consdata !=

);

success =

(consdata->vbdcoef, -epsilon, epsilon , maxmult, &numerator, &denominator);

denominator /= numerator;

success = success && (denominator <= maxmult);

( success &&

(denominator) > 1 && numerator == 1 )

assert(

(

, consdata->vbdcoef * denominator, 1.0));

( consdata->vbdcoef < 0 )

assert(denominator < 0);

consdata->lhs = consdata->rhs * denominator;

consdata->rhs = consdata->lhs * denominator;

tmp = consdata->lhs;

consdata->lhs = consdata->rhs * denominator;

consdata->rhs = tmp * denominator;

consdata->tightened =

;

assert(denominator > 0);

consdata->lhs *= denominator;

consdata->rhs *= denominator;

assert(

(

, consdata->rhs, consdata->lhs));

swapvar = consdata->var;

consdata->var = consdata->vbdvar;

consdata->vbdvar = swapvar;

consdata->vbdcoef = (

)denominator;

consdata->varboundsadded =

;

consdata->tightened =

;

assert(cons !=

);

assert(cutoff !=

);

assert(nchgbds !=

);

assert(ndelconss !=

);

assert(naddconss !=

);

assert(consdata !=

);

var = consdata->var;

vbdvar = consdata->vbdvar;

vbdvarconstant = 0.0;

varschanged = (var != consdata->var || vbdvar != consdata->vbdvar);

(

,

,

scalar = varscalar + consdata->vbdcoef * vbdvarscalar;

constant = varconstant + consdata->vbdcoef * vbdvarconstant;

( scalar > 0.0 )

newbnd = (consdata->lhs - constant) / scalar;

newbnd = (consdata->rhs - constant) / scalar;

newbnd = (consdata->lhs - constant) / scalar;

newbnd = (consdata->rhs - constant) / scalar;

activity = varconstant + consdata->vbdcoef * vbdvarconstant;

(

,

,

assert( consdata->vbdcoef != 0.0 );

assert( vbdvarscalar != 0.0 );

( consdata->vbdcoef > 0.0 )

newbnd = (consdata->lhs - varconstant) / consdata->vbdcoef;

( tightened )

newbnd = (consdata->lhs - varconstant) / consdata->vbdcoef;

( tightened )

( consdata->vbdcoef > 0.0 )

newbnd = (consdata->rhs - varconstant) / consdata->vbdcoef;

( tightened )

newbnd = (consdata->rhs - varconstant) / consdata->vbdcoef;

( tightened )

( var != consdata->var )

( consdata->vbdcoef > 0.0 )

( varscalar > 0.0 )

consdata->lhs = (consdata->lhs - varconstant)/varscalar;

consdata->rhs = (consdata->rhs - varconstant)/varscalar;

consdata->vbdcoef /= varscalar;

consdata->tightened =

;

assert(varscalar != 0.0);

lhs = consdata->lhs;

consdata->lhs = -consdata->rhs;

consdata->rhs = -lhs;

consdata->lhs = (consdata->lhs + varconstant)/(-varscalar);

consdata->rhs = (consdata->rhs + varconstant)/(-varscalar);

consdata->vbdcoef /= varscalar;

consdata->tightened =

;

consdata->var = var;

( consdata->vbdcoef > 0.0 )

(

,

,

newbnd = consdata->lhs - consdata->vbdcoef * vbdvarconstant;

( tightened )

newbnd = consdata->rhs - consdata->vbdcoef * vbdvarconstant;

( tightened )

( !(*cutoff) && vbdvar != consdata->vbdvar )

( consdata->vbdcoef > 0.0 )

consdata->lhs -= consdata->vbdcoef * vbdvarconstant;

consdata->rhs -= consdata->vbdcoef * vbdvarconstant;

consdata->tightened =

;

consdata->vbdcoef *= vbdvarscalar;

consdata->vbdvar = vbdvar;

( consdata->vbdcoef > 0.0 )

consdata->changed =

;

lhs = consdata->lhs;

rhs = consdata->rhs;

( var != consdata->var )

assert(var == consdata->var);

( vbdvar != consdata->vbdvar )

assert(vbdvar == consdata->vbdvar);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

assert(ndelconss !=

);

assert(consdata !=

);

( consdata->tightened )

consdata->tightened =

;

consdata->changed =

;

consdata->changed =

;

oldnchgcoefs = *nchgcoefs;

oldnchgsides = *nchgsides;

oldcoef = consdata->vbdcoef;

( (

(

, -consdata->lhs) ||

(

, consdata->vbdcoef -

(

, consdata->vbdcoef), consdata->lhs -

(

, consdata->lhs))) && (

(

, consdata->rhs) ||

(

, consdata->vbdcoef -

(

, consdata->vbdcoef), consdata->rhs -

(

, consdata->rhs))) )

( (

(

, -consdata->lhs) ||

(

, consdata->vbdcoef -

(

, consdata->vbdcoef), consdata->lhs -

(

, consdata->lhs))) && (

(

, consdata->rhs) ||

(

, consdata->vbdcoef -

(

, consdata->vbdcoef), consdata->rhs -

(

, consdata->rhs))) )

consdata->vbdcoef = oldcoef;

oldrhs = consdata->rhs;

newcoef =

(consdata->vbdcoef - consdata->rhs + xub, consdata->lhs - xlb);

newrhs = consdata->rhs - consdata->vbdcoef + newcoef;

,

consdata->lhs,

(consdata->var), xlb, xub, consdata->vbdcoef,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

consdata->rhs =

(newrhs, consdata->lhs);

consdata->tightened =

;

assert(consdata->tightened);

oldlhs = consdata->lhs;

newcoef =

(consdata->vbdcoef - consdata->lhs + xlb, consdata->rhs - xub);

newlhs = consdata->lhs - consdata->vbdcoef + newcoef;

,

consdata->lhs,

(consdata->var), xlb, xub, consdata->vbdcoef,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

consdata->lhs =

(newlhs, consdata->rhs);

consdata->tightened =

;

assert(consdata->tightened);

( consdata->vbdcoef > 0.0 &&

(

, xlb, consdata->lhs - consdata->vbdcoef) )

newcoef = consdata->lhs - xlb;

(

,

,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

( consdata->vbdcoef < 0.0 &&

(

, xlb, consdata->lhs) )

newcoef = consdata->vbdcoef - consdata->lhs + xlb;

(

,

,

(consdata->var), consdata->vbdcoef - consdata->lhs + xlb,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

consdata->lhs = xlb;

( consdata->vbdcoef > 0.0 &&

(

, xub, consdata->rhs) )

newcoef = consdata->vbdcoef - consdata->rhs + xub;

(

,

,

(consdata->var), consdata->vbdcoef - consdata->rhs + xub,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

consdata->rhs = xub;

( consdata->vbdcoef < 0.0 &&

(

, xub, consdata->rhs - consdata->vbdcoef) )

newcoef = consdata->rhs - xub;

(

,

,

assert(consdata->vbdcoef * newcoef > 0);

consdata->vbdcoef = newcoef;

( *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides )

consdata->varboundsadded =

;

consdata->changed =

;

assert(conshdlrdata !=

);

assert(conss !=

|| nconss == 0);

assert(cutoff !=

);

assert(naggrvars !=

);

assert(nchgbds !=

);

assert(nchgcoefs !=

);

assert(nchgsides !=

);

assert(ndelconss !=

);

assert(naddconss !=

);

assert(conss !=

);

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

assert(cons !=

);

assert(consdata !=

);

assert(

(

, consdata->lhs, consdata->rhs));

( !consdata->presolved )

( !consdata->tightened )

assert(

(

, consdata->lhs, consdata->rhs));

( consdata->vbdcoef > 0.0 )

(

,

,

assert(!infeasible);

assert(consdata->lhs < 0.5);

vars[0] = consdata->var;

vars[1] = consdata->vbdvar;

(

,

,

assert(!infeasible);

assert(consdata->lhs < -0.5);

vars[0] = consdata->var;

vars[1] = consdata->vbdvar;

assert(upgdcons !=

);

upgrade = (nvars == 2) && (nposbin + nnegbin <= 1) && (nposcont + nnegcont <= 1);

var = vars[1-vbdind];

vbdvar = vars[vbdind];

vbdcoef = vals[vbdind]/vals[1-vbdind];

( vals[1-vbdind] > 0.0 )

assert(cons !=

);

assert(graph !=

);

assert(success !=

);

cons, lhs, rhs, success) );

assert(conshdlr !=

);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

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

assert(consdata !=

);

( consdata->row !=

)

( consdata->nlrow !=

)

assert(conshdlrdata !=

);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

assert(sourcedata !=

);

sourcedata->var, sourcedata->vbdvar, sourcedata->vbdcoef, sourcedata->lhs, sourcedata->rhs) );

*infeasible =

;

( i = 0; i < nconss && !(*infeasible); i++ )

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

( i = nusefulconss; i < nconss && *result ==

; ++i )

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

( i = nusefulconss; i < nconss && *result ==

; ++i )

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

assert(conshdlr !=

);

assert(conshdlrdata !=

);

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

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

( i = 0; i < nconss && (*result ==

|| completely); i++ )

assert( consdata !=

);

assert(conshdlr !=

);

assert(conshdlrdata !=

);

(

,

, nmarkedconss);

( i = 0; i < nmarkedconss && !cutoff; i++ )

( nchgbds > 0 )

assert(conshdlr !=

);

assert(result !=

);

assert(conshdlrdata !=

);

oldnchgbds = *nchgbds;

oldndelconss = *ndelconss;

oldnaddconss = *naddconss;

oldnchgcoefs = *nchgcoefs;

oldnchgsides = *nchgsides;

oldnaggrvars = *naggrvars;

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

assert(cons !=

);

assert(consdata !=

);

consdata->presolved =

;

( consdata->presolved )

consdata->presolved =

;

( !consdata->varboundsadded )

localoldnchgbds;

localoldnchgbds = *nchgbds;

(

,

,

(consdata->vbdvar), (consdata->vbdcoef > 0 ?

:

), 1.0/-consdata->vbdcoef,

(consdata->var), consdata->lhs/consdata->vbdcoef);

&infeasible, &nlocalchgbds) );

assert(!infeasible);

*nchgbds += nlocalchgbds;

(

,

,

(consdata->vbdvar), (consdata->vbdcoef > 0 ?

:

), 1.0/-consdata->vbdcoef,

(consdata->var), consdata->rhs/consdata->vbdcoef);

&infeasible, &nlocalchgbds) );

assert(!infeasible);

*nchgbds += nlocalchgbds;

consdata->varboundsadded =

;

( *nchgbds > localoldnchgbds )

(

(

, conshdlrdata, conss, nconss, &cutoff, naggrvars, nchgbds, nchgcoefs, nchgsides, ndelconss, naddconss) );

( *nchgbds > oldnchgbds || *ndelconss > oldndelconss || *naddconss > oldnaddconss

|| *nchgcoefs > oldnchgcoefs || *nchgsides > oldnchgsides || *naggrvars > oldnaggrvars )

assert(conshdlr !=

);

assert(conshdlrdata !=

);

assert(consdata !=

);

( consdata->vbdcoef > 0.0 )

( consdata->vbdcoef > 0.0 )

assert(cons !=

);

assert(consdata !=

);

assert(conshdlr !=

);

assert(cons !=

);

assert(consdata !=

);

* consname;

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode, global, valid) );

assert(success !=

);

assert(str !=

);

assert(name !=

);

assert(cons !=

);

(*success) =

;

( isdigit(str[0]) || ((str[0] ==

|| str[0] ==

) && isdigit(str[1])) )

( endstr[0] !=

|| endstr[1] !=

)

(

, endstr[0], endstr[1]);

( requiredsize == 2 && *success )

( *str !=

&& *(str+1) !=

&&

(

, str+2, &value, &endstr) )

assert(str[1] ==

);

assert(str[1] ==

);

assert(str[1] ==

);

( strncmp(str,

, 6) != 0 )

initial, separate, enforce, check, propagate, local, modifiable, dynamic, removable, stickingatnode) );

assert( success !=

);

(*success) =

;

assert(cons !=

);

assert(vars !=

);

assert(consdata !=

);

vars[0] = consdata->var;

vars[1] = consdata->vbdvar;

assert(event !=

);

assert(cons !=

);

assert(consdata !=

);

consdata->presolved =

;

consdata->presolved =

;

consdata->tightened =

;

eventExecVarbound,

) );

consEnfolpVarbound, consEnfopsVarbound, consCheckVarbound, consLockVarbound,

assert(conshdlr !=

);

,

,

,

,

( conshdlr ==

)

assert(conshdlrdata !=

);

(

(

, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,

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

assert(consdata !=

);

consdata->lhs;

assert(consdata !=

);

consdata->rhs;

assert(consdata !=

);

consdata->var;

assert(consdata !=

);

consdata->vbdvar;

assert(consdata !=

);

consdata->vbdcoef;

assert(consdata !=

);

( consdata->row !=

)

assert(consdata !=

);

( consdata->row !=

)

assert(consdata !=

);

consdata->row;

( conshdlr ==

)

assert(infeasible !=

);

*infeasible =

;

assert(naddconss !=

);

assert(ndelconss !=

);

assert(nchgbds !=

);

assert(conshdlrdata !=

);

eventhdlr = conshdlrdata->eventhdlr;

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

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

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

static SCIP_DECL_CONSCHECK(consCheckVarbound)

static SCIP_RETCODE addRelaxation(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)

static SCIP_DECL_CONSRESPROP(consRespropVarbound)

static SCIP_DECL_SORTPTRCOMP(consVarboundComp)

static SCIP_RETCODE dropEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)

#define DEFAULT_USEBDWIDENING

#define CONSHDLR_NEEDSCONS

#define CONSHDLR_SEPAFREQ

static SCIP_DECL_EVENTEXEC(eventExecVarbound)

static SCIP_DECL_CONSGETPERMSYMGRAPH(consGetPermsymGraphVarbound)

static SCIP_DECL_CONSACTIVE(consActiveVarbound)

#define CONSHDLR_CHECKPRIORITY

static SCIP_DECL_CONSINITSOL(consInitsolVarbound)

static SCIP_DECL_CONSPROP(consPropVarbound)

static SCIP_DECL_CONSLOCK(consLockVarbound)

static SCIP_RETCODE upgradeConss(SCIP *scip, SCIP_CONSHDLRDATA *conshdlrdata, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *naggrvars, int *nchgbds, int *nchgcoefs, int *nchgsides, int *ndelconss, int *naddconss)

static SCIP_RETCODE applyFixings(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *naddconss)

static SCIP_DECL_CONSPRESOL(consPresolVarbound)

static SCIP_DECL_CONSGETNVARS(consGetNVarsVarbound)

static SCIP_RETCODE consdataCreate(SCIP *scip, SCIP_CONSDATA **consdata, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)

static SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(consGetSignedPermsymGraphVarbound)

static SCIP_RETCODE tightenCoefs(SCIP *scip, SCIP_CONS *cons, int *nchgcoefs, int *nchgsides, int *ndelconss, SCIP_Bool *cutoff, int *nchgbds)

static SCIP_RETCODE createRelaxation(SCIP *scip, SCIP_CONS *cons)

static SCIP_DECL_CONSEXITSOL(consExitsolVarbound)

#define CONSHDLR_PROP_TIMING

static void checkRedundancySide(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real coef0, SCIP_Real coef1, SCIP_Real side0, SCIP_Real side1, SCIP_Bool *sideequal, SCIP_Bool *cons0sidered, SCIP_Bool *cons1sidered, SCIP_Bool islhs)

static void conshdlrdataFree(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata)

static SCIP_DECL_CONSGETVARS(consGetVarsVarbound)

static SCIP_DECL_CONSCOPY(consCopyVarbound)

#define CONSHDLR_MAXPREROUNDS

static SCIP_Bool checkCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checklprows)

#define DEFAULT_PRESOLPAIRWISE

static SCIP_DECL_CONSSEPASOL(consSepasolVarbound)

static SCIP_DECL_CONSFREE(consFreeVarbound)

#define CONSHDLR_SEPAPRIORITY

#define DEFAULT_MAXLPCOEF

static SCIP_DECL_CONSPRINT(consPrintVarbound)

static void prettifyConss(SCIP *scip, SCIP_CONS **conss, int nconss, int *nchgcoefs, int *nchgsides)

static SCIP_RETCODE addSymmetryInformation(SCIP *scip, SYM_SYMTYPE symtype, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)

static SCIP_RETCODE preprocessConstraintPairs(SCIP *scip, SCIP_CONS **conss, int nconss, SCIP_Bool *cutoff, int *nchgbds, int *ndelconss, int *nchgcoefs, int *nchgsides)

static SCIP_RETCODE chgLhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)

static SCIP_DECL_CONSDEACTIVE(consDeactiveVarbound)

static SCIP_DECL_CONSSEPALP(consSepalpVarbound)

static SCIP_DECL_CONSDELETE(consDeleteVarbound)

static SCIP_RETCODE analyzeConflict(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, SCIP_Real inferbd, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_Bool usebdwidening)

static SCIP_DECL_CONSTRANS(consTransVarbound)

static SCIP_RETCODE chgRhs(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)

#define CONSHDLR_PROPFREQ

static SCIP_DECL_CONSPARSE(consParseVarbound)

static SCIP_DECL_CONSENFOPS(consEnfopsVarbound)

static SCIP_RETCODE resolvePropagation(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, PROPRULE proprule, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real inferbd, SCIP_Bool usebdwidening)

static SCIP_DECL_CONSENFORELAX(consEnforelaxVarbound)

static SCIP_RETCODE propagateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_Bool *cutoff, int *nchgbds, int *nchgsides, int *ndelconss)

#define CONSHDLR_PRESOLTIMING

static SCIP_RETCODE consdataFree(SCIP *scip, SCIP_CONSDATA **consdata)

static SCIP_DECL_LINCONSUPGD(linconsUpgdVarbound)

static SCIP_DECL_CONSINITLP(consInitlpVarbound)

static SCIP_RETCODE addNlrow(SCIP *scip, SCIP_CONS *cons)

#define CONSHDLR_EAGERFREQ

static SCIP_RETCODE conshdlrdataCreate(SCIP *scip, SCIP_CONSHDLRDATA **conshdlrdata, SCIP_EVENTHDLR *eventhdlr)

static SCIP_DECL_CONSENFOLP(consEnfolpVarbound)

#define CONSHDLR_ENFOPRIORITY

static SCIP_DECL_CONSHDLRCOPY(conshdlrCopyVarbound)

static SCIP_RETCODE catchEvents(SCIP *scip, SCIP_CONS *cons, SCIP_EVENTHDLR *eventhdlr)

#define LINCONSUPGD_PRIORITY

static SCIP_RETCODE separateCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool usebdwidening, SCIP_SOL *sol, SCIP_RESULT *result)

#define CONSHDLR_DELAYSEPA

#define CONSHDLR_DELAYPROP

Constraint handler for variable bound constraints .

defines macros for basic operations in double-double arithmetic giving roughly twice the precision of...

#define SCIPquadprecDivQD(r, a, b)

#define SCIPquadprecProdDD(r, a, b)

#define SCIPquadprecProdQD(r, a, b)

#define SCIPquadprecSumQD(r, a, b)

#define QUAD_ASSIGN(a, constant)

#define SCIPquadprecSumDD(r, a, b)

#define SCIPquadprecSumQQ(r, a, b)

#define SCIP_VARTYPE_INTEGER_CHAR

#define SCIP_VARTYPE_IMPLINT_CHAR

#define SCIP_VARTYPE_BINARY_CHAR

#define SCIP_VARTYPE_CONTINUOUS_CHAR

SCIP_RETCODE SCIPincludeLinconsUpgrade(SCIP *scip, SCIP_DECL_LINCONSUPGD((*linconsupgd)), int priority, const char *conshdlrname)

SCIP_Real SCIPgetVbdcoefVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPchgRhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real rhs)

SCIP_Real SCIPgetDualfarkasVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPaddCoefLinear(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPcreateConsBasicVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, SCIP_Real lhs, SCIP_Real rhs)

SCIP_ROW * SCIPgetRowVarbound(SCIP *scip, SCIP_CONS *cons)

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

SCIP_RETCODE SCIPcreateConsSetpack(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_RETCODE SCIPcleanupConssVarbound(SCIP *scip, SCIP_Bool onlychecked, SCIP_Bool *infeasible, int *naddconss, int *ndelconss, int *nchgbds)

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

SCIP_RETCODE SCIPcopyConsLinear(SCIP *scip, SCIP_CONS **cons, SCIP *sourcescip, const char *name, int nvars, SCIP_VAR **sourcevars, SCIP_Real *sourcecoefs, SCIP_Real lhs, SCIP_Real rhs, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)

SCIP_Real SCIPgetLhsVarbound(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_Real SCIPgetRhsVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_Real SCIPgetDualsolVarbound(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateConsVarbound(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_VAR *var, SCIP_VAR *vbdvar, SCIP_Real vbdcoef, 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_RETCODE SCIPchgLhsLinear(SCIP *scip, SCIP_CONS *cons, SCIP_Real lhs)

SCIP_RETCODE SCIPincludeConshdlrVarbound(SCIP *scip)

SCIP_Bool SCIPisTransformed(SCIP *scip)

SCIP_Bool SCIPisStopped(SCIP *scip)

SCIP_STAGE SCIPgetStage(SCIP *scip)

int SCIPgetNIntVars(SCIP *scip)

int SCIPgetNImplVars(SCIP *scip)

int SCIPgetNVars(SCIP *scip)

SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)

int SCIPgetNBinVars(SCIP *scip)

SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)

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

SCIP_Bool SCIPrealToRational(SCIP_Real val, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Longint *numerator, SCIP_Longint *denominator)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)

SCIP_RETCODE SCIPaddConflictLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPinitConflictAnalysis(SCIP *scip, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)

SCIP_RETCODE SCIPaddConflictUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx)

SCIP_RETCODE SCIPaddConflictRelaxedLb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedlb)

SCIP_RETCODE SCIPaddConflictRelaxedUb(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedub)

SCIP_Bool SCIPisConflictAnalysisApplicable(SCIP *scip)

SCIP_Real SCIPgetConflictVarUb(SCIP *scip, SCIP_VAR *var)

SCIP_Real SCIPgetConflictVarLb(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPanalyzeConflictCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *success)

int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))

void SCIPconshdlrSetData(SCIP_CONSHDLR *conshdlr, SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)

SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))

SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)

SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)

SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)

SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))

SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))

SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))

SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))

const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))

SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)

SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))

SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))

SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))

SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))

SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))

SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))

int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))

SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)

SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))

SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))

SCIP_CONSDATA * SCIPconsGetData(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDynamic(SCIP_CONS *cons)

SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsInitial(SCIP_CONS *cons)

SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)

SCIP_Bool SCIPconsIsMarkedPropagate(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsTransformed(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsEnforced(SCIP_CONS *cons)

SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)

SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)

SCIP_Bool SCIPconsIsPropagated(SCIP_CONS *cons)

SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)

const char * SCIPconsGetName(SCIP_CONS *cons)

SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsModifiable(SCIP_CONS *cons)

SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)

SCIP_Bool SCIPconsIsStickingAtNode(SCIP_CONS *cons)

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

SCIP_Bool SCIPconsIsSeparated(SCIP_CONS *cons)

SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)

SCIP_Bool SCIPconsIsRemovable(SCIP_CONS *cons)

SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)

SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)

SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)

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)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPduplicateBufferArray(scip, ptr, source, num)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

SCIP_RETCODE SCIPdelNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPaddNlRow(SCIP *scip, SCIP_NLROW *nlrow)

SCIP_Bool SCIPisNLPConstructed(SCIP *scip)

SCIP_RETCODE SCIPreleaseNlRow(SCIP *scip, SCIP_NLROW **nlrow)

SCIP_Bool SCIPnlrowIsInNLP(SCIP_NLROW *nlrow)

SCIP_RETCODE SCIPcreateNlRow(SCIP *scip, SCIP_NLROW **nlrow, const char *name, SCIP_Real constant, int nlinvars, SCIP_VAR **linvars, SCIP_Real *lincoefs, SCIP_EXPR *expr, SCIP_Real lhs, SCIP_Real rhs, SCIP_EXPRCURV curvature)

SCIP_Bool SCIPinProbing(SCIP *scip)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_Real SCIProwGetDualfarkas(SCIP_ROW *row)

SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)

SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)

SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)

void SCIPupdateSolLPConsViolation(SCIP *scip, SCIP_SOL *sol, SCIP_Real absviol, SCIP_Real relviol)

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

SCIP_Real SCIPinfinity(SCIP *scip)

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

SCIP_Bool SCIPisIntegral(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)

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

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeastol(SCIP *scip)

SCIP_Real SCIPgetHugeValue(SCIP *scip)

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

SCIP_Bool SCIPisNegative(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPepsilon(SCIP *scip)

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

SCIP_Bool SCIPisFeasPositive(SCIP *scip, SCIP_Real val)

SCIP_Bool SCIPparseReal(SCIP *scip, const char *str, SCIP_Real *value, char **endptr)

SCIP_Bool SCIPinRepropagation(SCIP *scip)

SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)

int SCIPvarGetNLocksUpType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)

SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VAR * SCIPvarGetProbvar(SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)

int SCIPvarGetIndex(SCIP_VAR *var)

SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)

SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)

SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)

SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)

SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)

SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)

SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

int SCIPvarGetNLocksDownType(SCIP_VAR *var, SCIP_LOCKTYPE locktype)

SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)

SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)

void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)

SCIP_RETCODE SCIPskipSpace(char **s)

SCIP_RETCODE SCIPgetSymActiveVariables(SCIP *scip, SYM_SYMTYPE symtype, SCIP_VAR ***vars, SCIP_Real **scalars, int *nvars, SCIP_Real *constant, SCIP_Bool transformed)

SCIP_RETCODE SCIPextendPermsymDetectionGraphLinear(SCIP *scip, SYM_GRAPH *graph, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_CONS *cons, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool *success)

memory allocation routines

public methods for managing constraints

public methods for managing events

public methods for LP management

public methods for message output

#define SCIPdebugPrintCons(x, y, z)

public data structures and miscellaneous methods

methods for sorting joint arrays of various types

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 cuts and aggregation rows

public methods for event handler plugins and event handlers

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for nonlinear relaxation

public methods for numerical tolerances

public methods for SCIP parameter handling

public methods for global and local (sub)problems

public methods for the probing mode

public methods for solutions

public methods for the branch-and-bound tree

public methods for SCIP variables

structs for symmetry computations

methods for dealing with symmetry detection graphs

@ SCIP_CONFTYPE_PROPAGATION

struct SCIP_ConshdlrData SCIP_CONSHDLRDATA

struct SCIP_ConsData SCIP_CONSDATA

struct SCIP_EventData SCIP_EVENTDATA

#define SCIP_EVENTTYPE_VARFIXED

#define SCIP_EVENTTYPE_BOUNDTIGHTENED

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_Result SCIP_RESULT

enum SCIP_Retcode SCIP_RETCODE

enum SYM_Symtype SYM_SYMTYPE

#define SCIP_PRESOLTIMING_MEDIUM

@ SCIP_VARTYPE_CONTINUOUS

@ SCIP_VARSTATUS_MULTAGGR

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