106#define SEPA_NAME "cgmip"
107#define SEPA_DESC "Chvatal-Gomory cuts via MIPs separator"
108#define SEPA_PRIORITY -1000
110#define SEPA_MAXBOUNDDIST 0.0
111#define SEPA_USESSUBSCIP TRUE
112#define SEPA_DELAY FALSE
114#define DEFAULT_MAXROUNDS 5
115#define DEFAULT_MAXROUNDSROOT 50
116#define DEFAULT_MAXDEPTH -1
117#define DEFAULT_DECISIONTREE FALSE
118#define DEFAULT_TIMELIMIT 1e20
119#define DEFAULT_MEMORYLIMIT 1e20
120#define DEFAULT_CUTCOEFBND 1000.0
121#define DEFAULT_MINNODELIMIT 500LL
122#define DEFAULT_MAXNODELIMIT 5000LL
123#define DEFAULT_ONLYACTIVEROWS FALSE
124#define DEFAULT_MAXROWAGE -1
125#define DEFAULT_ONLYRANKONE FALSE
126#define DEFAULT_ONLYINTVARS FALSE
127#define DEFAULT_CONTCONVERT FALSE
128#define DEFAULT_CONTCONVFRAC 0.1
129#define DEFAULT_CONTCONVMIN 100
130#define DEFAULT_INTCONVERT FALSE
131#define DEFAULT_INTCONVFRAC 0.1
132#define DEFAULT_INTCONVMIN 100
133#define DEFAULT_SKIPMULTBOUNDS TRUE
134#define DEFAULT_OBJLONE FALSE
135#define DEFAULT_OBJWEIGHT 1e-03
136#define DEFAULT_OBJWEIGHTSIZE TRUE
137#define DEFAULT_DYNAMICCUTS TRUE
138#define DEFAULT_USECMIR TRUE
139#define DEFAULT_USESTRONGCG FALSE
140#define DEFAULT_CMIROWNBOUNDS FALSE
141#define DEFAULT_USECUTPOOL TRUE
142#define DEFAULT_PRIMALSEPARATION TRUE
143#define DEFAULT_EARLYTERM TRUE
144#define DEFAULT_ADDVIOLATIONCONS FALSE
145#define DEFAULT_ADDVIOLCONSHDLR FALSE
146#define DEFAULT_CONSHDLRUSENORM TRUE
147#define DEFAULT_USEOBJUB FALSE
148#define DEFAULT_USEOBJLB FALSE
149#define DEFAULT_SUBSCIPFAST TRUE
150#define DEFAULT_OUTPUT FALSE
151#define DEFAULT_RANDSEED 101
152#define DEFAULT_GENPRIMALSOLS FALSE
155#define NROWSTOOSMALL 5
156#define NCOLSTOOSMALL 5
158#define EPSILONVALUE 1e-03
159#define BETAEPSILONVALUE 1e-02
160#define STALLNODELIMIT 1000LL
161#define CONSHDLRFULLNORM FALSE
162#define MINEFFICACY 0.05
164#define OBJWEIGHTRANGE 0.01
167#define BOUNDSWITCH 0.9999
169#define POSTPROCESS TRUE
170#define MINFRAC 0.0009
171#define MAXFRAC 0.9991
172#define FIXINTEGRALRHS FALSE
173#define MAKECONTINTEGRAL FALSE
174#define MAXWEIGHTRANGE 1e+05
176#define SEPARATEROWS TRUE
178#define MAXAGGRLEN(nvars) nvars
187 SCIP_Bool decisiontree;
189 SCIP_Real memorylimit;
190 SCIP_Longint minnodelimit;
191 SCIP_Longint maxnodelimit;
192 SCIP_Real cutcoefbnd;
193 SCIP_Bool onlyactiverows;
195 SCIP_Bool onlyrankone;
196 SCIP_Bool onlyintvars;
197 SCIP_Bool allowlocal;
198 SCIP_Bool contconvert;
199 SCIP_Real contconvfrac;
201 SCIP_Bool intconvert;
202 SCIP_Real intconvfrac;
204 SCIP_Bool skipmultbounds;
207 SCIP_Bool objweightsize;
208 SCIP_Bool dynamiccuts;
210 SCIP_Bool usestrongcg;
211 SCIP_Bool cmirownbounds;
212 SCIP_Bool usecutpool;
213 SCIP_Bool primalseparation;
215 SCIP_Bool addviolationcons;
216 SCIP_Bool addviolconshdlr;
217 SCIP_Bool conshdlrusenorm;
220 SCIP_Bool subscipfast;
222 SCIP_Bool genprimalsols;
246 unsigned int ntotalrows;
253 SCIP_Bool* iscomplemented;
254 SCIP_Bool* isshifted;
267 SCIP_Bool conshdlrusenorm;
268 SCIP_Bool conshdlrfullnorm;
281#define CONSHDLR_NAME "violatedCuts"
282#define CONSHDLR_DESC "only allow solutions corresponding to violated cuts"
285struct SCIP_ConshdlrData
327 subscip = mipdata->subscip;
337 if ( mipdata->conshdlrusenorm )
340 if ( mipdata->conshdlrfullnorm )
356 SCIP_CALL(
computeCut(mipdata->scip, mipdata->sepa, mipdata, mipdata->sepadata,
sol,
TRUE,
cutcoefs, &rhs, &
localrowsused, &
localboundsused, &
cutrank, &
success) );
368#ifdef SCIP_MORE_DEBUG
369 for (
j = 0;
j < (
unsigned int)
nvars; ++
j)
379 for (
j = 0;
j < (
unsigned int)
nvars; ++
j)
393 switch ( mipdata->normtype )
397 for (
j = 0;
j < mipdata->ncols; ++
j)
399 var = mipdata->alpha[
j];
413 for (
j = 0;
j < mipdata->ncols; ++
j)
415 var = mipdata->alpha[
j];
429 for (
j = 0;
j < mipdata->ncols; ++
j)
431 var = mipdata->alpha[
j];
444 for (
j = 0;
j < mipdata->ncols; ++
j)
446 var = mipdata->alpha[
j];
461 SCIPerrorMessage(
"invalid efficacy norm parameter '%c'\n", mipdata->normtype);
474 for (
j = 0;
j < mipdata->ncols; ++
j)
476 var = mipdata->alpha[
j];
492 SCIPdebugMsg(
scip,
"Violated cut from solution - act: %f, rhs: %f, norm: %f, eff.: %f\n",
act, rhs, norm, (
act-rhs)/norm);
496 SCIPdebugMsg(
scip,
"Rejected cut from solution - act: %f, rhs: %f, norm: %f, eff.: %f\n",
act, rhs, norm, (
act-rhs)/norm);
610 conshdlrdata->mipdata = mipdata;
614 -1000000, -1000000, 100,
FALSE,
641 SCIP_Real* varsolvals,
672 for (v = 0; v <
nvars; ++v)
677 act += val * varsolvals[v];
686 for (v = 0; v <
nvars; ++v)
691 act += val * varsolvals[v];
700 for (v = 0; v <
nvars; ++v)
705 act += val * varsolvals[v];
713 for (v = 0; v <
nvars; ++v)
718 act += val * varsolvals[v];
819 assert( 0 <= pos && pos < (
int) mipdata->nrows );
834 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
1094 assert( ncols > 0 && nrows > 0 );
1098 mipdata->nrows = (
unsigned int) nrows;
1099 mipdata->ncols = (
unsigned int) ncols;
1100 mipdata->ntotalrows = mipdata->nrows;
1103 mipdata->ntotalrows = mipdata->nrows + 1;
1106 ntotalrows = (int) mipdata->ntotalrows;
1109 mipdata->conshdlrusenorm =
sepadata->conshdlrusenorm;
1113 subscip = mipdata->subscip;
1147 for (
i = 0;
i < nrows; ++
i)
1212 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
1223 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
1241 for (
j = 0;
j < ncols; ++
j)
1269 mipdata->iscomplemented[
j] =
FALSE;
1270 mipdata->isshifted[
j] =
FALSE;
1354 SCIP_CALL(
transformColumn(
origscip,
sepadata, mipdata, col, ub[
j], -1.0, lhs, rhs, &(lb[
j]), &(ub[
j]), &(
primsol[
j])) );
1355 mipdata->iscomplemented[
j] =
TRUE;
1366 SCIP_CALL(
transformColumn(
origscip,
sepadata, mipdata, col, -lb[
j], 1.0, lhs, rhs, &(lb[
j]), &(ub[
j]), &(
primsol[
j])) );
1368 mipdata->isshifted[
j] =
TRUE;
1385 SCIP_CALL(
transformColumn(
origscip,
sepadata, mipdata, col, ub[
j], -1.0, lhs, rhs, &(lb[
j]), &(ub[
j]), &(
primsol[
j])) );
1387 mipdata->iscomplemented[
j] =
TRUE;
1414 SCIPdebugMsg(
origscip,
"Original variables: %d integral, %d continuous, %u shifted, %u complemented, %u at lb, %u at ub\n",
1426 for (
i = 0;
i < nrows; ++
i)
1433 mipdata->ylhs[
i] =
NULL;
1434 mipdata->yrhs[
i] =
NULL;
1454 SCIP_Real weight = -
sepadata->objweight;
1470#ifdef SCIP_MORE_DEBUG
1480#ifdef SCIP_MORE_DEBUG
1490 SCIP_Real weight = 0.0;
1511#ifdef SCIP_MORE_DEBUG
1521 SCIP_Real weight = 0.0;
1541#ifdef SCIP_MORE_DEBUG
1548 assert( (
int) cnt <= 2 * nrows );
1554 SCIP_Real weight = 0.0;
1556 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
1557 mipdata->ylhs[mipdata->nrows] =
NULL;
1558 mipdata->yrhs[mipdata->nrows] =
NULL;
1575#ifdef SCIP_MORE_DEBUG
1576 SCIPdebugMsg(
origscip,
"Created variable <%s> for upper bound on objective (weight: %f).\n", name, weight);
1589#ifdef SCIP_MORE_DEBUG
1590 SCIPdebugMsg(
origscip,
"Created variable <%s> for lower bound on objective (weight: %f).\n", name, weight);
1594 assert( (
int) cnt <= 2 * ntotalrows );
1601 for (
j = 0;
j < ncols; ++
j)
1603 mipdata->z[
j] =
NULL;
1604 mipdata->alpha[
j] =
NULL;
1605 mipdata->fracalpha[
j] =
NULL;
1651 assert( (
int) cnt <= 2 * ncols );
1671 mipdata->n += cnt +
ucnt + 2;
1679 for (
j = 0;
j < ncols; ++
j)
1694 if ( mipdata->iscomplemented[
j] )
1713 assert( 0 <= pos && pos < nrows );
1715 if ( mipdata->ylhs[pos] !=
NULL )
1717 consvars[nconsvars] = mipdata->ylhs[pos];
1721 if ( mipdata->yrhs[pos] !=
NULL )
1723 consvars[nconsvars] = mipdata->yrhs[pos];
1727 assert( nconsvars <= (
int) mipdata->n );
1730 if ( mipdata->z[
j] !=
NULL )
1733 consvars[nconsvars] = mipdata->z[
j];
1737 assert( nconsvars <= (
int) mipdata->n );
1740 consvars[nconsvars] = mipdata->alpha[
j];
1743 assert( nconsvars <= (
int) mipdata->n );
1746 consvars[nconsvars] = mipdata->fracalpha[
j];
1749 assert( nconsvars <= (
int) mipdata->n );
1755 if ( mipdata->ylhs[mipdata->nrows] !=
NULL )
1758 consvars[nconsvars] = mipdata->ylhs[mipdata->nrows];
1764 if ( mipdata->yrhs[mipdata->nrows] !=
NULL )
1767 consvars[nconsvars] = mipdata->yrhs[mipdata->nrows];
1792 if ( mipdata->iscomplemented[
j] )
1811 assert( 0 <= pos && pos < nrows );
1813 if ( mipdata->ylhs[pos] !=
NULL )
1815 consvars[nconsvars] = mipdata->ylhs[pos];
1819 if ( mipdata->yrhs[pos] !=
NULL )
1821 consvars[nconsvars] = mipdata->yrhs[pos];
1825 assert( nconsvars <= (
int) mipdata->n );
1832 if ( mipdata->ylhs[mipdata->nrows] )
1835 consvars[nconsvars] = mipdata->ylhs[mipdata->nrows];
1841 if ( mipdata->yrhs[mipdata->nrows] )
1844 consvars[nconsvars] = mipdata->yrhs[mipdata->nrows];
1867 assert( (
int) cnt <= ncols );
1874 for (
i = 0;
i < nrows; ++
i)
1886 consvars[nconsvars] = mipdata->ylhs[
i];
1894 consvars[nconsvars] = mipdata->yrhs[
i];
1898 assert( nconsvars <= (
int) mipdata->n );
1908 consvars[nconsvars] = mipdata->ylhs[mipdata->nrows];
1909 consvals[nconsvars] = -lhs[mipdata->nrows];
1918 consvars[nconsvars] = mipdata->yrhs[mipdata->nrows];
1919 consvals[nconsvars] = rhs[mipdata->nrows];
1922 assert( nconsvars <= (
int) mipdata->n );
1926 for (
j = 0;
j < ncols; ++
j)
1933 consvars[nconsvars] = mipdata->z[
j];
1936 assert( nconsvars <= (
int) mipdata->n );
1940 consvars[nconsvars] = mipdata->beta;
1945 consvars[nconsvars] = mipdata->fracbeta;
1948 assert( nconsvars <= (
int) mipdata->n );
1962 if ( bestsol !=
NULL )
1965 for (
j = 0;
j < ncols; ++
j)
1967 if ( mipdata->alpha[
j] !=
NULL )
1973 consvars[nconsvars] = mipdata->alpha[
j];
1976 assert( nconsvars <= (
int) mipdata->n );
1979 consvars[nconsvars] = mipdata->beta;
1996 for (
j = 0;
j < ncols; ++
j)
1998 if ( mipdata->alpha[
j] !=
NULL )
2000 consvars[nconsvars] = mipdata->alpha[
j];
2003 assert( nconsvars <= (
int) mipdata->n );
2006 consvars[nconsvars] = mipdata->beta;
2031#ifdef SCIP_WRITEPROB
2035 sepadata->addviolationcons ?
"_vc" :
"",
2036 sepadata->skipmultbounds ?
"_ub" :
"",
2037 sepadata->primalseparation ?
"_ps" :
"",
2060 subscip = mipdata->subscip;
2116#ifdef SCIP_DISABLED_CODE
2173#ifdef SCIP_WRITEPROB
2179 sepadata->addviolationcons ?
"_vc" :
"",
2180 sepadata->skipmultbounds ?
"_ub" :
"",
2181 sepadata->primalseparation ?
"_ps" :
"",
2234 for (
i = 0;
i < nrows; ++
i)
2259#if ( SEPARATEROWS == TRUE )
2303 for (
r = 0;
r < nrows; ++
r)
2375 assert( 0 <= idx && idx < ncols );
2384 val = mipdata->lhs[
r];
2389 val = mipdata->rhs[
r];
2396 for (
c = 0;
c < ncols; ++
c)
2402 if ( mipdata->iscomplemented[
c] )
2435 SCIPdebugMsg(
scip,
"Created %d primal solutions for CG-MIP from tableau cuts (tried: %d).\n",
ngen, ntried);
2453 SCIP_Real timelimit;
2454 SCIP_Real memorylimit;
2455 SCIP_Longint nodelimit;
2464 subscip = mipdata->subscip;
2476 if (
sepadata->timelimit < timelimit )
2482 if ( timelimit > 0.0 )
2496 if (
sepadata->memorylimit < memorylimit )
2497 memorylimit =
sepadata->memorylimit;
2504 if ( memorylimit > 0.0 )
2523 nodelimit =
MAX(
sepadata->minnodelimit, nodelimit);
2524 nodelimit =
MIN(
sepadata->maxnodelimit, nodelimit);
2526 assert( nodelimit >= 0 );
2558 SCIPwarningMessage(
origscip,
"Error while solving subproblem in CGMIP separator; sub-SCIP terminated with code <%d>\n", retcode);
2601 SCIPerrorMessage(
"Solution of subscip for CG-separation returned with invalid status %d.\n", status);
2621 SCIPwarningMessage(
origscip,
"Error while solving subproblem in CGMIP separator; sub-SCIP terminated with code <%d>\n", retcode);
2648 SCIPerrorMessage(
"Solution of subscip for CG-separation returned with invalid status %d.\n", status);
2672 SCIPwarningMessage(
origscip,
"Error while solving subproblem in CGMIP separator; sub-SCIP terminated with code <%d>\n", retcode);
2699 SCIPerrorMessage(
"Solution of subscip for CG-separation returned with invalid status %d.\n", status);
2786 subscip = mipdata->subscip;
2793 assert( nrows == (
int) mipdata->nrows );
2794 assert( ncols == (
int) mipdata->ncols );
2801 for (
i = 0;
i < nrows; ++
i)
2817 if ( mipdata->ylhs[
i] !=
NULL )
2830 if ( mipdata->yrhs[
i] !=
NULL )
2855 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
2857 if ( mipdata->ylhs[mipdata->nrows] !=
NULL )
2866 if ( mipdata->yrhs[mipdata->nrows] !=
NULL )
2882 for (
i = 0;
i < nrows; ++
i)
2902 if ( mipdata->ylhs[
i] !=
NULL )
2917 if ( mipdata->yrhs[
i] !=
NULL )
2992 SCIP_Real weight = 0.0;
2996 assert( mipdata->ntotalrows == mipdata->nrows + 1 );
2998 if ( mipdata->ylhs[mipdata->nrows] !=
NULL )
3012 if ( mipdata->yrhs[mipdata->nrows] !=
NULL )
3032 SCIP_Real
obj = 0.0;
3036 for (
j = 0;
j < ncols; ++
j)
3069 for (
j = 0;
j < ncols; ++
j)
3072 if ( mipdata->z[
j] !=
NULL )
3100 if ( mipdata->iscomplemented[
j] )
3163 if ( mipdata->iscomplemented[pos] )
3165 assert( ! mipdata->isshifted[pos] );
3269 SCIP_Real* varsolvals,
3313 SCIP_CALL(
computeCut(
scip, sepa, mipdata,
sepadata,
sol,
TRUE,
cutcoefs, &
cutrhs, &
localrowsused, &
localboundsused, &
cutrank, &
success) );
3320 SCIP_CALL(
computeCut(
scip, sepa, mipdata,
sepadata,
sol,
FALSE,
cutcoefs, &
cutrhs, &
localrowsused, &
localboundsused, &
cutrank, &
success) );
3335#ifdef SCIP_DISABLED_CODE
3340 SCIP_Real
obj = 0.0;
3347 subscip = mipdata->subscip;
3353 for (
j = 0;
j < mipdata->ncols; ++
j)
3445 SCIPdebugMsg(
scip,
" -> CG-cut <%s>: act=%f, rhs=%f, norm=%f, eff=%f, min=%f, max=%f (range=%f)\n",
3493 SCIP_Real* varsolvals,
3534 subscip = mipdata->subscip;
3539 assert( (
int) mipdata->nrows == nrows );
3549 for (
k = 0;
k < nrows; ++
k)
3554 if ( mipdata->ylhs[
k] !=
NULL )
3568 if ( mipdata->yrhs[
k] !=
NULL )
3610 assert( pos < (
int) mipdata->ncols );
3626 if ( ! mipdata->iscomplemented[pos] )
3633 if ( mipdata->iscomplemented[pos] )
3650 boundtypesfortrans,
MINFRAC,
MAXFRAC, 1.0, aggrrow,
cutcoefs, &
cutrhs,
cutinds, &
cutnnz, &
cutefficacy,
3706 SCIPdebugMsg(
scip,
" -> CG-cut <%s> no longer efficacious: act=%f, rhs=%f, norm=%f, eff=%f\n",
3733 SCIPdebugMsg(
scip,
" -> CG-cut <%s>: act=%f, rhs=%f, norm=%f, eff=%f, rank=%d, min=%f, max=%f (range=%f)\n",
3759 SCIPdebugMsg(
scip,
" -> CG-cut <%s> could not be scaled to integral coefficients: rhs=%f, eff=%f\n",
3783 SCIP_Real* varsolvals,
3822 subscip = mipdata->subscip;
3827 assert( (
int) mipdata->nrows == nrows );
3837 for (
k = 0;
k < nrows; ++
k)
3842 if ( mipdata->ylhs[
k] !=
NULL )
3856 if ( mipdata->yrhs[
k] !=
NULL )
3937 SCIPdebugMsg(
scip,
" -> CG-cut <%s> no longer efficacious: act=%f, rhs=%f, norm=%f, eff=%f\n",
3964 SCIPdebugMsg(
scip,
" -> CG-cut <%s>: act=%f, rhs=%f, norm=%f, eff=%f, rank=%d, min=%f, max=%f (range=%f)\n",
3990 SCIPdebugMsg(
scip,
" -> CG-cut <%s> could not be scaled to integral coefficients: rhs=%f, eff=%f\n",
4016 SCIP_Real* varsolvals;
4039 subscip = mipdata->subscip;
4065 ntotalrows = (int)mipdata->ntotalrows;
4097 varsolvals[
k] = 0.0;
4102 for (s = 0; s < nsols; ++s)
4110 SCIP_CALL(
createCGCutCMIR(
scip, sepa,
sepadata, mipdata,
sol, aggrrow,
cutcoefs,
cutinds,
cutvals, varsolvals, weights,
4116 SCIP_CALL(
createCGCutStrongCG(
scip, sepa,
sepadata, mipdata,
sol, aggrrow,
cutcoefs,
cutinds,
cutvals, varsolvals, weights,
4122 SCIP_CALL(
createCGCutDirect(
scip, sepa,
sepadata, mipdata,
sol,
cutcoefs,
cutinds,
cutvals, varsolvals, weights,
4178 subscip = mipdata->subscip;
4181 for (
j = 0;
j < mipdata->ncols; ++
j)
4193 for (
i = 0;
i < mipdata->nrows; ++
i)
4195 if ( mipdata->ylhs[
i] !=
NULL )
4199 if ( mipdata->yrhs[
i] !=
NULL )
4207 if ( mipdata->yrhs[mipdata->nrows] )
4211 if ( mipdata->ylhs[mipdata->nrows] )
4217 for (
j = 0;
j < mipdata->ncols; ++
j)
4219 if ( mipdata->z[
j] !=
NULL )
4323 unsigned int ngen = 0;
4367 "WARNING - sepa_cgmip: Using objective function bounds and CMIR or Strong-CG functions is useless. Turning off usage of objective function bounds.\n");
4383 SCIP_Real firstlptime;
4388 if ( nrows <= 136 && firstlptime <= 0.05 && ncols <= 143 )
4390 else if ( nrows <= 136 && 0.05 < firstlptime && firstlptime <= 0.15 && ncols <= 143 )
4392 else if ( 136 < nrows && nrows <= 332 && ncols <= 143 )
4394 else if ( 136 < nrows && nrows <= 332 && 655 < ncols && ncols <= 1290 )
4396 else if ( 333 < nrows && nrows <= 874 && 0.15 < firstlptime && firstlptime <= 0.25 && 2614 < ncols && ncols <= 5141 )
4398 else if ( 875 < nrows && nrows <= 1676 && firstlptime <= 0.05 && 143 < ncols && ncols <= 265 )
4400 else if ( 875 < nrows && nrows <= 1676 && firstlptime <= 0.05 && 265 < ncols && ncols <= 654 )
4402 else if ( 875 < nrows && nrows <= 1676 && 0.05 < firstlptime && firstlptime <= 0.15 )
4404 else if ( 875 < nrows && nrows <= 1676 && 0.15 < firstlptime && firstlptime <= 0.25 && 1291 < ncols && ncols <= 2613 )
4406 else if ( nrows > 8146 && 0.75 < firstlptime && firstlptime <= 6.25 && 655 < ncols && ncols <= 1290 )
4408 else if ( nrows > 8146 && 0.75 < firstlptime && firstlptime <= 6.25 && 1291 < ncols && ncols <= 2613 )
4410 else if ( nrows > 8146 && firstlptime > 6.25 )
4422 SCIPdebugMsg(
scip,
"separating CG-cuts via sub-MIPs: %d cols, %d rows\n", ncols, nrows);
4426 mipdata->subscip =
NULL;
4427 mipdata->alpha =
NULL;
4428 mipdata->fracalpha =
NULL;
4429 mipdata->beta =
NULL;
4430 mipdata->fracbeta =
NULL;
4431 mipdata->coltype =
NULL;
4432 mipdata->iscomplemented =
NULL;
4433 mipdata->isshifted =
NULL;
4434 mipdata->ylhs =
NULL;
4435 mipdata->yrhs =
NULL;
4437 mipdata->lhs =
NULL;
4438 mipdata->rhs =
NULL;
4439 mipdata->normtype =
' ';
4442 mipdata->scip =
scip;
4443 mipdata->sepa = sepa;
4474 else if (
ngen > 0 )
4513 "maximal number of cgmip separation rounds per node (-1: unlimited)",
4517 "separating/" SEPA_NAME "/maxroundsroot",
4518 "maximal number of cgmip separation rounds in the root node (-1: unlimited)",
4523 "maximal depth at which the separator is applied (-1: unlimited)",
4527 "separating/" SEPA_NAME "/decisiontree",
4528 "Use decision tree to turn separation on/off?",
4533 "time limit for sub-MIP",
4538 "memory limit for sub-MIP",
4542 "separating/" SEPA_NAME "/minnodelimit",
4543 "minimum number of nodes considered for sub-MIP (-1: unlimited)",
4547 "separating/" SEPA_NAME "/maxnodelimit",
4548 "maximum number of nodes considered for sub-MIP (-1: unlimited)",
4553 "bounds on the values of the coefficients in the CG-cut",
4557 "separating/" SEPA_NAME "/onlyactiverows",
4558 "Use only active rows to generate cuts?",
4563 "maximal age of rows to consider if onlyactiverows is false",
4568 "Separate only rank 1 inequalities w.r.t. CG-MIP separator?",
4573 "Generate cuts for problems with only integer variables?",
4578 "Convert some integral variables to be continuous to reduce the size of the sub-MIP?",
4582 "separating/" SEPA_NAME "/contconvfrac",
4583 "fraction of integral variables converted to be continuous (if contconvert)",
4588 "minimum number of integral variables before some are converted to be continuous",
4593 "Convert some integral variables attaining fractional values to have integral value?",
4598 "fraction of frac. integral variables converted to have integral value (if intconvert)",
4603 "minimum number of integral variables before some are converted to have integral value",
4607 "separating/" SEPA_NAME "/skipmultbounds",
4608 "Skip the upper bounds on the multipliers in the sub-MIP?",
4613 "Should the objective of the sub-MIP minimize the l1-norm of the multipliers?",
4618 "weight used for the row combination coefficient in the sub-MIP objective",
4622 "separating/" SEPA_NAME "/objweightsize",
4623 "Weight each row by its size?",
4628 "should generated cuts be removed from the LP if they are no longer tight?",
4633 "use CMIR-generator (otherwise add cut directly)?",
4638 "use strong CG-function to strengthen cut?",
4642 "separating/" SEPA_NAME "/cmirownbounds",
4643 "tell CMIR-generator which bounds to used in rounding?",
4648 "use cutpool to store CG-cuts even if the are not efficient?",
4652 "separating/" SEPA_NAME "/primalseparation",
4653 "only separate cuts that are tight for the best feasible solution?",
4658 "terminate separation if a violated (but possibly sub-optimal) cut has been found?",
4662 "separating/" SEPA_NAME "/addviolationcons",
4663 "add constraint to subscip that only allows violated cuts (otherwise add obj. limit)?",
4667 "separating/" SEPA_NAME "/addviolconshdlr",
4668 "add constraint handler to filter out violated cuts?",
4672 "separating/" SEPA_NAME "/conshdlrusenorm",
4673 "should the violation constraint handler use the norm of a cut to check for feasibility?",
4678 "Use upper bound on objective function (via primal solution)?",
4683 "Use lower bound on objective function (via primal solution)?",
4688 "Should the settings for the sub-MIP be optimized for speed?",
4693 "Should information about the sub-MIP and cuts be displayed?",
4697 "separating/" SEPA_NAME "/genprimalsols",
4698 "Try to generate primal solutions from Gomory cuts?",
Constraint handler for linear constraints in their most general form, .
methods for the aggregation rows
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
void SCIPsetSubscipDepth(SCIP *scip, int newdepth)
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
int SCIPgetSubscipDepth(SCIP *scip)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPfree(SCIP **scip)
SCIP_RETCODE SCIPcreate(SCIP **scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNObjVars(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
const char * SCIPgetProbName(SCIP *scip)
int SCIPgetNContVars(SCIP *scip)
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
int SCIPgetNBinVars(SCIP *scip)
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPaddLongintParam(SCIP *scip, const char *name, const char *desc, SCIP_Longint *valueptr, SCIP_Bool isadvanced, SCIP_Longint defaultvalue, SCIP_Longint minvalue, SCIP_Longint maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPsetSubscipsOff(SCIP *scip, SCIP_Bool quiet)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPwriteParams(SCIP *scip, const char *filename, SCIP_Bool comments, SCIP_Bool onlychanged)
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPsetEmphasis(SCIP *scip, SCIP_PARAMEMPHASIS paramemphasis, SCIP_Bool quiet)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
SCIP_RETCODE SCIPsetSeparating(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
SCIP_RETCODE SCIPgetCharParam(SCIP *scip, const char *name, char *value)
int SCIPgetNLPBranchCands(SCIP *scip)
int SCIPcolGetLPPos(SCIP_COL *col)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_Bool SCIPcolIsIntegral(SCIP_COL *col)
SCIP_Real SCIPcolGetObj(SCIP_COL *col)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
SCIP_Real SCIPcolGetLb(SCIP_COL *col)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
SCIP_Real SCIPcolGetUb(SCIP_COL *col)
int SCIPcolGetNLPNonz(SCIP_COL *col)
SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr,)
SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
SCIP_CONSHDLRDATA * SCIPconshdlrGetData(SCIP_CONSHDLR *conshdlr)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPgetCutEfficacy(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
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_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
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)
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 SCIPgetLPBasisInd(SCIP *scip, int *basisind)
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
int SCIPgetNLPRows(SCIP *scip)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
int SCIPgetNLPCols(SCIP *scip)
SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
SCIP_Bool SCIProwIsIntegral(SCIP_ROW *row)
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetAge(SCIP_ROW *row)
int SCIProwGetNLPNonz(SCIP_ROW *row)
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
SCIP_RETCODE SCIPmakeRowIntegral(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_SEPA * SCIProwGetOriginSepa(SCIP_ROW *row)
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
int SCIProwGetRank(SCIP_ROW *row)
void SCIProwChgRank(SCIP_ROW *row, int rank)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_BASESTAT SCIProwGetBasisStatus(SCIP_ROW *row)
SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa,)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
int SCIPsepaGetNCallsAtNode(SCIP_SEPA *sepa)
SCIP_RETCODE SCIPsetSepaExit(SCIP *scip, SCIP_SEPA *sepa,)
SCIP_RETCODE SCIPsetSepaInit(SCIP *scip, SCIP_SEPA *sepa,)
SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)
void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa,)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
int SCIPgetNSols(SCIP *scip)
SCIP_SOL ** SCIPgetSols(SCIP *scip)
SCIP_RETCODE SCIPtrySolFree(SCIP *scip, SCIP_SOL **sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Real SCIPgetFirstLPTime(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Bool SCIPisSumPositive(SCIP *scip, SCIP_Real val)
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_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasCeil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPfeasFloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasNegative(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real 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_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisSumZero(SCIP *scip, SCIP_Real val)
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 SCIPisFeasPositive(SCIP *scip, SCIP_Real val)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(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)
int SCIPvarGetProbindex(SCIP_VAR *var)
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetLPSol(SCIP_VAR *var)
SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_Real SCIPrandomGetReal(SCIP_RANDNUMGEN *randnumgen, SCIP_Real minrandval, SCIP_Real maxrandval)
SCIP_RETCODE SCIPincludeSepaCGMIP(SCIP *scip)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIPcreateSol(scip, &heurdata->sol, heur))
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
public methods for managing constraints
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
public methods for separators
public methods for problem variables
public methods for branching rule plugins and branching
public methods for constraint handler plugins and constraints
public methods for problem copies
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 SCIP parameter handling
public methods for global and local (sub)problems
public methods for random numbers
public methods for separator plugins
public methods for solutions
public methods for querying solving statistics
public methods for timing
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_RETCODE SCIPincludeDefaultPlugins(SCIP *scip)
#define DEFAULT_CUTCOEFBND
#define DEFAULT_USECUTPOOL
#define DEFAULT_CONSHDLRUSENORM
#define DEFAULT_ADDVIOLCONSHDLR
static SCIP_RETCODE createSubscip(SCIP *origscip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata)
#define DEFAULT_INTCONVMIN
#define DEFAULT_ADDVIOLATIONCONS
static SCIP_RETCODE createCGCutCMIR(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_SOL *sol, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, int *cutinds, SCIP_Real *cutvals, SCIP_Real *varsolvals, SCIP_Real *weights, int *boundsfortrans, SCIP_BOUNDTYPE *boundtypesfortrans, int *nprevrows, SCIP_ROW **prevrows, SCIP_Bool *cutoff, unsigned int *ngen)
static SCIP_RETCODE solveSubscip(SCIP *origscip, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_Bool *success)
#define DEFAULT_OBJWEIGHT
#define DEFAULT_SKIPMULTBOUNDS
#define DEFAULT_DYNAMICCUTS
#define DEFAULT_MINNODELIMIT
#define DEFAULT_CONTCONVERT
static SCIP_RETCODE computeCut(SCIP *scip, SCIP_SEPA *sepa, CGMIP_MIPDATA *mipdata, SCIP_SEPADATA *sepadata, SCIP_SOL *sol, SCIP_Bool usefrac, SCIP_Real *cutcoefs, SCIP_Real *cutrhs, SCIP_Bool *localrowsused, SCIP_Bool *localboundsused, int *cutrank, SCIP_Bool *success)
static SCIP_RETCODE createCGCutDirect(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_SOL *sol, SCIP_Real *cutcoefs, int *cutinds, SCIP_Real *cutvals, SCIP_Real *varsolvals, SCIP_Real *weights, int *nprevrows, SCIP_ROW **prevrows, SCIP_Bool *cutoff, unsigned int *ngen)
#define DEFAULT_ONLYINTVARS
#define DEFAULT_DECISIONTREE
#define DEFAULT_MAXROUNDSROOT
#define DEFAULT_GENPRIMALSOLS
static SCIP_Real computeObjWeightSize(int rowsize, int minrowsize, int maxrowsize)
static SCIP_RETCODE createCGCutStrongCG(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_SOL *sol, SCIP_AGGRROW *aggrrow, SCIP_Real *cutcoefs, int *cutinds, SCIP_Real *cutvals, SCIP_Real *varsolvals, SCIP_Real *weights, int *nprevrows, SCIP_ROW **prevrows, SCIP_Bool *cutoff, unsigned int *ngen)
#define DEFAULT_ONLYRANKONE
#define DEFAULT_INTCONVERT
#define DEFAULT_CMIROWNBOUNDS
static SCIP_RETCODE createCGMIPprimalsols(SCIP *scip, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata)
#define DEFAULT_EARLYTERM
struct CGMIP_MIPData CGMIP_MIPDATA
static SCIP_RETCODE SCIPincludeConshdlrViolatedCut(SCIP *scip, CGMIP_MIPDATA *mipdata)
#define DEFAULT_PRIMALSEPARATION
static SCIP_RETCODE freeSubscip(SCIP *scip, SCIP_SEPA *sepa, CGMIP_MIPDATA *mipdata)
#define SEPA_MAXBOUNDDIST
#define DEFAULT_CONTCONVMIN
#define MAXAGGRLEN(nvars)
#define DEFAULT_OBJWEIGHTSIZE
static SCIP_RETCODE storeCutInArrays(SCIP *scip, int nvars, SCIP_Real *cutcoefs, SCIP_Real *varsolvals, char normtype, int *cutinds, SCIP_Real *cutvals, int *cutlen, SCIP_Real *cutact, SCIP_Real *cutnorm)
static SCIP_RETCODE transformColumn(SCIP *scip, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_COL *col, SCIP_Real offset, SCIP_Real sigma, SCIP_Real *lhs, SCIP_Real *rhs, SCIP_Real *lb, SCIP_Real *ub, SCIP_Real *primsol)
#define DEFAULT_ONLYACTIVEROWS
static SCIP_RETCODE subscipSetParams(SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata)
#define DEFAULT_MAXROUNDS
#define DEFAULT_MEMORYLIMIT
#define DEFAULT_MAXROWAGE
static SCIP_RETCODE solCutIsViolated(SCIP *scip, CGMIP_MIPDATA *mipdata, SCIP_SOL *sol, SCIP_Bool *violated)
#define DEFAULT_SUBSCIPFAST
#define DEFAULT_MAXNODELIMIT
#define DEFAULT_CONTCONVFRAC
static SCIP_RETCODE createCGCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata, CGMIP_MIPDATA *mipdata, SCIP_Bool *cutoff, unsigned int *ngen)
#define DEFAULT_INTCONVFRAC
enum CGMIP_ColType CGMIP_COLTYPE
#define DEFAULT_TIMELIMIT
#define DEFAULT_USESTRONGCG
Chvatal-Gomory cuts computed via a sub-MIP.
#define SCIP_DECL_CONSENFOLP(x)
struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
#define SCIP_DECL_CONSENFOPS(x)
#define SCIP_DECL_CONSLOCK(x)
#define SCIP_DECL_CONSCHECK(x)
#define SCIP_DECL_CONSFREE(x)
enum SCIP_BoundType SCIP_BOUNDTYPE
enum SCIP_BaseStat SCIP_BASESTAT
@ SCIP_PARAMEMPHASIS_FEASIBILITY
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_SepaData SCIP_SEPADATA
#define SCIP_DECL_SEPAEXECLP(x)
#define SCIP_DECL_SEPAFREE(x)
#define SCIP_DECL_SEPAEXIT(x)
#define SCIP_DECL_SEPACOPY(x)
#define SCIP_DECL_SEPAINIT(x)
enum SCIP_Stage SCIP_STAGE
@ SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_USERINTERRUPT
@ SCIP_STATUS_STALLNODELIMIT
enum SCIP_Status SCIP_STATUS
@ SCIP_VARTYPE_CONTINUOUS