72 SCIP_Real
QUAD(activity);
123#define NONZERO(x) (COPYSIGN(1e-100, (x)) + (x))
145 for(
i = 0 ;
i < row->
len; ++
i )
151 val = vals[probindex];
154 inds[(*nnz)++] = probindex;
156 val += row->
vals[
i] * scale;
162 vals[probindex] = val;
190 for(
i = 0 ;
i < row->
len; ++
i )
200 inds[(*nnz)++] = probindex;
226 QUAD(SCIP_Real scale)
237 for(
i = 0 ;
i < row->
len; ++
i )
248 inds[(*nnz)++] = probindex;
279 SCIP_Real norm = 0.0;
280 SCIP_Real activity = 0.0;
289 switch(
scip->set->sepa_efficacynorm )
341 SCIP_Real norm = 0.0;
342 SCIP_Real
QUAD(coef);
348 switch(
scip->set->sepa_efficacynorm )
351 for(
i = 0;
i < nnz; ++
i )
359 for(
i = 0;
i < nnz; ++
i )
369 for(
i = 0;
i < nnz; ++
i )
376 for(
i = 0;
i < nnz; ++
i )
406 SCIP_Real norm = 0.0;
407 SCIP_Real activity = 0.0;
408 SCIP_Real
QUAD(coef);
418 switch(
scip->set->sepa_efficacynorm )
610 if(
EPSZ(val, minval) || isfixed )
662 SCIP_Real* coefs = (SCIP_Real*) dataptr;
684 SCIP_Real* coefs = (SCIP_Real*) dataptr;
710 SCIP_Real
QUAD(delta);
755 SCIP_Real
QUAD(delta);
805 SCIP_Bool isintegral =
TRUE;
1007 SCIP_Real
QUAD(val);
1019 SCIP_Real maxabsval;
1025 scale = 1.0 / maxabsval;
1036 SCIP_Real
QUAD(val);
1053 SCIP_Real
QUAD(val);
1067 SCIP_Real
QUAD(coef);
1081 SCIP_Real
QUAD(delta);
1088 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1114 SCIP_Real
QUAD(coef);
1128 SCIP_Real
QUAD(delta);
1135 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1179 SCIP_Bool* redundant
1184 SCIP_Bool isintegral =
TRUE;
1389 SCIP_Real maxabsval;
1395 scale = 1.0 / maxabsval;
1431 SCIP_Real
QUAD(coef);
1445 SCIP_Real
QUAD(delta);
1452 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1477 SCIP_Real
QUAD(coef);
1491 SCIP_Real
QUAD(delta);
1498 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1551 SCIP_Real maxabsval = 0.0;
1552 SCIP_Bool redundant =
FALSE;
1637 SCIP_Real coef = (*cutrhs) -
maxact;
1644 SCIP_Real
QUAD(delta);
1651 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1678 SCIP_Real coef =
maxact - (*cutrhs);
1685 SCIP_Real
QUAD(delta);
1692 SCIPdebugMsg(
scip,
"tightened coefficient from %g to %g; rhs changed from %g to %g; the bounds are [%g,%g]\n",
1749 (*aggrrow)->local =
FALSE;
1750 (*aggrrow)->nnz = 0;
1751 (*aggrrow)->rank = 0;
1753 (*aggrrow)->rowsinds =
NULL;
1754 (*aggrrow)->slacksign =
NULL;
1755 (*aggrrow)->rowweights =
NULL;
1756 (*aggrrow)->nrows = 0;
1757 (*aggrrow)->rowssize = 0;
1804 if( aggrrow->
nnz == 0 )
1807 for(
i = 0;
i < aggrrow->
nnz; ++
i )
1809 SCIP_Real
QUAD(val);
1838 (*aggrrow)->nnz =
source->nnz;
1853 (*aggrrow)->rowsinds =
NULL;
1854 (*aggrrow)->slacksign =
NULL;
1855 (*aggrrow)->rowweights =
NULL;
1858 (*aggrrow)->nrows =
source->nrows;
1859 (*aggrrow)->rowssize =
source->nrows;
1860 (*aggrrow)->rank =
source->rank;
1861 (*aggrrow)->local =
source->local;
1901 if( sidetype == -1 )
1906 else if( sidetype == 1 )
1961 SCIP_Real
QUAD(val);
1967 v = aggrrow->
inds[pos];
2020 SCIP_Real
QUAD(val);
2030 if( aggrrow->
nnz == 0 )
2117 for(
i = 0 ;
i < len; ++
i )
2119 SCIP_Real
QUAD(val);
2120 int probindex = inds[
i];
2125 aggrrow->
inds[aggrrow->
nnz++] = probindex;
2150 for(
i = 0;
i < aggrrow->
nnz; ++
i )
2183 SCIP_Bool sidetypebasis,
2184 SCIP_Bool allowlocal,
2293 SCIP_Bool sidetypebasis,
2294 SCIP_Bool allowlocal,
2317 if( rowinds !=
NULL && nrowinds > -1 )
2319 for(
k = 0;
k < nrowinds; ++
k )
2329 for(
k = 0;
k < nrows; ++
k )
2331 if( weights[
k] != 0.0 )
2362 SCIP_Bool redundant;
2365 SCIP_Real
QUAD(rhs);
2395 for(
i = 0;
i < *nnz; ++
i )
2431 SCIP_Bool redundant;
2460 for(
i = 0;
i < *nnz; ++
i )
2463 SCIP_Real
QUAD(coef);
2490 QUAD(&aggrrow->rhs), aggrrow->
inds, &aggrrow->
nnz);
2500 return aggrrow->
nrows;
2539 for(
i = 0;
i < aggrrow->
nrows; ++
i )
2555 return aggrrow->
inds;
2565 return aggrrow->
nnz;
2575 return aggrrow->
rank;
2585 return aggrrow->
local;
2600#define MAXCMIRSCALE 1e+6
2609 SCIP_Bool allowlocal,
2670 SCIP_Bool allowlocal,
2732 SCIP_Bool allowlocal,
2733 SCIP_Bool fixintegralrhs,
2939 SCIP_Real
QUAD(coef);
3016 SCIP_Real
QUAD(coef);
3065 SCIP_Bool allowlocal,
3066 SCIP_Bool fixintegralrhs,
3169 SCIP_Real
QUAD(coef);
3228 if( fixintegralrhs )
3244 for(
i = 0;
i < *nnz;
i++ )
3247 SCIP_Real
QUAD(coef);
3255 if( boundtype[
i] < 0
3302 SCIPerrorMessage(
"Cannot handle closest bounds with ignoring the LP solution.\n");
3320 SCIP_Real
QUAD(coef);
3525 if( boundtype[
i] == -1 )
3541 if( boundtype[
i] == -1 )
3600 if( boundtype[
i] < 0 )
3608 if( boundtype[
i] == -1 )
3624 if( boundtype[
i] == -1 )
3760 for(
i = 0;
i < nrowinds;
i++ )
3773 assert(slacksign[
i] == -1 || slacksign[
i] == +1);
3783 ar = slacksign[
i] * scale * weights[
i];
3829 if( slacksign[
i] == +1 )
3885 SCIP_Bool allowlocal,
3886 SCIP_Bool fixintegralrhs,
3914 SCIP_Real
QUAD(rhs);
3948 SCIP_Real
QUAD(coef);
3949 int k = aggrrow->
inds[
i];
3976 boundsfortrans,
boundtypesfortrans,
minfrac,
maxfrac,
tmpcoefs,
QUAD(&rhs),
tmpinds, &
tmpnnz,
varsign, boundtype, &
freevariable, &
localbdsused) );
4089 SCIP_Real
QUAD(coef);
4158 scale = 1.0 / delta;
4199 return - rhs /
MAX(norm, 1
e-6);
4224 SCIP_Bool allowlocal,
4256 SCIP_Real* bounddist;
4264 SCIP_Real bestefficacy;
4307 SCIP_Real
QUAD(coef);
4331 boundsfortrans,
boundtypesfortrans,
minfrac,
maxfrac,
mksetcoefs,
QUAD(&
mksetrhs),
mksetinds, &
mksetnnz,
varsign, boundtype, &
freevariable, &
localbdsused) );
4351 SCIP_Real
QUAD(coef);
4470 SCIP_Real
QUAD(coef);
4478 if( boundtype[
i] == -1 )
4521 switch( boundtype[
i] )
4549 solval = (coef *
vbdsolval + constant) - solval;
4561 solval = solval - (coef *
vbdsolval + constant);
4574 for(
i = 0;
i < aggrrow->
nrows; ++
i )
4625 for(
i = 0;
i < maxtestdelta; ++
i )
4632 for(
j = 0;
j <
i; ++
j )
4664 for(
i = 2;
i <= 8 ;
i *= 2 )
4712 SCIP_Real
QUAD(coef);
4761 if( bestefficacy > 0.0 )
4779 SCIP_Real
QUAD(coef);
4820 SCIP_Real
QUAD(coef);
4827 SCIPdebugMsg(
scip,
"efficacy of cmir cut is different than expected efficacy: %f != %f\n",
efficacy, bestefficacy);
4858 SCIP_Real
QUAD(coef);
4908#define NO_EXACT_KNAPSACK
4910#ifndef NO_EXACT_KNAPSACK
4911#define MAXDNOM 1000LL
4912#define MINDELTA 1e-03
4913#define MAXDELTA 1e-09
4914#define MAXSCALE 1000.0
4915#define MAXDYNPROGSPACE 1000000
4918#define MAXABSVBCOEF 1e+5
4919#define MAXBOUND 1e+10
4997 *closestvlbidx = -1;
5084 assert(*closestvlbidx >= 0);
5127 *closestvubidx = -1;
5214 assert(*closestvubidx >= 0);
5235 SCIP_Bool allowlocal,
5285 SCIPdebugMsg(
scip,
" %d: %g <%s, idx=%d, lp=%g, [%g(%d),%g(%d)]>:\n",
varposinrow,
rowcoef,
SCIPvarGetName(
var),
probidx,
5410 SCIP_Bool allowlocal,
5425 SCIP_Real
QUAD(transrhs);
5440 SCIPdebugMsg(
scip,
"--------------------- construction of SNF relaxation ------------------------------------\n");
5461 for(
i = nnz - 1;
i >= 0 && rowinds[
i] <
nbinvars; --
i )
5484 for(
j = 0;
j <
i; ++
j )
5505 snf->ntransvars = 0;
5548 SCIP_Real
QUAD(val);
5572 snf->origbinvars[
snf->ntransvars] = -1;
5573 snf->aggrcoefsbin[
snf->ntransvars] = 0.0;
5577 snf->transvarcoefs[
snf->ntransvars] = - 1;
5579 snf->transbinvarsolvals[
snf->ntransvars] = 1.0;
5589 snf->transvarcoefs[
snf->ntransvars] = 1;
5591 snf->transbinvarsolvals[
snf->ntransvars] = 1.0;
5600 SCIPdebugMsg(
scip,
" --> bestlb used for trans: ... %s y'_%d + ..., y'_%d <= %g x_%d (=1), rhs=%g-(%g*%g)=%g\n",
5601 snf->transvarcoefs[
snf->ntransvars] == 1 ?
"+" :
"-",
snf->ntransvars,
snf->ntransvars,
snf->transvarvubcoefs[
snf->ntransvars],
5608 SCIP_Real
QUAD(val);
5655 snf->transvarcoefs[
snf->ntransvars] = - 1;
5668 snf->transvarcoefs[
snf->ntransvars] = 1;
5680 SCIPdebugMsg(
scip,
" --> bestlb used for trans: ... %s y'_%d + ..., y'_%d <= %g x_%d (=%s), rhs=%g-(%g*%g)=%g\n",
5681 snf->transvarcoefs[
snf->ntransvars] == 1 ?
"+" :
"-",
snf->ntransvars,
snf->ntransvars,
snf->transvarvubcoefs[
snf->ntransvars],
5702 SCIP_Real
QUAD(val);
5726 snf->origbinvars[
snf->ntransvars] = -1;
5727 snf->aggrcoefsbin[
snf->ntransvars] = 0.0;
5731 snf->transvarcoefs[
snf->ntransvars] = 1;
5733 snf->transbinvarsolvals[
snf->ntransvars] = 1.0;
5743 snf->transvarcoefs[
snf->ntransvars] = - 1;
5745 snf->transbinvarsolvals[
snf->ntransvars] = 1.0;
5754 SCIPdebugMsg(
scip,
" --> bestub used for trans: ... %s y'_%d + ..., Y'_%d <= %g x_%d (=1), rhs=%g-(%g*%g)=%g\n",
5755 snf->transvarcoefs[
snf->ntransvars] == 1 ?
"+" :
"-",
snf->ntransvars,
snf->ntransvars,
snf->transvarvubcoefs[
snf->ntransvars],
5762 SCIP_Real
QUAD(val);
5807 snf->transvarcoefs[
snf->ntransvars] = 1;
5820 snf->transvarcoefs[
snf->ntransvars] = - 1;
5834 SCIPdebugMsg(
scip,
" --> bestub used for trans: ... %s y'_%d + ..., y'_%d <= %g x_%d (=%s), rhs=%g-(%g*%g)=%g\n",
5835 snf->transvarcoefs[
snf->ntransvars] == 1 ?
"+" :
"-",
snf->ntransvars,
snf->ntransvars,
snf->transvarvubcoefs[
snf->ntransvars],
5843 snf->transvarvubcoefs[
snf->ntransvars] =
MAX(
snf->transvarvubcoefs[
snf->ntransvars], 0.0);
5880 SCIPdebugMsg(
scip,
" %d: %g <%s, idx=%d, lp=%g, [%g, %g]>:\n",
i,
QUAD_TO_DBL(
rowcoef),
SCIPvarGetName(
var),
probidx,
varsolval,
5895 snf->origcontvars[
snf->ntransvars] = -1;
5896 snf->aggrcoefscont[
snf->ntransvars] = 0.0;
5897 snf->aggrconstants[
snf->ntransvars] = 0.0;
5901 snf->transvarcoefs[
snf->ntransvars] = 1;
5902 snf->transvarvubcoefs[
snf->ntransvars] = val;
5912 snf->transvarcoefs[
snf->ntransvars] = - 1;
5913 snf->transvarvubcoefs[
snf->ntransvars] = - val;
5921 assert(
snf->transvarcoefs[
snf->ntransvars] == 1 ||
snf->transvarcoefs[
snf->ntransvars] == - 1 );
5927 SCIPdebugMsg(
scip,
" --> ... %s y'_%d + ..., y'_%d <= %g x_%d (=%s))\n",
snf->transvarcoefs[
snf->ntransvars] == 1 ?
"+" :
"-",
snf->ntransvars,
snf->ntransvars,
5938 SCIPdebugMsg(
scip,
"constraint in constructed 0-1 single node flow relaxation: ");
5939 for(
i = 0;
i <
snf->ntransvars;
i++ )
6038 if( solval !=
NULL )
6045 for(
i = nitems - 1;
i >= 0; --
i )
6066 if( solval !=
NULL )
6072 for( ;
j < nitems;
j++ )
6081 if( solval !=
NULL )
6139 (*nnonflowcovervars)++;
6146 (*nflowcovervars)++;
6156 (*nflowcovervars)++;
6164 (*nnonflowcovervars)++;
6173#ifndef NO_EXACT_KNAPSACK
6191 sval = val * scalar;
6211 SCIP_Longint intval;
6216 sval = val * scalar;
6256#if !defined(NDEBUG) || defined(SCIP_DEBUG)
6281 SCIPdebugMsg(
scip,
"--------------------- get flow cover ----------------------------------------------------\n");
6302#if !defined(NDEBUG) || defined(SCIP_DEBUG)
6318 for(
j = 0;
j <
snf->ntransvars;
j++ )
6320 assert(
snf->transvarcoefs[
j] == 1 ||
snf->transvarcoefs[
j] == -1);
6328 (*nnonflowcovervars)++;
6337 if(
snf->transvarcoefs[
j] == 1 )
6346 else if(
snf->transvarcoefs[
j] == 1 &&
snf->transbinvarsolvals[
j] < 0.5 )
6349 (*nnonflowcovervars)++;
6353 else if(
snf->transvarcoefs[
j] == 1 &&
snf->transbinvarsolvals[
j] > 0.5 )
6356 (*nflowcovervars)++;
6361 else if(
snf->transvarcoefs[
j] == -1 &&
snf->transbinvarsolvals[
j] > 0.5 )
6364 (*nflowcovervars)++;
6371 assert(
snf->transvarcoefs[
j] == -1 &&
snf->transbinvarsolvals[
j] < 0.5);
6373 (*nnonflowcovervars)++;
6412 for(
j = 0;
j < nitems;
j++ )
6434 SCIPdebugMsg(
scip,
" transcapacity = -rhs(%g) + flowcoverweight(%g) + n1itemsweight(%g) = %g\n",
6487 for(
j = 0;
j < nitems; ++
j )
6520#if !defined(NDEBUG) || defined(SCIP_DEBUG)
6580 for(
j = 0;
j <
snf->ntransvars;
j++ )
6656 SCIPdebugMsg(
scip,
"--------------------- get flow cover ----------------------------------------------------\n");
6685 for(
j = 0;
j <
snf->ntransvars;
j++ )
6687 assert(
snf->transvarcoefs[
j] == 1 ||
snf->transvarcoefs[
j] == -1);
6695 (*nnonflowcovervars)++;
6704 if(
snf->transvarcoefs[
j] == 1 )
6715 else if(
snf->transvarcoefs[
j] == 1 &&
snf->transbinvarsolvals[
j] < 0.5 )
6718 (*nnonflowcovervars)++;
6722 else if(
snf->transvarcoefs[
j] == 1 &&
snf->transbinvarsolvals[
j] > 0.5 )
6725 (*nflowcovervars)++;
6730 else if(
snf->transvarcoefs[
j] == -1 &&
snf->transbinvarsolvals[
j] > 0.5 )
6733 (*nflowcovervars)++;
6740 assert(
snf->transvarcoefs[
j] == -1 &&
snf->transbinvarsolvals[
j] < 0.5);
6742 (*nnonflowcovervars)++;
6780 for(
j = 0;
j < nitems;
j++ )
6799 SCIPdebugMsg(
scip,
" transcapacity = -rhs(%g) + flowcoverweight(%g) + n1itemsweight(%g) = %g\n",
6850 for(
j = 0;
j <
snf->ntransvars;
j++ )
7041 for(
i = 0;
i <
snf->ntransvars; ++
i )
7160 SCIP_Real
QUAD(rhs);
7178 for(
i = 0;
i <
snf->ntransvars; ++
i )
7188 if(
snf->origbinvars[
i] != -1 )
7203 if(
snf->origcontvars[
i] != -1 &&
snf->aggrcoefscont[
i] != 0.0 )
7211 if(
snf->origbinvars[
i] != -1 &&
snf->aggrcoefsbin[
i] != 0.0 )
7227 if(
snf->origbinvars[
i] != -1 )
7256 if(
snf->origcontvars[
i] != -1 &&
snf->aggrcoefscont[
i] != 0.0 )
7265 if(
snf->origbinvars[
i] != -1 )
7291 SCIP_Real constant =
snf->aggrconstants[
i];
7316 if(
snf->origcontvars[
i] != -1 &&
snf->aggrcoefscont[
i] != 0.0 )
7336 for(
i = 0;
i < aggrrow->
nrows; ++
i )
7433 SCIP_Bool allowlocal,
7465 SCIP_CALL(
constructSNFRelaxation(
scip,
sol,
boundswitch, allowlocal, aggrrow->
vals,
QUAD(aggrrow->rhs), aggrrow->
inds, aggrrow->
nnz, &
snf,
success, &
localbdsused) );
7497 SCIP_Real
QUAD(rhs);
7555 SCIP_Bool allowlocal,
7598 SCIP_Real
QUAD(coef);
7639 SCIP_Real
QUAD(coef);
7665 SCIP_Real
QUAD(coef);
7722 assert(boundtype[
i] == -1 || boundtype[
i] == -2);
7780 SCIP_Real
QUAD(coef);
7785 solval = 1 - solval;
7820 SCIP_Real
QUAD(coef);
7861 SCIP_Real
QUAD(sigma);
7924 SCIP_Real
QUAD(coef);
8061 SCIP_Bool allowlocal,
8080 SCIP_Real
QUAD(rhs);
8083 SCIP_Bool transformed;
8105 if( aggrrow->
nnz == 0 )
8108 for(
k = 0;
k < aggrrow->
nrows; ++
k )
8131 for(
k = 0;
k < nnz; ++
k )
8133 SCIP_Real
QUAD(coef);
8150 local = aggrrow->
local;
8154 assert(allowlocal || !local);
8177 for(
k = 0;
k < nnz; ++
k )
8225 for(
k = 0;
k < nnz; )
8234 SCIP_Real
QUAD(coef);
8290 for(
k = 0;
k < nnz; ++
k )
8292 SCIP_Real
QUAD(coef);
8321 for(
k = 0;
k < nnz; ++
k )
8390 SCIP_Bool allowlocal,
8433 SCIP_Real
QUAD(coef);
8488 SCIP_Real
QUAD(coef);
8512 SCIP_CALL(
determineBestBounds(
scip,
vars[v],
sol,
boundswitch, 0, allowlocal,
FALSE,
FALSE,
NULL,
NULL,
8538 assert(boundtype[
i] == -1 || boundtype[
i] == -2);
8679 assert(boundtype[
i] == -1 || boundtype[
i] == -2);
8726 if( boundtype[
i] == -1 )
8735 if( boundtype[
i] == -1 )
8854 for(
i = 0;
i < nrowinds;
i++ )
8867 assert(slacksign[
i] == -1 || slacksign[
i] == +1);
8921 if( slacksign[
i] == +1 )
8981 SCIP_Bool allowlocal,
9004 SCIP_Real
QUAD(rhs);
9024 for(
i = 0;
i < aggrrow->
nrows; ++
i )
9047 SCIP_Real
QUAD(coef);
9178 SCIP_Real
QUAD(coef);
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 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,)
static SCIP_Bool chgQuadCoeffWithBound(SCIP *scip, SCIP_VAR *var, QUAD(SCIP_Real oldcoeff), SCIP_Real newcoeff, SCIP_Bool cutislocal,)
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_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 varVecAddScaledRowCoefsQuadScale(int *RESTRICT inds, SCIP_Real *RESTRICT vals, int *RESTRICT nnz, SCIP_ROW *row,)
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_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_Bool chgCoeffWithBound(SCIP *scip, SCIP_VAR *var, SCIP_Real oldcoeff, SCIP_Real newcoeff, SCIP_Bool cutislocal,)
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,)
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_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,)
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)
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)
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 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_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)
assert(minobj< SCIPgetCutoffbound(scip))
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
#define SCIP_DECL_SORTINDCOMP(x)
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS