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

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

SCIP Doxygen Documentation: scip_var.c Source File

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

(

->set->stage )

name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) );

name, lb, ub, obj, vartype, initial, removable, vardelorig, vartrans, vardeltrans, varcopy, vardata) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

, var, name, lb, ub, obj, vartype,

,

,

,

,

,

,

) );

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

( vals[v] == 1.0 )

( vals[v] == -1.0 )

( nvars > 0 )

assert(monomialvars !=

|| nmonomials == 0);

assert(monomialcoefs !=

|| nmonomials == 0);

assert(monomialnvars !=

|| nmonomials == 0);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( nmonomials == 0 )

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

( monomialcoefs[i] == 1.0 )

( monomialcoefs[i] == -1.0 )

assert(monomialvars[i] !=

|| monomialnvars[i] == 0);

( v = 0; v < monomialnvars[i]; ++v )

( monomialexps !=

&& monomialexps[i] !=

&& monomialexps[i][v] != 1.0 )

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) );

str, initial, removable, varcopy, vardelorig, vartrans, vardeltrans, vardata, endptr, success) );

assert(str !=

);

assert(var !=

);

assert(endptr !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(*endptr !=

);

( *endptr == str )

( *varname ==

)

assert( nvars !=

);

assert( requiredsize !=

);

assert( endptr !=

);

assert( success !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*endptr = (

*)str;

( ntmpvars < varssize )

tmpvars[ntmpvars] = var;

( *str == delimiter );

*endptr = (

*)str;

( (*success) && ntmpvars <= varssize )

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

vars[v] = tmpvars[v];

(*requiredsize) = ntmpvars;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(str !=

);

assert(vars !=

|| varssize == 0);

assert(vals !=

|| varssize == 0);

assert(nvars !=

);

assert(requiredsize !=

);

assert(endptr !=

);

assert(success !=

);

assert(nmonomials == 0);

( nmonomials == 1 && monomialnvars[0] == 0 && monomialcoefs[0] == 0.0 )

*requiredsize = nmonomials;

( varssize >= nmonomials )

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

( monomialnvars[v] == 0 )

( monomialnvars[v] > 1 || monomialexps[v][0] != 1.0 )

assert(monomialnvars[v] == 1);

assert(monomialvars[v][0] !=

);

assert(monomialexps[v][0] == 1.0);

vars[v] = monomialvars[v][0];

vals[v] = monomialcoefs[v];

** monomialnvars,

SCIPPARSEPOLYNOMIAL_STATE_BEGIN,

SCIPPARSEPOLYNOMIAL_STATE_INTERMED,

SCIPPARSEPOLYNOMIAL_STATE_COEF,

SCIPPARSEPOLYNOMIAL_STATE_VARS,

SCIPPARSEPOLYNOMIAL_STATE_EXPONENT,

SCIPPARSEPOLYNOMIAL_STATE_END,

SCIPPARSEPOLYNOMIAL_STATE_ERROR

} SCIPPARSEPOLYNOMIAL_STATES;

SCIPPARSEPOLYNOMIAL_STATES state;

assert(str !=

);

assert(monomialvars !=

);

assert(monomialexps !=

);

assert(monomialnvars !=

);

assert(monomialcoefs !=

);

assert(nmonomials !=

);

assert(endptr !=

);

assert(success !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*monomialvars =

;

*monomialexps =

;

*monomialcoefs =

;

*monomialnvars =

;

state = SCIPPARSEPOLYNOMIAL_STATE_BEGIN;

( *str && state != SCIPPARSEPOLYNOMIAL_STATE_END && state != SCIPPARSEPOLYNOMIAL_STATE_ERROR )

assert(state != SCIPPARSEPOLYNOMIAL_STATE_END);

SCIPPARSEPOLYNOMIAL_STATE_BEGIN:

(

,

, coef, nvars);

( monomialssize <= *nmonomials )

(*monomialvars)[*nmonomials] =

;

(*monomialexps)[*nmonomials] =

;

(*monomialcoefs)[*nmonomials] = coef;

(*monomialnvars)[*nmonomials] = nvars;

state = SCIPPARSEPOLYNOMIAL_STATE_VARS;

( *str ==

|| *str ==

|| isdigit(*str) )

state = SCIPPARSEPOLYNOMIAL_STATE_COEF;

state = SCIPPARSEPOLYNOMIAL_STATE_END;

SCIPPARSEPOLYNOMIAL_STATE_INTERMED:

state = SCIPPARSEPOLYNOMIAL_STATE_VARS;

( *str ==

|| *str ==

|| isdigit(*str) )

state = SCIPPARSEPOLYNOMIAL_STATE_BEGIN;

state = SCIPPARSEPOLYNOMIAL_STATE_END;

SCIPPARSEPOLYNOMIAL_STATE_COEF:

( *str ==

&& !isdigit(str[1]) )

( *str ==

&& !isdigit(str[1]) )

(

, str);

state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;

state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;

SCIPPARSEPOLYNOMIAL_STATE_VARS:

assert(*str ==

);

( *endptr == str )

state = SCIPPARSEPOLYNOMIAL_STATE_END;

(

, str);

state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;

( nvars + 1 > varssize )

assert(vars !=

);

assert(exponents !=

);

exponents[nvars] = 1.0;

state = SCIPPARSEPOLYNOMIAL_STATE_EXPONENT;

state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;

SCIPPARSEPOLYNOMIAL_STATE_EXPONENT:

assert(*str ==

);

assert(exponents !=

);

(

, str);

state = SCIPPARSEPOLYNOMIAL_STATE_ERROR;

state = SCIPPARSEPOLYNOMIAL_STATE_INTERMED;

SCIPPARSEPOLYNOMIAL_STATE_END:

SCIPPARSEPOLYNOMIAL_STATE_ERROR:

*endptr = (

*)str;

SCIPPARSEPOLYNOMIAL_STATE_BEGIN:

SCIPPARSEPOLYNOMIAL_STATE_END:

SCIPPARSEPOLYNOMIAL_STATE_INTERMED:

(

,

, coef, nvars);

( monomialssize <= *nmonomials )

monomialssize = *nmonomials+1;

(*monomialvars)[*nmonomials] = vars;

(*monomialexps)[*nmonomials] = exponents;

(*monomialvars)[*nmonomials] =

;

(*monomialexps)[*nmonomials] =

;

(*monomialcoefs)[*nmonomials] = coef;

(*monomialnvars)[*nmonomials] = nvars;

SCIPPARSEPOLYNOMIAL_STATE_COEF:

SCIPPARSEPOLYNOMIAL_STATE_VARS:

SCIPPARSEPOLYNOMIAL_STATE_EXPONENT:

(

);

SCIPPARSEPOLYNOMIAL_STATE_ERROR:

( *success && *nmonomials > 0 )

assert(*nmonomials <= monomialssize);

** monomialnvars,

assert(monomialvars !=

);

assert(monomialexps !=

);

assert(monomialcoefs !=

);

assert(monomialnvars !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( nmonomials == 0 )

assert(*monomialvars !=

);

assert(*monomialexps !=

);

assert(*monomialcoefs !=

);

assert(*monomialnvars !=

);

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var !=

);

assert(*var !=

);

assert((*var)->scip ==

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

assert(transvar !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || transvars !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

transvars[v] = vars[v];

assert(transvar !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || transvars !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

transvars[v] = vars[v];

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

assert(var !=

);

assert(repvar !=

);

assert(negated !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(vars !=

|| nvars == 0);

assert(repvars !=

|| nvars == 0);

assert(negated !=

|| nvars == 0);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

assert( var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert( nvars !=

);

assert( vars !=

|| *nvars == 0 );

assert( constant !=

);

assert( requiredsize !=

);

assert( *nvars <= varssize );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var !=

);

assert(scalar !=

);

assert(constant !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars !=

);

assert(vars !=

|| *nvars == 0);

assert(varssize >= *nvars);

assert(requiredsize !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert( var !=

);

assert( var !=

);

assert(var !=

);

assert(var !=

);

( varstatus )

( bdchgidx ==

)

( bdchginfo !=

)

(

);

assert(var !=

);

( varstatus )

( bdchgidx ==

)

( bdchginfo !=

)

(

);

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || vals !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || vals !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->branch_firstsbchild )

assert(

->set->branch_firstsbchild ==

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( enablepropagation )

(

);

(

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( i = 0, nbnds = 0; i < nboundchgs; ++i )

(

,

, nbnds);

->branchcand,

->eventqueue,

->eventfilter,

->cliquetable) );

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

assert(col !=

);

( downinf !=

)

*downinf = downcutoff;

( upinf !=

)

(

->set->conf_enable &&

->set->conf_usesb &&

->set->nconflicthdlrs > 0

assert(downconflict !=

);

assert(upconflict !=

);

->transprob,

->origprob,

->tree,

->reopt,

->lp,

->branchcand,

->eventqueue,

->cliquetable, col, downconflict, upconflict) );

assert(var !=

);

assert(lperror !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( downvalid !=

)

*downvalid =

;

( upvalid !=

)

( downinf !=

)

( upinf !=

)

( downconflict !=

)

*downconflict =

;

( upconflict !=

)

*upconflict =

;

assert(col !=

);

&localdown, &localup, &localdownvalid, &localupvalid, lperror) );

(

->set->misc_exactsolve )

( pseudoobjval > lpobjval )

( !localdownvalid || localdown < pseudoobjval )

localdown = pseudoobjval;

localdownvalid =

;

( !localupvalid || localup < pseudoobjval )

localup = pseudoobjval;

localupvalid =

;

( downinf !=

)

*downinf = localdownvalid &&

(

->set, localdown,

->lp->cutoffbound);

( upinf !=

)

( downvalid !=

)

*downvalid = localdownvalid;

( upvalid !=

)

*upvalid = localupvalid;

assert(value !=

);

assert(foundsol !=

);

assert(cutoff !=

);

assert(lperror !=

);

assert(valid !=

? !(*valid) :

);

( valid !=

)

( conflict !=

)

( valid !=

)

( conflict !=

)

( valid !=

)

( conflict !=

)

( ndomreductions !=

)

*ndomreductions = ndomreds;

( valid !=

)

(

,

,

assert(!(*lperror));

( valid !=

)

(

,

,

( !(*lperror) )

(

,

, *value);

( valid !=

)

++

->stat->nsbtimesiterlimhit;

*value = objval + looseobjval;

( valid !=

)

( !(*cutoff) && newlbs !=

)

assert(newubs !=

);

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

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

newlbs[v] =

(newlbs[v], lb);

newubs[v] =

(newubs[v], ub);

assert(var !=

);

assert(down !=

);

assert(up !=

);

assert(lperror !=

);

assert((newlbs !=

) == (newubs !=

));

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

propagate = (maxproprounds != 0 && maxproprounds != -3);

( maxproprounds == -2 )

( downvalid !=

)

*downvalid =

;

( upvalid !=

)

( downinf !=

)

( upinf !=

)

( downconflict !=

)

*downconflict =

;

( upconflict !=

)

*upconflict =

;

( ndomredsdown !=

)

( ndomredsup !=

)

assert(col !=

);

( upinf !=

)

( upvalid !=

)

( upconflict !=

)

*upconflict =

;

*down, *up,

,

, 0LL, INT_MAX);

( downinf !=

)

( downvalid !=

)

( downconflict !=

)

*downconflict =

;

*down, *up,

,

, 0LL, INT_MAX);

oldniters =

->stat->nsbdivinglpiterations;

enabledconflict =

->set->conf_enable;

->set->conf_enable = (

->set->conf_enable &&

->set->conf_usesb);

downvalidlocal =

;

upvalidlocal =

;

down, &downvalidlocal, ndomredsdown, downconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );

( downinf !=

)

( downconflict !=

*downconflict =

;

( upinf !=

)

upvalidlocal =

;

up, &upvalidlocal, ndomredsup, upconflict, lperror, vars, nvars, newlbs, newubs, &foundsol, &cutoff) );

( upinf !=

)

( upconflict !=

*upconflict =

;

( downinf !=

)

downvalidlocal =

;

downchild = !downchild;

firstchild = !firstchild;

( !firstchild && ( !cutoff ||

->set->branch_forceall ) );

(

->set->misc_exactsolve )

( pseudoobjval > lpobjval )

( !downvalidlocal || *down < pseudoobjval )

*down = pseudoobjval;

downvalidlocal =

;

( !upvalidlocal || *up < pseudoobjval )

upvalidlocal =

;

*down, *up, downvalidlocal, upvalidlocal,

->stat->nsbdivinglpiterations - oldniters, itlim);

( downvalid !=

)

*downvalid = downvalidlocal;

( upvalid !=

)

*upvalid = upvalidlocal;

->set->conf_enable = enabledconflict;

assert(var !=

);

assert(lperror !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( downvalid !=

)

*downvalid =

;

( upvalid !=

)

( downinf !=

)

( upinf !=

)

( downconflict !=

)

*downconflict =

;

( upconflict !=

)

*upconflict =

;

assert(col !=

);

&localdown, &localup, &localdownvalid, &localupvalid, lperror) );

(

->set->misc_exactsolve )

( pseudoobjval > lpobjval )

( !localdownvalid || localdown < pseudoobjval )

localdown = pseudoobjval;

localdownvalid =

;

( !localupvalid || localup < pseudoobjval )

localup = pseudoobjval;

localupvalid =

;

( downinf !=

)

*downinf = localdownvalid &&

(

->set, localdown,

->lp->cutoffbound);

( upinf !=

)

( downvalid !=

)

*downvalid = localdownvalid;

( upvalid !=

)

*upvalid = localupvalid;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert( lperror !=

);

assert( vars !=

);

assert(cols !=

);

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

( downvalid !=

)

downvalid[j] =

;

( upvalid !=

)

upvalid[j] =

;

( downinf !=

)

downinf[j] =

;

( upinf !=

)

( downconflict !=

)

downconflict[j] =

;

( upconflict !=

)

upconflict[j] =

;

assert( var !=

);

assert(col !=

);

down, up, downvalid, upvalid, lperror) );

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

