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

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

SCIP Doxygen Documentation: cuts.c Source File

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

( cutcoefs[i] > 0.0 )

assert(inds !=

);

assert(vals !=

);

assert(nnz !=

);

assert(row !=

);

( i = 0 ; i < row->

; ++i )

val = vals[probindex];

inds[(*nnz)++] = probindex;

val += row->

[i] * scale;

vals[probindex] = val;

assert(inds !=

);

assert(vals !=

);

assert(nnz !=

);

assert(row !=

);

( i = 0 ; i < row->

; ++i )

inds[(*nnz)++] = probindex;

assert(inds !=

);

assert(vals !=

);

assert(nnz !=

);

assert(row !=

);

( i = 0 ; i < row->

; ++i )

inds[(*nnz)++] = probindex;

assert(cutcoefs !=

);

assert(cutinds !=

);

(

->set->sepa_efficacynorm )

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

norm +=

(cutcoefs[i]);

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

absval =

(cutcoefs[i]);

norm =

(norm, absval);

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

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

(activity - cutrhs) /

(1e-6, norm);

(

->set->sepa_efficacynorm )

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

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

norm =

(norm, absval);

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

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

assert(cutcoefs !=

);

assert(cutinds !=

);

(

->set->sepa_efficacynorm )

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

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

norm =

(norm, absval);

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

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

(activity - cutrhs) /

(1e-6, norm);

( i = 0; i < *cutnnz; )

cutinds[i] = cutinds[*cutnnz];

( i = 0; i < *cutnnz; )

(

(val, minval) || isfixed )

cutinds[i] = cutinds[*cutnnz];

( abscoef1 < abscoef2 )

( abscoef2 < abscoef1 )

abscoef1 =

(coefs[ind1]);

abscoef2 =

(coefs[ind2]);

( abscoef1 < abscoef2 )

( abscoef2 < abscoef1 )

assert(redundant !=

);

( i = 0; i < *cutnnz; ++i )

assert(cutinds[i] >= 0);

assert(vars[cutinds[i]] !=

);

( cutinds[i] < nintegralvars )

( cutinds[i] < nintegralvars )

equiscale = 1.0 /

((maxact -

(*cutrhs)), maxabsintval);

( i = 0; i < *cutnnz; ++i )

(

)

->set->sepa_maxcoefratio,

->set->sepa_maxcoefratio, &intscalar, &success) );

intscalar *= equiscale;

( i = 0; i < *cutnnz; )

cutinds[i] = cutinds[*cutnnz];

( i = 0; i < *cutnnz; ++i )

assert(cutinds[i] >= 0);

assert(vars[cutinds[i]] !=

);

maxabsintval *= equiscale;

( i = 0; i < *cutnnz; ++i )

maxabsval =

(maxabsval, maxabsintval);

maxabsval =

(maxabsval, maxabscontval);

scale = 1.0 / maxabsval;

maxabsintval *= scale;

( i = 0; i < *cutnnz; ++i )

(cutinds, compareAbsCoefsQuad, (

*) cutcoefs, *cutnnz);

( i = 0; i < *cutnnz; )

( cutinds[i] >= nintegralvars )

(

,

,

cutinds[i] = cutinds[*cutnnz];

(

,

,

cutinds[i] = cutinds[*cutnnz];

assert(redundant !=

);

*redundant =

;

( i = 0; i < *cutnnz; ++i )

assert(cutinds[i] >= 0);

assert(vars[cutinds[i]] !=

);

val = cutcoefs[cutinds[i]];

( cutinds[i] < nintegralvars )

maxabsintval =

(maxabsintval, -val);

maxabscontval =

(maxabscontval, -val);

isintegral =

;

( cutinds[i] < nintegralvars )

maxabsintval =

(maxabsintval, val);

maxabscontval =

(maxabscontval, val);

isintegral =

;

equiscale = 1.0 /

((maxact -

(*cutrhs)), maxabsintval);

( i = 0; i < *cutnnz; ++i )

val = equiscale * cutcoefs[cutinds[i]];

(

)

->set->sepa_maxcoefratio,

->set->sepa_maxcoefratio, &intscalar, &success) );

intscalar *= equiscale;

( i = 0; i < *cutnnz; )

val = cutcoefs[cutinds[i]];

( intval != 0.0 )

cutcoefs[cutinds[i]] = intval;

cutcoefs[cutinds[i]] = 0.0;

cutinds[i] = cutinds[*cutnnz];

( i = 0; i < *cutnnz; ++i )

assert(cutinds[i] >= 0);

assert(vars[cutinds[i]] !=

);

val = cutcoefs[cutinds[i]];

maxabsintval =

(maxabsintval, -val);

maxabsintval =

(maxabsintval, val);

isintegral =

;

maxabsintval *= equiscale;

( i = 0; i < *cutnnz; ++i )

cutcoefs[cutinds[i]] *= equiscale;

maxabsval =

(maxabsval, maxabsintval);

maxabsval =

(maxabsval, maxabscontval);

scale = 1.0 / maxabsval;

maxabsintval *= scale;

( i = 0; i < *cutnnz; ++i )

cutcoefs[cutinds[i]] *= scale;

(cutinds, compareAbsCoefs, (

*) cutcoefs, *cutnnz);

( i = 0; i < *cutnnz; )

( cutinds[i] >= nintegralvars )

val = cutcoefs[cutinds[i]];

