76#define SEPA_NAME "aggregation"
77#define SEPA_DESC "aggregation heuristic for complemented mixed integer rounding cuts and flowcover cuts"
78#define SEPA_PRIORITY -3000
80#define SEPA_MAXBOUNDDIST 1.0
81#define SEPA_USESSUBSCIP FALSE
82#define SEPA_DELAY FALSE
84#define DEFAULT_MAXROUNDS -1
85#define DEFAULT_MAXROUNDSROOT -1
86#define DEFAULT_MAXTRIES 200
88#define DEFAULT_MAXTRIESROOT -1
90#define DEFAULT_MAXFAILS 20
91#define DEFAULT_MAXFAILSROOT 100
93#define DEFAULT_MAXAGGRS 3
94#define DEFAULT_MAXAGGRSROOT 6
95#define DEFAULT_MAXSEPACUTS 100
96#define DEFAULT_MAXSEPACUTSROOT 500
97#define DEFAULT_MAXSLACK 0.0
98#define DEFAULT_MAXSLACKROOT 0.1
99#define DEFAULT_DENSITYSCORE 1e-4
100#define DEFAULT_SLACKSCORE 1e-3
101#define DEFAULT_MAXAGGDENSITY 0.20
102#define DEFAULT_MAXROWDENSITY 0.05
103#define DEFAULT_DENSITYOFFSET 100
104#define DEFAULT_MAXROWFAC 1e+4
105#define DEFAULT_MAXTESTDELTA -1
106#define DEFAULT_AGGRTOL 1e-2
110#define DEFAULT_TRYNEGSCALING TRUE
111#define DEFAULT_FIXINTEGRALRHS TRUE
112#define DEFAULT_DYNAMICCUTS TRUE
114#define BOUNDSWITCH 0.5
115#define POSTPROCESS TRUE
119#define MAKECONTINTEGRAL FALSE
120#define IMPLINTSARECONT
131 SCIP_Real maxslackroot;
132 SCIP_Real densityscore;
133 SCIP_Real slackscore;
134 SCIP_Real maxaggdensity;
135 SCIP_Real maxrowdensity;
154 SCIP_Bool trynegscaling;
155 SCIP_Bool fixintegralrhs;
156 SCIP_Bool dynamiccuts;
157 SCIP_Bool sepflowcover;
158 SCIP_Bool sepknapsackcover;
193 SCIP_Bool makeintegral,
198 SCIP_Real cutefficacy,
199 SCIP_Bool cutislocal,
200 SCIP_Bool cutremovable,
202 const char* cutclassname,
234 for(
i = 0;
i < cutnnz; ++
i )
242 SCIPdebugMsg(
scip,
" -> found potential %s cut <%s>: rhs=%f, eff=%f\n", cutclassname, cutname, cutrhs, cutefficacy);
257 makeintegral =
FALSE;
268 SCIPdebugMsg(
scip,
" -> %s cut <%s> no longer efficacious: rhs=%f, eff=%f\n", cutclassname, cutname, cutrhs, cutefficacy);
277 SCIPdebugMsg(
scip,
" -> found %s cut <%s>: rhs=%f, eff=%f, rank=%d, min=%f, max=%f (range=%g)\n",
315 SCIP_Bool allowlocal,
348 firstcontvar =
nvars - ncontvars;
377 if( bestvlbidx >= 0 )
378 bestlb =
MAX(bestlb, bestvlb);
379 if( bestvubidx >= 0 )
380 bestub =
MIN(bestub, bestvub);
386 bounddist =
MIN(distlb, distub);
387 bounddist =
MAX(bounddist, 0.0);
390 if(
i < firstcontvar )
412 int aggrrowsminsize = aggrdata->
naggrrows + ncolnonzeros;
424 for( k = 0; k < ncolnonzeros; ++k )
466 for( k = beg; k < end; ++k )
474 int nextgoodrowpos = beg + ngoodrows;
475 if( k > nextgoodrowpos )
521 SCIP_Real** rowvarcoefs,
563 SCIP_Real* rowlhsscores,
564 SCIP_Real* rowrhsscores,
574 SCIP_Real* badvarbddist;
578 SCIP_Real bestrowscore;
597 for(
i = 0;
i < nnz; ++
i )
602 if( inds[
i] < firstcontvar )
607 if( bounddist == 0.0 )
610 badvarinds[nbadvars] = inds[
i];
611 badvarbddist[nbadvars] = bounddist;
627 for(
i = nbadvars - 1;
i >= 0; --
i )
631 SCIP_Real* candrowcoefs;
637 if( badvarbddist[
i] > 0.0 )
642 minbddist = -badvarbddist[
i] * (1.0 -
sepadata->aggrtol);
645 if( -badvarbddist[
i] < minbddist )
648 probvaridx = badvarinds[
i];
654 assert(ngoodrows <= nrows);
656 for( k = 0; k < ngoodrows; ++k )
658 SCIP_Real rowaggrfac;
675 rowscore =
MAX(rowlhsscores[lppos], rowrhsscores[lppos]);
678 if( aggrfac == 0.0 || rowscore > bestrowscore )
680 bestrow = candrows[k];
681 aggrfac = rowaggrfac;
682 bestrowscore = rowscore;
697 for(
i = 0;
i < nbadvars; ++
i )
701 SCIP_Real* candrowcoefs;
707 if( badvarbddist[
i] < 0.0 )
712 minbddist = badvarbddist[
i] * (1.0 -
sepadata->aggrtol);
715 if( badvarbddist[
i] < minbddist )
718 probvaridx = badvarinds[
i];
726 for( k = 0; k < nrows; ++k )
728 SCIP_Real rowaggrfac;
749 rowscore = rowlhsscores[lppos];
754 rowscore = rowrhsscores[lppos];
759 if( aggrfac == 0.0 ||
SCIPisGT(
scip, rowscore, bestrowscore) ||
762 bestrow = candrows[k];
763 aggrfac = rowaggrfac;
764 bestrowscore = rowscore;
765 bestrowside = rowside;
792 SCIP_Bool allowlocal,
793 SCIP_Real* rowlhsscores,
794 SCIP_Real* rowrhsscores,
808 SCIP_Real startweight;
809 SCIP_Real startrowact;
834 maxtestdelta =
sepadata->maxtestdelta == -1 ? INT_MAX :
sepadata->maxtestdelta;
865 assert(0 <= startrow && startrow < nrows);
883 while( naggrs <= maxaggrs )
887 SCIP_Bool aggrsuccess;
888 SCIP_Bool cmirsuccess;
889 SCIP_Bool cmircutislocal =
FALSE;
890 SCIP_Bool flowcoversuccess;
891 SCIP_Real flowcoverefficacy;
892 SCIP_Bool flowcovercutislocal =
FALSE;
893 SCIP_Bool knapsackcoversuccess;
894 SCIP_Real knapsackcoverefficacy;
895 SCIP_Bool knapsackcovercutislocal =
FALSE;
898 SCIP_Real cutefficacy;
911 cutcoefs, &cutrhs, cutinds, &cutnnz, &flowcoverefficacy, &cutrank, &flowcovercutislocal, &flowcoversuccess) );
915 flowcoversuccess =
FALSE;
921 knapsackcoverefficacy = flowcoverefficacy;
926 cutcoefs, &cutrhs, cutinds, &cutnnz, &knapsackcoverefficacy, &cutrank, &knapsackcovercutislocal, &knapsackcoversuccess) );
930 knapsackcoversuccess =
FALSE;
937 cutefficacy = knapsackcoverefficacy;
941 SCIP_CALL(
SCIPcutGenerationHeuristicCMIR(
scip,
sol,
POSTPROCESS,
BOUNDSWITCH,
USEVBDS, allowlocal, maxtestdelta,
NULL,
NULL,
MINFRAC,
MAXFRAC,
942 aggrdata->
aggrrow, cutcoefs, &cutrhs, cutinds, &cutnnz, &cutefficacy, &cutrank, &cmircutislocal, &cmirsuccess) );
953 cmircutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objcmir" :
"cmir",
cutoff, ncuts, &cut) );
955 else if ( knapsackcoversuccess )
959 knapsackcovercutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objlci" :
"lci",
cutoff, ncuts, &cut) );
961 else if ( flowcoversuccess )
965 flowcovercutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objflowcover" :
"flowcover",
cutoff, ncuts, &cut) );
989 for(
i = 0;
i < nrows; ++
i )
993 rowlhsscores[rowinds[
i]] *= fac;
994 rowrhsscores[rowinds[
i]] *= fac;
1008 if( naggrs == maxaggrs )
1010 SCIPdebugMsg(
scip,
" -> abort aggregation: maximal number of aggregations reached\n");
1015 &naggrs, &aggrsuccess) );
1023 SCIPdebugMsg(
scip,
" -> current aggregation has %d/%d nonzeros and consists of %d/%d rows\n",
1036 SCIP_Real* fractionalities
1043 SCIP_Real fracsum = 0.0;
1049 for(
i = 0;
i < nlpnonz; ++
i )
1064 SCIP_Bool allowlocal,
1072 SCIP_Real* varsolvals;
1073 SCIP_Real* bestcontlbs;
1074 SCIP_Real* bestcontubs;
1075 SCIP_Real* fractionalities;
1077 SCIP_Real* rowlhsscores;
1078 SCIP_Real* rowrhsscores;
1079 SCIP_Real* rowscores;
1102 SCIP_Real* cutcoefs;
1121 int knapsackcoverfreq;
1128 sepadata->sepflowcover = flowcoverfreq > 0 ? (
depth % flowcoverfreq) == 0 : flowcoverfreq ==
depth;
1129 sepadata->sepknapsackcover = knapsackcoverfreq > 0 ? (
depth % knapsackcoverfreq) == 0 : knapsackcoverfreq ==
depth;
1151#ifdef IMPLINTSARECONT
1184 fractionalities[v] =
MIN(fractionalities[v], 1.0 - fractionalities[v]);
1192 for( ; v <
nvars; ++v )
1196 SCIP_Real* vlbcoefs;
1197 SCIP_Real* vubcoefs;
1198 SCIP_Real closestvlb;
1199 SCIP_Real closestvub;
1211 fractionalities[v] = 0.0;
1212 if( closestvlbidx != -1 &&
SCIPisEQ(
scip, varsolvals[v], closestvlb) )
1221 fractionalities[v] +=
frac;
1224 if( closestvubidx != -1 &&
SCIPisEQ(
scip, varsolvals[v], closestvub) )
1233 fractionalities[v] +=
frac;
1243 maxsepacuts =
sepadata->maxsepacutsroot;
1251 maxsepacuts =
sepadata->maxsepacuts;
1261 for(
r = 0;
r < nrows;
r++ )
1271 rowlhsscores[
r] = 0.0;
1272 rowrhsscores[
r] = 0.0;
1280 SCIP_Real dualscore;
1281 SCIP_Real rowdensity;
1285 SCIP_Real fracscore;
1289 objnorm =
MAX(objnorm, 1.0);
1297 rownorm =
MAX(rownorm, 0.1);
1300 fracscore = fracact / rownorm;
1302 slack = (activity - lhs)/rownorm;
1303 dualscore =
MAX(fracscore * dualsol/objnorm, 0.0001);
1305 && rowdensity <= sepadata->maxrowdensity
1306 && rowdensity <= sepadata->maxaggdensity )
1308 rowlhsscores[
r] = dualscore +
sepadata->densityscore * (1.0-rowdensity) +
sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1309 assert(rowlhsscores[
r] > 0.0);
1312 rowlhsscores[
r] = 0.0;
1314 slack = (rhs - activity)/rownorm;
1315 dualscore =
MAX(-fracscore * dualsol/objnorm, 0.0001);
1317 && rowdensity <= sepadata->maxrowdensity
1318 && rowdensity <= sepadata->maxaggdensity )
1320 rowrhsscores[
r] = dualscore +
sepadata->densityscore * (1.0-rowdensity) +
sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1321 assert(rowrhsscores[
r] > 0.0);
1324 rowrhsscores[
r] = 0.0;
1327 if( fracscore != 0.0 )
1329 roworder[nnonzrows] =
r;
1330 rowscores[nnonzrows] = fracscore;
1336 rowlhsscores[
r], rowrhsscores[
r], rowscores[
r]);
1338 assert(nnonzrows <= nrows);
1362 -1, 2 * maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
FALSE, &ncuts) );
1368 for(
r = 0;
r < nnonzrows && ntries < maxtries && ncuts < maxsepacuts && !
SCIPisStopped(
scip);
r++ )
1372 roworder[
r], maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
FALSE, &ncuts) );
1380 roworder[
r], maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
TRUE, &ncuts) );
1392 if( ncuts == oldncuts )
1395 if( nfails >= maxfails )
1420 else if ( ncuts > 0 )
1555 sepaExeclpAggregation, sepaExecsolAggregation,
1575 "maximal number of cmir separation rounds per node (-1: unlimited)",
1578 "separating/" SEPA_NAME "/maxroundsroot",
1579 "maximal number of cmir separation rounds in the root node (-1: unlimited)",
1583 "maximal number of rows to start aggregation with per separation round (-1: unlimited)",
1586 "separating/" SEPA_NAME "/maxtriesroot",
1587 "maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited)",
1591 "maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)",
1594 "separating/" SEPA_NAME "/maxfailsroot",
1595 "maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)",
1599 "maximal number of aggregations for each row per separation round",
1602 "separating/" SEPA_NAME "/maxaggrsroot",
1603 "maximal number of aggregations for each row per separation round in the root node",
1607 "maximal number of cmir cuts separated per separation round",
1610 "separating/" SEPA_NAME "/maxsepacutsroot",
1611 "maximal number of cmir cuts separated per separation round in the root node",
1615 "maximal slack of rows to be used in aggregation",
1618 "separating/" SEPA_NAME "/maxslackroot",
1619 "maximal slack of rows to be used in aggregation in the root node",
1622 "separating/" SEPA_NAME "/densityscore",
1623 "weight of row density in the aggregation scoring of the rows",
1627 "weight of slack in the aggregation scoring of the rows",
1630 "separating/" SEPA_NAME "/maxaggdensity",
1631 "maximal density of aggregated row",
1634 "separating/" SEPA_NAME "/maxrowdensity",
1635 "maximal density of row to be used in aggregation",
1638 "separating/" SEPA_NAME "/densityoffset",
1639 "additional number of variables allowed in row on top of density",
1643 "maximal row aggregation factor",
1646 "separating/" SEPA_NAME "/maxtestdelta",
1647 "maximal number of different deltas to try (-1: unlimited)",
1651 "tolerance for bound distances used to select continuous variable in current aggregated constraint to be eliminated",
1654 "separating/" SEPA_NAME "/trynegscaling",
1655 "should negative values also be tested in scaling?",
1658 "separating/" SEPA_NAME "/fixintegralrhs",
1659 "should an additional variable be complemented if f0 = 0?",
1663 "should generated cuts be removed from the LP if they are no longer tight?",
methods for the aggregation rows
#define SCIP_LONGINT_FORMAT
SCIP_Bool SCIPisStopped(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
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)
SCIP_Real SCIPgetObjNorm(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
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 SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
void SCIPswapPointers(void **pointer1, void **pointer2)
void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
int SCIPcolGetNLPNonz(SCIP_COL *col)
SCIP_RETCODE SCIPaddPoolCut(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)
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_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
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_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool useglbbounds, SCIP_Bool *valid)
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)
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_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
int SCIPgetNLPCols(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPfreeBufferArrayNull(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
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)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(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_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 SCIProwGetDualsol(SCIP_ROW *row)
int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
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)
int SCIPsepaGetFreq(SCIP_SEPA *sepa)
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa,)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
int SCIPsepaGetNCallsAtNode(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,)
void SCIPsetSepaIsParentsepa(SCIP *scip, SCIP_SEPA *sepa)
void SCIPsetSepaParentsepa(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPA *parentsepa)
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIPgetUpperbound(SCIP *scip)
int SCIPgetNSepaRounds(SCIP *scip)
SCIP_Longint SCIPgetNLPs(SCIP *scip)
SCIP_Real SCIPgetCutoffbound(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
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_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisGT(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_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(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)
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
SCIP_RETCODE SCIPincludeSepaAggregation(SCIP *scip)
SCIP_Bool SCIPsortedvecFindInt(int *intarray, int val, int len, int *pos)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
assert(minobj< SCIPgetCutoffbound(scip))
static SCIP_Real negate(SCIP_Real x)
memory allocation routines
#define BMSclearMemoryArray(ptr, num)
public methods for LP management
public methods for message output
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for separators
public methods for problem variables
public methods for branching rule plugins and branching
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 separator plugins
public methods for solutions
public methods for querying solving statistics
public methods for the branch-and-bound tree
public methods for SCIP variables
struct AggregationData AGGREGATIONDATA
#define DEFAULT_SLACKSCORE
static SCIP_RETCODE addCut(SCIP *scip, SCIP_SOL *sol, SCIP_SEPA *sepa, SCIP_Bool makeintegral, SCIP_Real *cutcoefs, int *cutinds, int cutnnz, SCIP_Real cutrhs, SCIP_Real cutefficacy, SCIP_Bool cutislocal, SCIP_Bool cutremovable, int cutrank, const char *cutclassname, SCIP_Bool *cutoff, int *ncuts, SCIP_ROW **thecut)
#define DEFAULT_DYNAMICCUTS
static SCIP_Bool getRowAggregationCandidates(AGGREGATIONDATA *aggrdata, int probvaridx, SCIP_ROW ***rows, SCIP_Real **rowvarcoefs, int *nrows, int *ngoodrows)
static SCIP_Real aggrdataGetBoundDist(AGGREGATIONDATA *aggrdata, int probvaridx)
#define DEFAULT_MAXSLACKROOT
#define DEFAULT_MAXFAILSROOT
#define DEFAULT_MAXAGGRSROOT
#define DEFAULT_MAXROUNDSROOT
static SCIP_RETCODE aggregateNextRow(SCIP *scip, SCIP_SEPADATA *sepadata, SCIP_Real *rowlhsscores, SCIP_Real *rowrhsscores, AGGREGATIONDATA *aggrdata, SCIP_AGGRROW *aggrrow, int *naggrs, SCIP_Bool *success)
#define DEFAULT_TRYNEGSCALING
#define DEFAULT_MAXTRIESROOT
#define DEFAULT_MAXROWFAC
#define DEFAULT_MAXSEPACUTSROOT
#define DEFAULT_DENSITYSCORE
#define DEFAULT_DENSITYOFFSET
#define DEFAULT_FIXINTEGRALRHS
static SCIP_RETCODE setupAggregationData(SCIP *scip, SCIP_SOL *sol, SCIP_Bool allowlocal, AGGREGATIONDATA *aggrdata)
#define DEFAULT_MAXTESTDELTA
#define SEPA_MAXBOUNDDIST
#define DEFAULT_MAXSEPACUTS
#define DEFAULT_MAXAGGDENSITY
static SCIP_RETCODE aggregation(SCIP *scip, AGGREGATIONDATA *aggrdata, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_Bool allowlocal, SCIP_Real *rowlhsscores, SCIP_Real *rowrhsscores, int startrow, int maxaggrs, SCIP_Bool *wastried, SCIP_Bool *cutoff, int *cutinds, SCIP_Real *cutcoefs, SCIP_Bool negate, int *ncuts)
static SCIP_Real getRowFracActivity(SCIP_ROW *row, SCIP_Real *fractionalities)
#define DEFAULT_MAXROUNDS
static void destroyAggregationData(SCIP *scip, AGGREGATIONDATA *aggrdata)
#define DEFAULT_MAXROWDENSITY
static SCIP_RETCODE separateCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_Bool allowlocal, int depth, SCIP_RESULT *result)
flow cover and complemented mixed integer rounding cuts separator (Marchand's version)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_SepaData SCIP_SEPADATA
#define SCIP_DECL_SEPAEXECSOL(x)
#define SCIP_DECL_SEPAEXECLP(x)
#define SCIP_DECL_SEPAFREE(x)
#define SCIP_DECL_SEPACOPY(x)