(upinf !=

) ? (&(upinf[j])) :

, (downconflict !=

) ? (&(downconflict[j])) :

,

(upconflict !=

) ? (&(upconflict[j])) :

) );

assert(lperror !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert( vars !=

);

assert(cols !=

);

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

( downvalid !=

)

downvalid[j] =

;

( upvalid !=

)

upvalid[j] =

;

( downinf !=

)

downinf[j] =

;

( upinf !=

)

( downconflict !=

)

downconflict[j] =

;

( upconflict !=

)

upconflict[j] =

;

assert( var !=

);

assert(col !=

);

down, up, downvalid, upvalid, lperror) );

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

(upinf !=

) ? (&(upinf[j])) :

, (downconflict !=

) ? (&(downconflict[j])) :

,

(upconflict !=

) ? (&(upconflict[j])) :

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

down, up, downvalid, upvalid, iter, itlim);

assert(foundsol !=

);

assert(cutoff !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->branch_checksbsol )

(

->set->branch_roundsbsol )

->stat->nsbsolsfound++;

(

->primal->nbestsolsfound != oldnbestsolsfound )

->stat->nsbbestsolsfound++;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

( nlocksdown[i] == 0 && nlocksup[i] == 0 )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

( nlocksdown[i] == 0 && nlocksup[i] == 0 )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

);

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!infeasible);