(

,

,

cutcoefs[cutinds[i]] = 0.0;

cutinds[i] = cutinds[*cutnnz];

(

,

,

cutcoefs[cutinds[i]] = 0.0;

cutinds[i] = cutinds[*cutnnz];

assert(nchgcoefs !=

);

assert(nchgcoefs !=

);

( i = 0; i < *cutnnz; ++i )

assert(cutinds[i] >= 0);

assert(vars[cutinds[i]] !=

);

( cutcoefs[i] < 0.0 )

( cutinds[i] < nintegralvars )

maxabsval =

(maxabsval, -cutcoefs[i]);

absvals[i] = -cutcoefs[i];

( cutinds[i] < nintegralvars )

maxabsval =

(maxabsval, cutcoefs[i]);

absvals[i] = cutcoefs[i];

( i = 0; i < *cutnnz; ++i )

( cutinds[i] >= nintegralvars )

( cutcoefs[i] < 0.0 &&

(

, maxact + cutcoefs[i], *cutrhs) )

( coef > cutcoefs[i] )

(

,

,

cutcoefs[i], coef, (*cutrhs),

(tmp), lb,

cutinds[i] = cutinds[*cutnnz];

cutcoefs[i] = cutcoefs[*cutnnz];

( cutcoefs[i] > 0.0 &&

(

, maxact - cutcoefs[i], *cutrhs) )

( coef < cutcoefs[i] )

(

,

,

cutinds[i] = cutinds[*cutnnz];

cutcoefs[i] = cutcoefs[*cutnnz];

assert(aggrrow !=

);

(*aggrrow)->local =

;

(*aggrrow)->nnz = 0;

(*aggrrow)->rank = 0;

(*aggrrow)->rowsinds =

;

(*aggrrow)->slacksign =

;

(*aggrrow)->rowweights =

;

(*aggrrow)->nrows = 0;

(*aggrrow)->rowssize = 0;

assert(aggrrow !=

);

assert(aggrrow !=

);

assert(vars !=

);

assert(messagehdlr);

( aggrrow->

== 0 )

( i = 0; i < aggrrow->

; ++i )

assert(aggrrow !=

);

assert(source !=

);

(*aggrrow)->nnz = source->

;

( source->

> 0 )

(*aggrrow)->rowsinds =

;

(*aggrrow)->slacksign =

;

(*aggrrow)->rowweights =

;

(*aggrrow)->nrows = source->

;

(*aggrrow)->rowssize = source->

;

(*aggrrow)->rank = source->

;

(*aggrrow)->local = source->

;

assert(row->

>= 0);

i = aggrrow->

++;

( sidetype == -1 )

( sidetype == 1 )

assert(valid !=

);

v = aggrrow->

[pos];

aggrrow->

[pos] = aggrrow->

[aggrrow->

];

assert(aggrrow !=

);

( aggrrow->

== 0 )

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

aggrrow->

[aggrrow->

++] = i;

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

aggrrow->

[aggrrow->

++] = i;

assert(

(val) != 0.0);

assert(weight >= 0.0);

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

probindex = inds[i];

aggrrow->

[aggrrow->

++] = probindex;

assert(

(val) != 0.0);

( i = 0; i < aggrrow->

; ++i )

aggrrow->

= 0;

assert( rowtoolong !=

);

*rowtoolong =

;

( weight > 0.0 && ((negslack == 0) || (negslack == 1 && !row->

)) )

( weight < 0.0 && ((negslack == 0) || (negslack == 1 && !row->

)) )

i = aggrrow->

++;

aggrrow->

[i] = uselhs ? -1 : 1;

( aggrrow->

> maxaggrlen )

*rowtoolong =

;

assert( aggrrow !=

);

assert( valid !=

);

( rowinds !=

&& nrowinds > -1 )

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

(

(

, aggrrow, rows[rowinds[k]], weights[rowinds[k]], sidetypebasis, allowlocal, negslack, maxaggrlen, &rowtoolong) );

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

( weights[k] != 0.0 )

(

(

, aggrrow, rows[k], weights[k], sidetypebasis, allowlocal, negslack, maxaggrlen, &rowtoolong) );

assert(cutinds !=

);

assert(cutcoefs !=

);

assert(cutrhs !=

);

assert(success !=

);

( i = 0; i < *nnz; ++i )

maxcoef =

(absval, maxcoef);

maxcoef /=

->set->sepa_maxcoefratio;

minallowedcoef =

(minallowedcoef, maxcoef);

*success = !

(

, minallowedcoef, cutislocal, cutcoefs,

(&rhs), cutinds, nnz);

assert(cutinds !=

);

assert(cutcoefs !=

);

assert(success !=

);

( i = 0; i < *nnz; ++i )

maxcoef =

(abscoef, maxcoef);

maxcoef /=

->set->sepa_maxcoefratio;

minallowedcoef =

(minallowedcoef, maxcoef);

assert(aggrrow !=

);

assert(valid !=

);

(&aggrrow->rhs), aggrrow->

, &aggrrow->

);

assert(aggrrow !=

);

aggrrow->

;

assert(aggrrow !=

);

assert(aggrrow !=

);

assert(aggrrow !=

);

assert(row !=

);

( i = 0; i < aggrrow->

; ++i )

( aggrrow->

[i] == rowind )

assert(aggrrow !=

);

aggrrow->

;

assert(aggrrow !=

);

aggrrow->

;

assert(aggrrow !=

);

aggrrow->

;

assert(aggrrow !=

);

aggrrow->

;

assert(aggrrow !=

);

assert(bestlb !=

);

assert(bestlbtype !=

);

*simplebound = *bestlb;

( bestvlbidx >= 0 && (bestvlb > *bestlb || (*bestlbtype < 0 &&

(

, bestvlb, *bestlb))) )

assert(vlbvars !=

);

*bestlbtype = bestvlbidx;

assert(bestub !=

);

assert(bestubtype !=

);

*simplebound = *bestub;

( bestvubidx >= 0 && (bestvub < *bestub || (*bestubtype < 0 &&

(

, bestvub, *bestub))) )

assert(vubvars !=

);

*bestubtype = bestvubidx;

* boundsfortrans,

( boundsfortrans !=

&& boundsfortrans[v] > -3 )

assert(boundtypesfortrans !=

);

*bestlbtype = boundsfortrans[v];

( *bestlbtype == -1 )

( *bestlbtype == -2 )

k = boundsfortrans[v];

assert(vlbvars !=

);

assert(vlbcoefs !=

);

assert(vlbconsts !=

);

(

(

, var, sol, fixintegralrhs ? usevbds : 0, allowlocal && fixintegralrhs, bestub, &simpleub, bestubtype) );

*bestubtype = boundsfortrans[v];

( *bestubtype == -1 )

( *bestubtype == -2 )

k = boundsfortrans[v];

assert(vubvars !=

);

assert(vubcoefs !=

);

assert(vubconsts !=

);

(

(

, var, sol, fixintegralrhs ? usevbds : 0, allowlocal && fixintegralrhs, bestlb, &simplelb, bestlbtype) );

*freevariable =

;

(

(

, varsol, (1.0 - boundswitch) * (*bestlb) + boundswitch * (*bestub)) )

(

(

, varsol, (1.0 - boundswitch) * (*bestlb) + boundswitch * (*bestub)) )

( *bestlbtype == -1 )

( *bestubtype == -1 )

( ((*bestlbtype) >= 0 || (*bestubtype) >= 0) && !

(

, *bestlb - simplelb, simpleub - *bestub) )

( *bestlb - simplelb > simpleub - *bestub )

( *bestlbtype >= 0 )

( *bestubtype >= 0 )

( boundtype < 0 )

*localbdsused = *localbdsused || (boundtype == -2);

( varsign == +1 )

assert(vbdvars !=

);

assert(vbdcoefs !=

);

assert(vbdconsts !=

);

cutinds[(*nnz)++] = zidx;

assert(

(zcoef) != 0.0);

assert( boundtype < 0 );

*localbdsused = *localbdsused || (boundtype == -2);

* boundsfortrans,

aggrrowintstart;

assert(varsign !=

);

assert(boundtype !=

);

assert(freevariable !=

);

assert(localbdsused !=

);

*freevariable =

;

*localbdsused =

;

( i = 0; i < *nnz && cutinds[i] >= firstcontvar; ++i )

ignoresol, boundsfortrans, boundtypesfortrans,

bestlbs + i, bestubs + i, bestlbtypes + i, bestubtypes + i, selectedbounds + i, freevariable) );

( *freevariable )

aggrrowintstart = i;

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

boundtype[i] = bestlbtypes[i];

boundtype[i] = bestubtypes[i];

assert(cutinds[i] < firstcontvar);

cutinds[i] = cutinds[*nnz];

ignoresol, boundsfortrans, boundtypesfortrans,

bestlbs + i, bestubs + i, bestlbtypes + i, bestubtypes + i, selectedbounds + i, freevariable) );

( *freevariable )

( i = aggrrowintstart; i < *nnz; ++i )

assert(bestlbtypes[i] < 0);

boundtype[i] = bestlbtypes[i];

assert(bestubtypes[i] < 0);

boundtype[i] = bestubtypes[i];

( fixintegralrhs )

( f0 < minfrac || f0 > maxfrac )

bestviolgain = -1e+100;

( i = 0; i < *nnz; i++ )

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

( boundtype[i] < 0

&& ((varsign[i] == +1 && !

(

, bestubs[i]) && bestubtypes[i] < 0)

|| (varsign[i] == -1 && !

(

, -bestlbs[i]) && bestlbtypes[i] < 0)) )

( newf0 < minfrac || newf0 > maxfrac )

( v >= firstcontvar )

viol = f0 - fj * (varsign[i] == +1 ? solval - bestlbs[i] : bestubs[i] - solval);

newviol = newf0 - newfj * (varsign[i] == -1 ? solval - bestlbs[i] : bestubs[i] - solval);

violgain = newviol - viol;

(

);

(

(

, violgain, bestviolgain) || (

(

, violgain, bestviolgain) && newf0 < bestnewf0) )

bestviolgain = violgain;

assert(besti < *nnz);

assert(boundtype[besti] < 0);

( varsign[besti] == +1 )

assert(bestubtypes[besti] < 0);

boundtype[besti] = bestubtypes[besti];

varsign[besti] = -1;

assert(bestlbtypes[besti] < 0);

boundtype[besti] = bestlbtypes[besti];

varsign[besti] = +1;

*localbdsused = *localbdsused || (boundtype[besti] == -2);

assert(cutcoefs !=

);

assert(cutinds !=

);

assert(nnz !=

);

assert(boundtype !=

);

assert(varsign !=

);

( i < *nnz && cutinds[i] >= firstcontvar )

assert(cutinds[i] < firstcontvar);