->cliquetable, var, newbound,

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!infeasible);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!infeasible);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!infeasible);

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, ub);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!(*infeasible));

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, lb);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!(*infeasible));

assert(var !=

);

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( tightened !=

)

*tightened =

;

->eventqueue,

->cliquetable, fixedval, infeasible, &fixed) );

( tightened !=

)

( ! (*infeasible) )

( tightened !=

)

*tightened |= lbtightened;

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, ub);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

assert(!(*infeasible));

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, lb);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

assert(!(*infeasible));

assert(fixedval ==

|| fixedval ==

);

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

( (lb > 0.5) || (ub < 0.5) )

*infeasible = (fixedval == (lb < 0.5));

(

->set->stage )

( fixedval ==

)

->cliquetable, (

)fixedval, infeasible, &fixed) );

( fixedval ==

)

( tightened !=

)

assert(var !=

);

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( tightened !=

)

*tightened =

;

->cliquetable, fixedval, infeasible, &fixed) );

( tightened !=

)

( ! (*infeasible) )

( tightened !=

)

*tightened |= lbtightened;

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, ub);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

assert(!(*infeasible));

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, lb);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

assert(!(*infeasible));

assert(fixedval ==

|| fixedval ==

);

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

( (lb > 0.5) || (ub < 0.5) )

*infeasible = (fixedval == (lb < 0.5));

(

->set->stage )

( fixedval ==

)

->cliquetable, (

)fixedval, infeasible, &fixed) );

( fixedval ==

)

->transprob,

->origprob,

->tree,

->reopt,

->lp,

->branchcand,

->eventqueue,

->cliquetable, var, 1.0,

->transprob,

->origprob,

->tree,

->reopt,

->lp,

->branchcand,

->eventqueue,

->cliquetable, var, 0.0,

( tightened !=

)

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, ub);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!(*infeasible));

assert(infeasible !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( tightened !=

)

*tightened =

;

*infeasible =

;

newbound =

(newbound, lb);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, newbound) );

->branchcand,

->eventqueue, newbound) );

->branchcand,

->eventqueue,

->cliquetable, newbound) );

assert(!(*infeasible));

assert(var !=

);

assert(var !=

);

assert(var !=

);

assert(var !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->reopt,

->lp,

->cliquetable,

->branchcand,

->eventqueue, vlbvar, vlbcoef, vlbconstant,

, infeasible, &nlocalbdchgs) );

*nbdchgs = nlocalbdchgs;

( vlbcoef > 0.0 )

-vlbconstant/vlbcoef,

, infeasible, &nlocalbdchgs) );

-vlbconstant/vlbcoef,