( i = *nnz - 1; i >= 0 && cutinds[i] < firstcontvar; --i )

assert(var !=

);

assert(varsign[i] == +1 || varsign[i] == -1);

cutinds[i] = cutinds[*nnz];

assert(boundtype[i] < 0);

( varsign[i] == +1 )

( boundtype[i] == -1 )

( boundtype[i] == -1 )

( i >= ndelcontvars )

assert(var !=

);

assert(varsign[i] == +1 || varsign[i] == -1);

assert( v >= firstcontvar );

cutinds[i] = cutinds[ndelcontvars];

varsign[i] = varsign[ndelcontvars];

boundtype[i] = boundtype[ndelcontvars];

( boundtype[i] < 0 )

( varsign[i] == +1 )

( boundtype[i] == -1 )

( boundtype[i] == -1 )

vbidx = boundtype[i];

( varsign[i] == +1 )

assert(0 <= zidx && zidx < firstcontvar);

cutinds[(*nnz)++] = zidx;

assert(

(zcoef) != 0.0);

( ndelcontvars > 0 )

assert(ndelcontvars <= *nnz);

*nnz -= ndelcontvars;

( *nnz < ndelcontvars )

assert(weights !=

|| nrowinds == 0);

assert(slacksign !=

|| nrowinds == 0);

assert(rowinds !=

|| nrowinds == 0);

assert(scale > 0.0);

assert(cutcoefs !=

);

assert(cutinds !=

);

assert(nnz !=

);

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

assert(slacksign[i] == -1 || slacksign[i] == +1);

assert(row !=

);

( slacksign[i] == +1 )

* boundsfortrans,

assert(aggrrow !=

);

assert(success !=

);

tmpnnz = aggrrow->

;

tmpislocal = aggrrow->

;

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

k = aggrrow->

[i];

assert(

(coef) != 0.0);

boundsfortrans, boundtypesfortrans, minfrac, maxfrac, tmpcoefs,

(&rhs), tmpinds, &tmpnnz, varsign, boundtype, &freevariable, &localbdsused) );

assert(allowlocal || !localbdsused);

tmpislocal = tmpislocal || localbdsused;

aggrrow->

, scale, tmpcoefs,

(&rhs), tmpinds, &tmpnnz,

(f0)) );

*cutislocal = tmpislocal;

( i = 0; i < *cutnnz; ++i )

( cutefficacy !=

)

*cutefficacy = mirefficacy;

( cutrank !=

)

*cutrank = aggrrow->

+ 1;

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

scale = 1.0 / delta;

( f0 < minfrac || f0 > maxfrac )

onedivoneminusf0 = 1.0 / (1.0 - f0);

contscale = scale * onedivoneminusf0;

rhs -= contscale * contactivity;

norm =

(contscale) * contsqrnorm;

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

fi = (scale * coefs[i]) - floorai;

( fi > f0pluseps )

floorai += (fi - f0) * onedivoneminusf0;

rhs -= solvals[i] * floorai;

norm +=

(floorai);

- rhs /

(norm, 1e-6);

* boundsfortrans,

assert(aggrrow !=

);

assert(aggrrow->

+ aggrrow->

>= 1);

assert(success !=

);

mksetnnz = aggrrow->

;

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

j = mksetinds[i];

assert(

(coef) != 0.0);

*cutislocal = aggrrow->

;

boundsfortrans, boundtypesfortrans, minfrac, maxfrac, mksetcoefs,

(&mksetrhs), mksetinds, &mksetnnz, varsign, boundtype, &freevariable, &localbdsused) );

assert(allowlocal || !localbdsused);

maxabsmksetcoef = -1.0;

( i = mksetnnz - 1; i >= 0 && mksetinds[i] < firstcontvar; --i )

* var = vars[mksetinds[i]];

bounddist[nbounddist] =

(ub - primsol, primsol - lb);

bounddistpos[nbounddist] = i;

( nbounddist == 0 )

ndeltacands = nbounddist;

( intscalesuccess )

delta = 1.0 / intscale;

intf0 = intscalerhs - floor(intscalerhs);

( intf0 < minfrac || intf0 > maxfrac )

intscale *=

(

,

(minfrac, (1.0 - maxfrac)) /

(intf0, (1.0 - intf0)));

delta = 1.0 / intscale;

intf0 = intscalerhs - floor(intscalerhs);

( intf0 >= minfrac && intf0 <= maxfrac )

deltacands[ndeltacands++] = delta;

( intf0 < maxfrac )

delta2 = 1.0 / (intscale *

(

, maxfrac / intf0));

deltacands[ndeltacands++] = delta2;

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

absmksetcoef =

(deltacands[i]);

maxabsmksetcoef =

(absmksetcoef, maxabsmksetcoef);

deltacands[i] = absmksetcoef;

( maxabsmksetcoef != -1.0 )

deltacands[ndeltacands++] = maxabsmksetcoef + 1.0;

deltacands[ndeltacands++] = 1.0;

maxtestdelta =

(ndeltacands, maxtestdelta);

( i = intstart; i < mksetnnz; ++i )

var = vars[mksetinds[i]];

( boundtype[i] == -1 )

( varsign[i] == -1 )

assert(boundtype[i] == -2);

( varsign[i] == -1 )

tmpvalues[ntmpcoefs] = solval;

tmpcoefs[ntmpcoefs] = varsign[i] *

(coef);

assert(ntmpcoefs == mksetnnz - intstart);

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

( varsign[i] *

(mksetcoef) >= 0.0 )

( boundtype[i] )

( varsign[i] == -1 )

( varsign[i] == -1 )

( varsign[i] == -1 )

solval = (coef * vbdsolval + constant) - solval;

solval = solval - (coef * vbdsolval + constant);

contactivity += solval * (

(mksetcoef) * varsign[i]);

( i = 0; i < aggrrow->

; ++i )

row = rows[aggrrow->

[i]];

slackval = row->

- slackval;

slackval = slackval - row->

;

tmpvalues[ntmpcoefs] = slackval;

contactivity += slackval * slackcoeff;

contsqrnorm +=

(slackcoeff);

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

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

deltaseenbefore =

;

( deltaseenbefore )

maxtestdelta =

(maxtestdelta + 1, ndeltacands);

( efficacy > bestefficacy )

bestefficacy = efficacy;

bestdelta = deltacands[i];

( i = 2; i <= 8 ; i *= 2 )

delta = basedelta / i;

( efficacy > bestefficacy )

bestefficacy = efficacy;

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

k = bounddistpos[i];

tmpcoefs[k - intstart] = -tmpcoefs[k - intstart];

oldsolval = tmpvalues[k - intstart];

( newefficacy > bestefficacy )

bestefficacy = newefficacy;

( varsign[k] == +1 )

assert(bestubtype < 0);

boundtype[k] = bestubtype;

assert(bestlbtype < 0);

boundtype[k] = bestlbtype;

localbdsused = localbdsused || (boundtype[k] == -2);

tmpcoefs[k - intstart] = -tmpcoefs[k - intstart];

tmpvalues[k - intstart] = oldsolval;

( bestefficacy > 0.0 )

scale = 1.0 / bestdelta;

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

aggrrow->

, scale, mksetcoefs,

(&mksetrhs), mksetinds, &mksetnnz,

(f0)) );

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

(

,

, efficacy, bestefficacy);

*cutislocal = *cutislocal || localbdsused;

(

,

, *success ?

:

);

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

*cutefficacy = mirefficacy;

( cutrank !=

)

*cutrank = aggrrow->

+ 1;

*cutislocal = *cutislocal || localbdsused;

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

assert(var !=

);

assert(rowcoefs !=

);

assert(binvarused !=

);

assert(closestvlb !=

);

assert(closestvlbidx !=

);

*closestvlbidx = -1;

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

( bestsub > vlbconsts[i] )

( (

)probidxbinvar >= (

)nbinvars )

( binvarused[probidxbinvar] == 1 )

rowcoefsign =

(1.0, rowcoef);

val2 = rowcoefsign * ((rowcoef * vlbcoefs[i]) + rowcoefbinvar);

val1 = rowcoefsign * ((rowcoef * (bestsub - vlbconsts[i])) + rowcoefbinvar);