, infeasible, &nlocalbdchgs) );

*nbdchgs += nlocalbdchgs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->reopt,

->lp,

->cliquetable,

->branchcand,

->eventqueue, vubvar, vubcoef, vubconstant,

,

infeasible, &nlocalbdchgs) );

*nbdchgs = nlocalbdchgs;

( vubcoef > 0.0 )

-vubconstant/vubcoef,

, infeasible, &nlocalbdchgs) );

-vubconstant/vubcoef,

, infeasible, &nlocalbdchgs) );

*nbdchgs += nlocalbdchgs;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(infeasible !=

);

*infeasible =

;

( nbdchgs !=

)

vals[0] = varfixing;

( varfixing ==

)

implbound - lby, lby,

, infeasible, nbdchgs) );

implbound - uby, uby,

, infeasible, nbdchgs) );

lby - implbound, implbound,

, infeasible, nbdchgs) );

uby - implbound, implbound,

, infeasible, nbdchgs) );

->tree,

->reopt,

->lp,

->cliquetable,

->branchcand,

->eventqueue, varfixing, implvar, impltype,

implbound,

, infeasible, nbdchgs) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

( nbdchgs !=

)

->origprob,

->tree,

->reopt,

->lp,

->branchcand,

->eventqueue, vars, values, nvars, isequation,

infeasible, nbdchgs) );

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

currentlabel = labels[i];

( currentlabel == -1 )

localclassidx = classidx;

assert(currentlabel >= 0);

localclassidx = classidx;

assert(localclassidx - 1 >= 0);

assert(localclassidx - 1 <= i);

labels[i] = localclassidx - 1;

assert(classidx > 0);

assert(classidx <= nlabels);

*nclasses = classidx;

* sortedindices,

* classesstartposs,

** indexpointers;

assert(vars !=

);

assert(sortedindices !=

);

assert(classesstartposs !=

);

assert(nvars == 0 || vars !=

);

assert(classlabels !=

);

assert(nclasses > 0);

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

assert(0 <= classlabels[v] && classlabels[v] < nclasses);

++(classcount[classlabels[v]]);

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

varpointers[c] = (

**) (sortedvars + nextpos);

indexpointers[c] = (

*) (sortedindices + nextpos);

classesstartposs[c] = nextpos;

assert(classcount[c] > 0);

nextpos += classcount[c];

assert(nextpos > 0);

assert(nextpos == nvars);

classesstartposs[c] = nextpos;

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

*(varpointers[classlabels[v]]) = vars[v];

++(varpointers[classlabels[v]]);

*(indexpointers[classlabels[v]]) = v;

++(indexpointers[classlabels[v]]);

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

assert(sortedvars[v] !=

);

assert(sortedindices[v] >= 0);

assert(vars[sortedindices[v]] == sortedvars[v]);

*

cliquepartition,

*

ncliques

maxncliquevarscomp;

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

cliquepartition[i] = -1;

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

( cliquepartition[i] == -1 )

cliquepartition[i] = *ncliques;

cliquevars[0] = vars[i];

cliquevalues[0] = values[i];

( j = i+1; j < nvars; ++j )

( k = ncliquevars - 1; k >= 0; --k )

cliquepartition[j] = cliquepartition[i];

cliquevars[ncliquevars] = vars[j];

cliquevalues[ncliquevars] = values[j];

assert(cliquepartition[i] >= 0 && cliquepartition[i] < i+1);

( i * nvars > maxncliquevarscomp )

( ; i < nvars; ++i )