( vlbsol > *closestvlb )

*closestvlb = vlbsol;

assert(*closestvlbidx >= 0);

assert(var !=

);

assert(rowcoefs !=

);

assert(binvarused !=

);

assert(closestvub !=

);

assert(closestvubidx !=

);

*closestvubidx = -1;

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

( bestslb < vubconsts[i] )

( (

)probidxbinvar >= (

)nbinvars )

( binvarused[probidxbinvar] == 1 )

rowcoefsign =

(1.0, rowcoef);

val2 = rowcoefsign * ((rowcoef * vubcoefs[i]) + rowcoefbinvar);

val1 = rowcoefsign * ((rowcoef * (bestslb - vubconsts[i])) + rowcoefbinvar);

( vubsol < *closestvub )

*closestvub = vubsol;

assert(*closestvubidx >= 0);

bestlbtype[varposinrow] = -3;

bestubtype[varposinrow] = -3;

probidx = rowinds[varposinrow];

var = vars[probidx];

(

(

, var, sol, 0, allowlocal, &bestslb[varposinrow], &simplebound, &bestslbtype[varposinrow]) );

(

(

, var, sol, 0, allowlocal, &bestsub[varposinrow], &simplebound, &bestsubtype[varposinrow]) );

( bestslb[varposinrow] <= -

)

( bestsub[varposinrow] >=

)

(

,

, varposinrow, rowcoef,

(var), probidx,

solval, bestslb[varposinrow], bestslbtype[varposinrow], bestsub[varposinrow], bestsubtype[varposinrow]);

*freevariable =

;

bestlb[varposinrow] = bestslb[varposinrow];

bestlbtype[varposinrow] = bestslbtype[varposinrow];

bestlb[varposinrow] = bestvlb;

bestlbtype[varposinrow] = bestvlbidx;

bestub[varposinrow] = bestsub[varposinrow];

bestubtype[varposinrow] = bestsubtype[varposinrow];

bestub[varposinrow] = bestvub;

bestubtype[varposinrow] = bestvubidx;

(

,

, bestlb[varposinrow], bestlbtype[varposinrow], bestub[varposinrow], bestubtype[varposinrow]);

*freevariable =

;

*freevariable =

;

(

(

, solval, (1.0 - boundswitch) * bestlb[varposinrow] + boundswitch * bestub[varposinrow]) && bestlbtype[varposinrow] >= 0 )

(

(

, solval, (1.0 - boundswitch) * bestlb[varposinrow] + boundswitch * bestub[varposinrow])

&& bestubtype[varposinrow] >= 0 )

(

(

, solval, (1.0 - boundswitch) * bestlb[varposinrow] + boundswitch * bestub[varposinrow]) )

assert(

(

, solval, (1.0 - boundswitch) * bestlb[varposinrow] + boundswitch * bestub[varposinrow]));

binvarused[vlbvarprobidx] = 1;

( selectedbounds[varposinrow] ==

&& bestubtype[varposinrow] >= 0 )

binvarused[vubvarprobidx] = 1;

(

,

);

( i = nnz - 1; i >= 0 && rowinds[i] < nbinvars; --i )

binvarused[rowinds[i]] = -1;

nnonbinvarsrow = i + 1;

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

assert(rowinds[i] >= nbinvars);

bestlb, bestub, bestslb, bestsub, bestlbtype, bestubtype, bestslbtype, bestsubtype, selectedbounds, &freevariable) );

( j = nnz - 1; j >= nnonbinvarsrow; --j )

binvarused[rowinds[j]] = 0;

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

*localbdsused =

;

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

probidx = rowinds[i];

var = vars[probidx];

assert(probidx >= nbinvars);

assert(bestsubtype[i] == -1 || bestsubtype[i] == -2);

( bestlbtype[i] < 0 )

( bestlbtype[i] == -2 || bestsubtype[i] == -2 )

*localbdsused =

;

(

,

,

assert(binvarused[vlbvarprobidx] == 1);

assert(vlbvarprobidx < nbinvars);

binvarused[vlbvarprobidx] = 0;

(

,

,

vlbconsts[bestlbtype[i]], snf->

);

assert(bestslbtype[i] == -1 || bestslbtype[i] == -2);

( bestubtype[i] < 0 )

( bestubtype[i] == -2 || bestslbtype[i] == -2 )

*localbdsused =

;

(

,

,

assert(binvarused[vubvarprobidx] == 1);

assert(vubvarprobidx < nbinvars);

binvarused[vubvarprobidx] = 0;

(

,

,

vubconsts[bestubtype[i]],

(transrhs));

( i = nnonbinvarsrow; i < nnz; ++i )

probidx = rowinds[i];

assert(probidx < nbinvars);

( binvarused[probidx] == 0 )

assert(binvarused[probidx] == -1);

binvarused[probidx] = 0;

var = vars[probidx];

(

,

, i,

(rowcoef),

(var), probidx, varsolval,

(

,

);

assert(weights !=

);

assert(profits !=

);

assert(items !=

);

assert(nitems >= 0);

( solitems !=

)

( solval !=

)

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

tempsort[i] = profits[i] / weights[i];

solitemsweight = 0.0;

( j = 0; j < nitems &&

(

, solitemsweight + weights[j], capacity); j++ )

( solitems !=

)

solitems[*nsolitems] = items[j];

( solval !=

)

(*solval) += profits[j];

solitemsweight += weights[j];

( ; j < nitems; j++ )

( solitems !=

)

solitems[*nsolitems] = items[j];

( solval !=

)

(*solval) += profits[j];

solitemsweight += weights[j];

( solitems !=

)

nonsolitems[*nnonsolitems] = items[j];

* nflowcovervars,

* nnonflowcovervars,

* flowcoverstatus,

assert(coefs !=

);

assert(vubcoefs !=

);

assert(solitems !=

);

assert(nonsolitems !=

);

assert(nsolitems >= 0);

assert(nnonsolitems >= 0);

assert(nflowcovervars !=

&& *nflowcovervars >= 0);

assert(nnonflowcovervars !=

&& *nnonflowcovervars >= 0);

assert(flowcoverstatus !=

);

assert(lambda !=

);

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

( coefs[solitems[j]] == 1 )

flowcoverstatus[solitems[j]] = -1;

(*nnonflowcovervars)++;

assert(coefs[solitems[j]] == -1);

flowcoverstatus[solitems[j]] = 1;

(*nflowcovervars)++;

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

( coefs[nonsolitems[j]] == 1 )

flowcoverstatus[nonsolitems[j]] = 1;

(*nflowcovervars)++;

(*flowcoverweight, *flowcoverweight, vubcoefs[nonsolitems[j]]);

assert(coefs[nonsolitems[j]] == -1);

flowcoverstatus[nonsolitems[j]] = -1;

(*nnonflowcovervars)++;

assert(mindelta <= 0.0);

assert(maxdelta >= 0.0);

sval = val * scalar;

downval = floor(sval);

assert(mindelta <= 0.0);

assert(maxdelta >= 0.0);

sval = val * scalar;

* nflowcovervars,

* nnonflowcovervars,

* flowcoverstatus,

nflowcovervarsafterfix;

nnonflowcovervarsafterfix;

assert(nflowcovervars !=

);

assert(nnonflowcovervars !=

);

assert(flowcoverstatus !=

);

assert(lambda !=

);

assert(found !=

);

(

,

);

*nflowcovervars = 0;

*nnonflowcovervars = 0;

nflowcovervarsafterfix = 0;

nnonflowcovervarsafterfix = 0;

n1itemsweight = 0.0;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

flowcoverstatus[j] = 1;

(*nflowcovervars)++;

flowcoverstatus[j] = 1;

(*nflowcovervars)++;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

assert((*nflowcovervars) + (*nnonflowcovervars) + nitems == snf->

);

assert(nn1items >= 0);

transweightsrealintegral =

;

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

transweightsrealintegral =

;

(

,

, items[j], items[j], transweightsreal[j],

items[j], transprofitsreal[j],

(

, transweightsreal[j]) ?

:

);

(

,

, items[j], items[j], transweightsreal[j],

items[j], transprofitsreal[j],

(

, transweightsreal[j]) ?

:

);

(

,

,

assert(nitems >= 0);

( transweightsrealintegral )

scalesuccess =

;

scalesuccess =

;

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

transweightsint[j] = getIntegralVal(transweightsreal[j], scalar, -

,

);

transprofitsint[j] = transprofitsreal[j];

itemsint[j] = items[j];

transcapacityint = getIntegralVal(transcapacityreal, scalar, -

,

);

transcapacityint -= 1;

transcapacityint = (

) (transcapacityreal * scalar);

nflowcovervarsafterfix = *nflowcovervars;

nnonflowcovervarsafterfix = *nnonflowcovervars;

tmp2 = (

) ((transcapacityint) + 1);

( transcapacityint * nitems <= MAXDYNPROGSPACE && tmp1 * tmp2 <= INT_MAX / 8.0)

itemsint, solitems, nonsolitems, &nsolitems, &nnonsolitems,

, &success));

transcapacityreal, items, solitems, nonsolitems, &nsolitems, &nnonsolitems,

));

items, solitems, nonsolitems, &nsolitems, &nnonsolitems,

));

items, solitems, nonsolitems, &nsolitems, &nnonsolitems,

));

assert(nsolitems != -1);

assert(nnonsolitems != -1);

assert(*nflowcovervars + *nnonflowcovervars + nsolitems + nnonsolitems == snf->

);

nnonflowcovervars, flowcoverstatus,

(&flowcoverweight), lambda);

assert(*nflowcovervars + *nnonflowcovervars == snf->

);

items, solitems, nonsolitems, &nsolitems, &nnonsolitems,

));

*nflowcovervars = nflowcovervarsafterfix;

*nnonflowcovervars = nnonflowcovervarsafterfix;

assert(*nflowcovervars + *nnonflowcovervars + nsolitems + nnonsolitems == snf->

);

nnonflowcovervars, flowcoverstatus,

(&flowcoverweight), lambda);

assert(*nflowcovervars + *nnonflowcovervars == snf->

);

(

,

, kpexact ?

:

);

( snf->

[j] == 1 && flowcoverstatus[j] == 1 )

( snf->

[j] == -1 && flowcoverstatus[j] == 1 )

* nflowcovervars,

* nnonflowcovervars,

* flowcoverstatus,

assert(nflowcovervars !=

);

assert(nnonflowcovervars !=

);

assert(flowcoverstatus !=

);

assert(lambda !=

);

assert(found !=

);

(

,

);

*nflowcovervars = 0;

*nnonflowcovervars = 0;

n1itemsweight = 0.0;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

flowcoverstatus[j] = 1;

(*nflowcovervars)++;

flowcoverstatus[j] = 1;

(*nflowcovervars)++;

flowcoverstatus[j] = -1;

(*nnonflowcovervars)++;

assert((*nflowcovervars) + (*nnonflowcovervars) + nitems == snf->

);

assert(nn1items >= 0);

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

(

,

, items[j], items[j], transweightsreal[j],

items[j], transprofitsreal[j],

(

, transweightsreal[j]) ?

:

);

(

,

, items[j], items[j], transweightsreal[j],

items[j], transprofitsreal[j],

(

, transweightsreal[j]) ?

:

);

(

,

,

assert(nitems >= 0);

items, solitems, nonsolitems, &nsolitems, &nnonsolitems,

));

assert(nsolitems != -1);

assert(nnonsolitems != -1);

assert(*nflowcovervars + *nnonflowcovervars + nsolitems + nnonsolitems == snf->

);

nnonflowcovervars, flowcoverstatus,

(&flowcoverweight), lambda);

assert(*nflowcovervars + *nnonflowcovervars == snf->

);

( snf->

[j] == 1 && flowcoverstatus[j] == 1 )

( snf->

[j] == -1 && flowcoverstatus[j] == 1 )

assert( liftingdata !=

);

xpluslambda =

+ liftingdata->

;

( i < liftingdata->

&&

(

, xpluslambda, liftingdata->

[i+1]) )

( i < liftingdata->t )

assert(

(

, xpluslambda, liftingdata->

[i+1]));

i * liftingdata->

;

assert(i > 0 &&

(

, liftingdata->

[i], xpluslambda) && x <= liftingdata->M[i]);

( i < liftingdata->

)

i * liftingdata->

;

(0.0, liftingdata->

[i] - (liftingdata->

- liftingdata->

) - liftingdata->

)));

assert(i == liftingdata->

&&

(

, liftingdata->

[liftingdata->

], xpluslambda));

vubcoefpluslambda = vubcoef + liftingdata->

;

( i < liftingdata->

&&

(

, vubcoefpluslambda, liftingdata->

[i+1]) )

assert(liftingdata->

[i] < vubcoefpluslambda);

assert(i == liftingdata->

||

(

, vubcoefpluslambda, liftingdata->

[i+1]));

* transvarflowcoverstatus,

liftingdata->

=

;

liftingdata->

=

;

liftingdata->

= 0;

liftingdata->

= 0;

s = (snf->

[i] + 1) + (transvarflowcoverstatus[i] + 1)/2;

assert(snf->

[i] == -1 && transvarflowcoverstatus[i] == -1);

assert(snf->

[i] == -1 && transvarflowcoverstatus[i] == 1);

assert(snf->

[i] == 1 && transvarflowcoverstatus[i] == 1);

( i = 0; i < liftingdata->

; ++i)

( liftingdata->

< liftingdata->

&& liftingdata->

[liftingdata->

] == liftingdata->

)

liftingdata->

= lambda;

* flowcoverstatus,

assert( liftingdata.

!=

);

assert( liftingdata.

!=

);

assert( liftingdata.

>= 0 );

assert( liftingdata.

>= 0 );

s = (snf->

[i] + 1) + (flowcoverstatus[i] + 1)/2;

assert(snf->

[i] == -1 && flowcoverstatus[i] == 1);

( liftedbincoef != 0.0 )

assert(snf->

[i] == 1 && flowcoverstatus[i] == -1);

assert(alpha == 0 || alpha == 1);

( snf->

[i] != -1 && bincoef != 0.0 )

( i = 0; i < aggrrow->

; ++i )

assert(slackcoef != 0.0);

( slackcoef > 0.0 )

row = rows[aggrrow->

[i]];

slackub = rowrhs - rowlhs;

slackub = -aggrrow->

[i] *

(rhsslack, slackub);

slackub = aggrrow->

[i] *

(lhsslack, slackub);

*transvarflowcoverstatus;

nnonflowcovervars;

(

(

, sol, boundswitch, allowlocal, aggrrow->

,

(aggrrow->rhs), aggrrow->

, aggrrow->

, &snf, success, &localbdsused) );

*cutislocal = aggrrow->

|| localbdsused;

(

(

, &snf, &nflowcovervars, &nnonflowcovervars, transvarflowcoverstatus, &lambda, success) );

( i = 0; i < *cutnnz; ++i )

assert(tmpcoefs[j] != 0.0);

cutcoefs[i] = tmpcoefs[j];

( cutefficacy !=

)

*cutefficacy =

(

, sol, cutcoefs, *cutrhs, cutinds, *cutnnz);

( cutrank !=

)

*cutrank = aggrrow->

+ 1;

( i = 0; i < *cutnnz; ++i )

assert(tmpcoefs[j] != 0.0);

aggrrowbinstart;

assert(varsign !=

);

assert(boundtype !=

);

assert(success !=

);

assert(localbdsused !=

);

( i = 0; i < *nnz && cutinds[i] >= firstnonbinvar; ++i )

aggrrowbinstart = i;

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

assert(i == aggrrowbinstart);

( aggrrowbinstart != 0 )

*nnz -= aggrrowbinstart;

assert(v < firstnonbinvar);

*localbdsused = *localbdsused || (boundtype[i] == -2);

assert(boundtype[i] == -1 || boundtype[i] == -2);

cutinds[i] = cutinds[*nnz];

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

( varsign[k] == -1 )

solval = 1 - solval;

coverpos[*coversize] = k;