( cliquepartition[i] == -1 )

cliquepartition[i] = *ncliques;

*

cliquepartition,

*

ncliques

* componentlabels;

* sortedindices;

* componentstartposs;

assert(nvars == 0 || vars !=

);

assert(nvars == 0 || cliquepartition !=

);

assert(ncliques !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

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

cliquepartition[i] = i;

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

tmpvalues[i] =

;

cliquepartition[i] = -1;

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

componentlabels[i] = -1;

assert(ncomponents >= 1);

assert(ncomponents <= nvars);

( ncomponents > 1 )

(

(

, tmpvars, componentlabels, sortedtmpvars, sortedindices, componentstartposs, nvars, ncomponents) );

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

assert(tmpvars[sortedindices[i]] == sortedtmpvars[i]);

sortedtmpvalues[i] = tmpvalues[sortedindices[i]];

sortedtmpvars = tmpvars;

sortedtmpvalues = tmpvalues;

componentstartposs[0] = 0;

componentstartposs[1] = nvars;

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

sortedindices[i] = i;

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

* localcliquepartition;

ncomponentvars = componentstartposs[c + 1] - componentstartposs[c];

ncomponentvars, localcliquepartition, &nlocalcliques) );

assert(nlocalcliques >= 1);

assert(nlocalcliques <= ncomponentvars);

( l = componentstartposs[c]; l < componentstartposs[c + 1]; ++l )

origvaridx = sortedindices[l];

assert(cliquepartition[origvaridx] == -1);

assert(localcliquepartition[l - componentstartposs[c]] <= l - componentstartposs[c]);

cliquepartition[origvaridx] = localcliquepartition[l - componentstartposs[c]] + (*ncliques);

*ncliques += nlocalcliques;

( ncomponents > 1 && ncomponents < nvars )

assert(partitionsize == *ncliques);

( ncomponents > 1 )

* debugcliquepartition;

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

assert(i * nvars >

|| cliquepartition[i] == debugcliquepartition[i]);

*

cliquepartition,

*

ncliques

assert(cliquepartition !=

|| nvars == 0);

assert(ncliques !=

);

assert(vars !=

);

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

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

globalinfeasibility =

;

&globalinfeasibility) );

( infeasible !=

)

*infeasible = globalinfeasibility;

( globalinfeasibility )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var1 !=

);

assert(var2 !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(fname !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

( nbinvars + nimplvars == 0 )

( ncliques == 0 )

gmlfile = fopen(fname,

);

( gmlfile ==

)

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

( writenodeweights )

( writenodeweights )

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(

->branchcand !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

assert(var !=

);

(

->set->stage )

->branchcand,

->eventqueue,

->cliquetable, var, vartype) );

->eventqueue, vartype) );

assert(transvar !=

);

->branchcand,

->eventqueue,

->cliquetable, var, vartype) );

->eventqueue, vartype) );

assert(var !=

);

assert(infeasible !=

);

assert(fixed !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

*infeasible =

;

(

->set->stage )

->cliquetable, fixedval, infeasible, fixed) );

*infeasible =

;

*infeasible =

;

assert(infeasible !=

);

assert(redundant !=

);

assert(aggregated !=

);

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

*infeasible =

;

*redundant =

;

*aggregated =

;

(

->set->presol_donotaggr )

rhs -= (constantx + constanty);

( varx ==

&& vary ==

)

( varx ==

)

->cliquetable, rhs/scalary, infeasible, aggregated) );

( vary ==

)

->cliquetable, rhs/scalarx, infeasible, aggregated) );

( varx == vary )

->cliquetable, rhs/scalarx, infeasible, aggregated) );

->eventqueue, varx, vary, scalarx, scalary, rhs, infeasible, aggregated) );

*redundant = *aggregated;

(

(

,

,

,

,

,

,

,

,

,

,

,

,

,

,

,

) );

->eventqueue, naggvars, aggvars,

, constant, infeasible, aggregated) );

->set->presol_donotaggr;

->set->presol_donotmultaggr;

assert(var !=

);

assert(var !=

);

!

->set->reopt_enable &&

->set->misc_allowstrongdualreds;

!

->set->reopt_enable &&

->set->misc_allowstrongdualreds;

!

->set->reopt_enable &&

->set->misc_allowweakdualreds;

!

->set->reopt_enable &&

->set->misc_allowweakdualreds;