(covervals + (*coversize), coverpos + (*coversize), cutnnz - (*coversize));

( *coversize < cutnnz &&

k = coverpos[*coversize];

assert(*coversize > 0);

( k = 1; k < coversize; ++k )

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

coverstatus[coverpos[k]] = -1;

coverstatus[coverpos[k]] = -1;

(

< coversize )

covervals[

], cutcoef);

assert(aggrrow !=

);

assert(cutcoefs !=

);

assert(cutrhs !=

);

assert(cutinds !=

);

assert(cutnnz !=

);

assert(cutefficacy !=

);

assert(cutislocal !=

);

assert(success !=

);

( aggrrow->

== 0 )

( k = 0; k < aggrrow->

; ++k )

nnz = aggrrow->

;

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

assert(

(coef) != 0.0);

local = aggrrow->

;

tmpcoefs,

(&rhs), tmpinds, &nnz, varsign, boundtype, &local, &transformed) );

assert(allowlocal || !local);

coverpos, covervals, &coversize,

(&coverweight)) )

assert(coversize > 0);

( coversize == 1 )

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

( coverstatus[k] == 0 )

tmpinds[0] = tmpinds[k];

varsign[0] = varsign[k];

( varsign[0] == -1 )

(coverweight), covervals, coverstatus,

(&abar), &cplussize);

( k = 0; k < nnz; )

( coverstatus[k] == -1 )

(

,

,tmpinds[k]);

( cutcoef == 0.0 )

coverstatus[k] = coverstatus[nnz];

tmpinds[k] = tmpinds[nnz];

varsign[k] = varsign[nnz];

( varsign[k] == -1 )

*success = efficacy > *cutefficacy;

*cutislocal = local;

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

assert(

(coef) != 0.0);

assert( cutefficacy !=

);

*cutefficacy =

(

, sol, cutcoefs, *cutrhs, cutinds, nnz);

( cutrank !=

)

*cutrank = aggrrow->

+ 1;

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

(tmpcoefs[k] != 0.0)

aggrrowintstart;

assert(varsign !=

);

assert(boundtype !=

);

assert(freevariable !=

);

assert(localbdsused !=

);

*freevariable =

;

*localbdsused =

;

( i = 0; i < *nnz && cutinds[i] >= firstcontvar; ++i )

(

(

, vars[v], sol, usevbds ? 2 : 0, allowlocal, bestbds + i, &simplebound, boundtype + i) );

*freevariable =

;

(

(

, vars[v], sol, usevbds ? 2 : 0, allowlocal, bestbds + i, &simplebound, boundtype + i) );

*freevariable =

;

aggrrowintstart = i;

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

assert(i == aggrrowintstart);

assert(v < firstcontvar);

cutinds[i] = cutinds[*nnz];

(

(

, vars[v], sol, boundswitch, 0, allowlocal,

,

,

,

,

&bestlb, &bestub, &bestlbtype, &bestubtype, &selectedbound, freevariable) );

( *freevariable )

boundtype[i] = bestlbtype;

boundtype[i] = bestubtype;

assert(boundtype[i] == -1 || boundtype[i] == -2);

aggrrowintstart;

assert(cutcoefs !=

);

assert(cutinds !=

);

assert(nnz !=

);

assert(boundtype !=

);

assert(varsign !=

);

( i < *nnz && cutinds[i] >= firstcontvar )

assert(cutinds[i] < firstcontvar);

( i = *nnz - 1; i >= 0 && cutinds[i] < firstcontvar; --i )

assert(var !=

);

assert(boundtype[i] == -1 || boundtype[i] == -2);

assert(varsign[i] == +1 || varsign[i] == -1);

cutinds[i] = cutinds[*nnz];

assert(boundtype[i] < 0);

( varsign[i] == +1 )

( boundtype[i] == -1 )

( boundtype[i] == -1 )

aggrrowintstart = i + 1;

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

assert(var !=

);

assert(varsign[i] == +1 || varsign[i] == -1);

( aggrrowintstart > 0 )

assert(aggrrowintstart <= *nnz);

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

*nnz -= aggrrowintstart;

( *nnz < aggrrowintstart )

assert(weights !=

);

assert(slacksign !=

);

assert(rowinds !=

);

assert(cutcoefs !=

);

assert(cutinds !=

);

assert(nnz !=

);

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

assert(slacksign[i] == -1 || slacksign[i] == +1);

assert(row !=

);

( slacksign[i] == +1 )

assert(aggrrow !=

);

assert(cutcoefs !=

);

assert(cutrhs !=

);

assert(cutinds !=

);

assert(success !=

);

assert(cutislocal !=

);

( i = 0; i < aggrrow->

; ++i )

*cutnnz = aggrrow->

;

*cutislocal = aggrrow->

;

( i = 0; i < *cutnnz; ++i )

assert(

(coef) != 0.0);

tmpcoefs,

(&rhs), cutinds, cutnnz, varsign, boundtype, &freevariable, &localbdsused) );

assert(allowlocal || !localbdsused);

*cutislocal = *cutislocal || localbdsused;

( i = *cutnnz - 1; i >= 0 && cutinds[i] < firstcontvar; --i )

aggrrow->

, scale, tmpcoefs,

(&rhs), cutinds, cutnnz,

(f0), k) );

( i = 0; i < *cutnnz; ++i )

assert(

(coef) != 0.0);

( cutefficacy !=

)

*cutefficacy =

(

, sol, cutcoefs, *cutrhs, cutinds, *cutnnz);

( cutrank !=

)

*cutrank = aggrrow->

+ 1;

( i = 0; i < *cutnnz; ++i )

static SCIP_Real computeMIREfficacy(SCIP *scip, SCIP_Real *RESTRICT coefs, SCIP_Real *RESTRICT solvals, SCIP_Real rhs, SCIP_Real contactivity, SCIP_Real contsqrnorm, SCIP_Real delta, int nvars, SCIP_Real minfrac, SCIP_Real maxfrac)

static SCIP_RETCODE cutsTransformMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, SCIP_Bool ignoresol, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, int *varsign, int *boundtype, SCIP_Bool *freevariable, SCIP_Bool *localbdsused)

static void performBoundSubstitutionSimple(SCIP *scip, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int boundtype, SCIP_Real boundval, int probindex, SCIP_Bool *localbdsused)

static void prepareLiftingData(SCIP *scip, SCIP_Real *cutcoefs, int *cutinds, QUAD(SCIP_Real cutrhs), int *coverpos, int coversize, QUAD(SCIP_Real coverweight), SCIP_Real *covervals, int *coverstatus, QUAD(SCIP_Real *abar), int *cplussize)

static SCIP_RETCODE cutsTransformKnapsackCover(SCIP *scip, SCIP_SOL *sol, SCIP_Bool allowlocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, int *varsign, int *boundtype, SCIP_Bool *localbdsused, SCIP_Bool *success)

static SCIP_DECL_SORTINDCOMP(compareAbsCoefsQuad)

static SCIP_RETCODE findBestLb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, int usevbds, SCIP_Bool allowlocal, SCIP_Real *bestlb, SCIP_Real *simplebound, int *bestlbtype)

static SCIP_Real calcEfficacyDenseStorageQuad(SCIP *scip, SCIP_SOL *sol, SCIP_Real *cutcoefs, SCIP_Real cutrhs, int *cutinds, int cutnnz)

static SCIP_Bool removeZerosQuad(SCIP *scip, SCIP_Real minval, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *cutnnz)

static SCIP_RETCODE cutsSubstituteStrongCG(SCIP *scip, SCIP_Real *weights, int *slacksign, int *rowinds, int nrowinds, SCIP_Real scale, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, QUAD(SCIP_Real f0), SCIP_Real k)

static SCIP_RETCODE computeLiftingData(SCIP *scip, SNF_RELAXATION *snf, int *transvarflowcoverstatus, SCIP_Real lambda, LIFTINGDATA *liftingdata, SCIP_Bool *valid)

static SCIP_RETCODE getClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *rowcoefs, int8_t *binvarused, SCIP_Real bestsub, SCIP_Real rowcoef, SCIP_Real *closestvlb, int *closestvlbidx)

static SCIP_RETCODE getFlowCover(SCIP *scip, SNF_RELAXATION *snf, int *nflowcovervars, int *nnonflowcovervars, int *flowcoverstatus, SCIP_Real *lambda, SCIP_Bool *found)

static SCIP_RETCODE determineBestBounds(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real boundswitch, int usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, SCIP_Bool ignoresol, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real *bestlb, SCIP_Real *bestub, int *bestlbtype, int *bestubtype, SCIP_BOUNDTYPE *selectedbound, SCIP_Bool *freevariable)

static SCIP_RETCODE getClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *rowcoefs, int8_t *binvarused, SCIP_Real bestslb, SCIP_Real rowcoef, SCIP_Real *closestvub, int *closestvubidx)

static SCIP_RETCODE cutsTransformStrongCG(SCIP *scip, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, int *varsign, int *boundtype, SCIP_Bool *freevariable, SCIP_Bool *localbdsused)

static SCIP_Real evaluateLiftingFunctionKnapsack(SCIP *scip, QUAD(SCIP_Real x), QUAD(SCIP_Real abar), SCIP_Real *covervals, int coversize, int cplussize, SCIP_Real *scale)

static SCIP_Bool chgCoeffWithBound(SCIP *scip, SCIP_VAR *var, SCIP_Real oldcoeff, SCIP_Real newcoeff, SCIP_Bool cutislocal, QUAD(SCIP_Real *cutrhs))

static SCIP_Bool chgQuadCoeffWithBound(SCIP *scip, SCIP_VAR *var, QUAD(SCIP_Real oldcoeff), SCIP_Real newcoeff, SCIP_Bool cutislocal, QUAD(SCIP_Real *cutrhs))

static SCIP_RETCODE constructSNFRelaxation(SCIP *scip, SCIP_SOL *sol, SCIP_Real boundswitch, SCIP_Bool allowlocal, SCIP_Real *rowcoefs, QUAD(SCIP_Real rowrhs), int *rowinds, int nnz, SNF_RELAXATION *snf, SCIP_Bool *success, SCIP_Bool *localbdsused)

static SCIP_RETCODE postprocessCutQuad(SCIP *scip, SCIP_Bool cutislocal, int *cutinds, SCIP_Real *cutcoefs, int *nnz, QUAD(SCIP_Real *cutrhs), SCIP_Bool *success)

static SCIP_RETCODE cutsRoundMIR(SCIP *scip, SCIP_Real *RESTRICT cutcoefs, QUAD(SCIP_Real *RESTRICT cutrhs), int *RESTRICT cutinds, int *RESTRICT nnz, int *RESTRICT varsign, int *RESTRICT boundtype, QUAD(SCIP_Real f0))

static void performBoundSubstitution(SCIP *scip, int *cutinds, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *nnz, int varsign, int boundtype, SCIP_Real boundval, int probindex, SCIP_Bool *localbdsused)

static void destroyLiftingData(SCIP *scip, LIFTINGDATA *liftingdata)

static SCIP_RETCODE varVecAddScaledRowCoefsQuad(int *RESTRICT inds, SCIP_Real *RESTRICT vals, int *RESTRICT nnz, SCIP_ROW *row, SCIP_Real scale)

static SCIP_Real calcEfficacyNormQuad(SCIP *scip, SCIP_Real *vals, int *inds, int nnz)

static SCIP_RETCODE cutTightenCoefs(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *cutnnz, SCIP_Bool *redundant)

static SCIP_Bool removeZeros(SCIP *scip, SCIP_Real minval, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *cutnnz)

struct LiftingData LIFTINGDATA

static SCIP_RETCODE SCIPsolveKnapsackApproximatelyLT(SCIP *scip, int nitems, SCIP_Real *weights, SCIP_Real *profits, SCIP_Real capacity, int *items, int *solitems, int *nonsolitems, int *nsolitems, int *nnonsolitems, SCIP_Real *solval)

static SCIP_RETCODE determineBoundForSNF(SCIP *scip, SCIP_SOL *sol, SCIP_VAR **vars, SCIP_Real *rowcoefs, int *rowinds, int varposinrow, int8_t *binvarused, SCIP_Bool allowlocal, SCIP_Real boundswitch, SCIP_Real *bestlb, SCIP_Real *bestub, SCIP_Real *bestslb, SCIP_Real *bestsub, int *bestlbtype, int *bestubtype, int *bestslbtype, int *bestsubtype, SCIP_BOUNDTYPE *selectedbounds, SCIP_Bool *freevariable)

static SCIP_RETCODE postprocessCut(SCIP *scip, SCIP_Bool cutislocal, int *cutinds, SCIP_Real *cutcoefs, int *nnz, SCIP_Real *cutrhs, SCIP_Bool *success)

static void destroySNFRelaxation(SCIP *scip, SNF_RELAXATION *snf)

static SCIP_RETCODE allocSNFRelaxation(SCIP *scip, SNF_RELAXATION *snf, int nvars)

static SCIP_RETCODE cutsRoundStrongCG(SCIP *scip, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, int *varsign, int *boundtype, QUAD(SCIP_Real f0), SCIP_Real k)

static SCIP_Real calcEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_Real *cutcoefs, SCIP_Real cutrhs, int *cutinds, int cutnnz)

static void buildFlowCover(SCIP *scip, int *coefs, SCIP_Real *vubcoefs, SCIP_Real rhs, int *solitems, int *nonsolitems, int nsolitems, int nnonsolitems, int *nflowcovervars, int *nnonflowcovervars, int *flowcoverstatus, QUAD(SCIP_Real *flowcoverweight), SCIP_Real *lambda)

static SCIP_RETCODE generateLiftedFlowCoverCut(SCIP *scip, SNF_RELAXATION *snf, SCIP_AGGRROW *aggrrow, int *flowcoverstatus, SCIP_Real lambda, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *nnz, SCIP_Bool *success)

static void getAlphaAndBeta(SCIP *scip, LIFTINGDATA *liftingdata, SCIP_Real vubcoef, int *alpha, SCIP_Real *beta)

static SCIP_RETCODE cutsSubstituteMIR(SCIP *scip, SCIP_Real *weights, int *slacksign, int *rowinds, int nrowinds, SCIP_Real scale, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *nnz, QUAD(SCIP_Real f0))

static SCIP_RETCODE addOneRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, SCIP_Bool sidetypebasis, SCIP_Bool allowlocal, int negslack, int maxaggrlen, SCIP_Bool *rowtoolong)

static SCIP_RETCODE varVecAddScaledRowCoefsQuadScale(int *RESTRICT inds, SCIP_Real *RESTRICT vals, int *RESTRICT nnz, SCIP_ROW *row, QUAD(SCIP_Real scale))

struct SNF_Relaxation SNF_RELAXATION

static SCIP_RETCODE cutTightenCoefsQuad(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, QUAD(SCIP_Real *cutrhs), int *cutinds, int *cutnnz, SCIP_Bool *redundant)

static SCIP_Real evaluateLiftingFunction(SCIP *scip, LIFTINGDATA *liftingdata, SCIP_Real x)

static SCIP_RETCODE varVecAddScaledRowCoefs(int *RESTRICT inds, SCIP_Real *RESTRICT vals, int *RESTRICT nnz, SCIP_ROW *row, SCIP_Real scale)

static SCIP_RETCODE findBestUb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, int usevbds, SCIP_Bool allowlocal, SCIP_Real *bestub, SCIP_Real *simplebound, int *bestubtype)

static SCIP_Bool computeInitialKnapsackCover(SCIP *scip, SCIP_SOL *sol, SCIP_Real *cutcoefs, int *cutinds, SCIP_Real cutrhs, int cutnnz, int *varsign, int *coverstatus, int *coverpos, SCIP_Real *covervals, int *coversize, QUAD(SCIP_Real *coverweight))

methods for the aggregation rows

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

#define QUAD_ARRAY_STORE(a, idx, x)

#define SCIPquadprecProdDD(r, a, b)

#define SCIPquadprecProdQD(r, a, b)

#define SCIPquadprecProdQQ(r, a, b)

#define SCIPquadprecSumQD(r, a, b)

#define QUAD_ARRAY_SIZE(size)

#define SCIPquadprecEpsFloorQ(r, a, eps)

#define QUAD_ASSIGN(a, constant)

#define SCIPquadprecFloorQ(r, a)

#define SCIPquadprecEpsCeilQ(r, a, eps)

#define SCIPquadprecSumDD(r, a, b)

#define SCIPquadprecSumQQ(r, a, b)

#define SCIPquadprecDivDQ(r, a, b)

#define QUAD_ASSIGN_Q(a, b)

#define QUAD_ARRAY_LOAD(r, a, idx)

#define SCIPquadprecDivDD(r, a, b)

#define SCIP_CALL_ABORT(x)

SCIP_RETCODE SCIPsolveKnapsackExactly(SCIP *scip, int nitems, SCIP_Longint *weights, SCIP_Real *profits, SCIP_Longint capacity, int *items, int *solitems, int *nonsolitems, int *nsolitems, int *nnonsolitems, SCIP_Real *solval, SCIP_Bool *success)

int SCIPgetNContVars(SCIP *scip)

SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)

int SCIPgetNVars(SCIP *scip)

SCIP_VAR ** SCIPgetVars(SCIP *scip)

int SCIPgetNBinVars(SCIP *scip)

#define SCIPdebugMsgPrint

SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)

SCIP_RETCODE SCIPcalcIntegralScalar(SCIP_Real *vals, int nvals, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Real *intscalar, SCIP_Bool *success)

SCIP_Real SCIPrelDiff(SCIP_Real val1, SCIP_Real val2)

void SCIPaggrRowCancelVarWithBound(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_VAR *var, int pos, SCIP_Bool *valid)

SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)

int SCIPaggrRowGetRank(SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPcutGenerationHeuristicCMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, int maxtestdelta, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)

SCIP_Bool SCIPcutsTightenCoefficients(SCIP *scip, SCIP_Bool cutislocal, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, int *nchgcoefs)

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

SCIP_RETCODE SCIPcalcStrongCG(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real scale, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)

SCIP_RETCODE SCIPcalcKnapsackCover(SCIP *scip, SCIP_SOL *sol, SCIP_Bool allowlocal, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)

void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPaggrRowCopy(SCIP *scip, SCIP_AGGRROW **aggrrow, SCIP_AGGRROW *source)

SCIP_Bool SCIPaggrRowIsLocal(SCIP_AGGRROW *aggrrow)

SCIP_Real SCIPaggrRowGetRhs(SCIP_AGGRROW *aggrrow)

SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)

int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPaggrRowAddCustomCons(SCIP *scip, SCIP_AGGRROW *aggrrow, int *inds, SCIP_Real *vals, int len, SCIP_Real rhs, SCIP_Real weight, int rank, SCIP_Bool local)

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

int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)

void SCIPaggrRowPrint(SCIP *scip, SCIP_AGGRROW *aggrrow, FILE *file)

void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)

SCIP_Real * SCIPaggrRowGetRowWeights(SCIP_AGGRROW *aggrrow)

int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)

int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPaggrRowSumRows(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real *weights, int *rowinds, int nrowinds, SCIP_Bool sidetypebasis, SCIP_Bool allowlocal, int negslack, int maxaggrlen, SCIP_Bool *valid)

int SCIPgetNCuts(SCIP *scip)

SCIP_RETCODE SCIPaggrRowAddObjectiveFunction(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Real rhs, SCIP_Real scale)

SCIP_RETCODE SCIPcalcFlowCover(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool allowlocal, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)

SCIP_Real SCIPaggrRowCalcEfficacyNorm(SCIP *scip, SCIP_AGGRROW *aggrrow)

SCIP_RETCODE SCIPcalcMIR(SCIP *scip, SCIP_SOL *sol, SCIP_Bool postprocess, SCIP_Real boundswitch, SCIP_Bool usevbds, SCIP_Bool allowlocal, SCIP_Bool fixintegralrhs, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, SCIP_Real minfrac, SCIP_Real maxfrac, SCIP_Real scale, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, int *cutinds, int *cutnnz, SCIP_Real *cutefficacy, int *cutrank, SCIP_Bool *cutislocal, SCIP_Bool *success)

SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)

SCIP_ROW ** SCIPgetLPRows(SCIP *scip)

int SCIPgetNLPRows(SCIP *scip)

#define SCIPfreeCleanBufferArray(scip, ptr)

#define SCIPallocCleanBufferArray(scip, ptr, num)

#define SCIPfreeBlockMemoryArray(scip, ptr, num)

int SCIPcalcMemGrowSize(SCIP *scip, int num)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

#define SCIPallocBlockMemoryArray(scip, ptr, num)

#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)

#define SCIPfreeBlockMemory(scip, ptr)

#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)

#define SCIPfreeBufferArrayNull(scip, ptr)

#define SCIPallocBlockMemory(scip, ptr)

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

SCIP_Real SCIProwGetLhs(SCIP_ROW *row)

SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)

SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIProwGetRhs(SCIP_ROW *row)

SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)

int SCIProwGetLPPos(SCIP_ROW *row)

SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)

SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)

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

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

SCIP_Longint SCIPgetNLPs(SCIP *scip)

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_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfloor(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 SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPfeastol(SCIP *scip)

SCIP_Real SCIPfrac(SCIP *scip, SCIP_Real val)

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_Real SCIPceil(SCIP *scip, SCIP_Real val)

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

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

SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)

SCIP_Real SCIPepsilon(SCIP *scip)

SCIP_Real SCIPsumepsilon(SCIP *scip)

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

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

int SCIPvarGetNVlbs(SCIP_VAR *var)

SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)

SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)

SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)

SCIP_Real SCIPvarGetObj(SCIP_VAR *var)

SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)

SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)

SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)

int SCIPvarGetProbindex(SCIP_VAR *var)

const char * SCIPvarGetName(SCIP_VAR *var)

SCIP_Real * SCIPvarGetVlbConstants(SCIP_VAR *var)

int SCIPvarGetNVubs(SCIP_VAR *var)

SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)

SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)

SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)

SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)

SCIP_Real * SCIPvarGetVubConstants(SCIP_VAR *var)

SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)

SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)

void SCIPselectWeightedDownRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, SCIP_Real *weights, SCIP_Real capacity, int len, int *medianpos)

void SCIPsortDownRealRealInt(SCIP_Real *realarray1, SCIP_Real *realarray2, int *intarray, int len)

SCIP_Bool SCIPsortedvecFindDownReal(SCIP_Real *realarray, SCIP_Real val, int len, int *pos)

void SCIPsortDownReal(SCIP_Real *realarray, int len)

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

void SCIPsortDownInd(int *indarray, SCIP_DECL_SORTINDCOMP((*indcomp)), void *dataptr, int len)

void SCIPsortDownInt(int *intarray, int len)

static SCIP_Bool isIntegralScalar(SCIP_Real val, SCIP_Real scalar, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Real *intval)

internal methods for LP management

memory allocation routines

#define BMScopyMemoryArray(ptr, source, num)

#define BMSmoveMemoryArray(ptr, source, num)

#define BMSclearMemoryArray(ptr, num)

void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)

public methods for LP management

public methods for message output

public data structures and miscellaneous methods

methods for selecting (weighted) k-medians

methods for sorting joint arrays of various types

public methods for problem variables

public methods for cuts and aggregation rows

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for message handling

public methods for numerical tolerances

public methods for global and local (sub)problems

public methods for solutions

public methods for querying solving statistics

public methods for SCIP variables

SCIP_Real * transbinvarsolvals

SCIP_Real * transcontvarsolvals

SCIP_Real * aggrconstants

SCIP_Real * aggrcoefscont

SCIP_Real * transvarvubcoefs

data structures for LP management

SCIP main data structure.

datastructures for global SCIP settings

enum SCIP_BoundType SCIP_BOUNDTYPE

enum SCIP_BaseStat SCIP_BASESTAT

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_VARTYPE_CONTINUOUS

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

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

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