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
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",
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 )
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 )
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 )
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 )
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 )
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;
834 maxtestdelta =
sepadata->maxtestdelta == -1 ? INT_MAX :
sepadata->maxtestdelta;
863 assert(0 <= startrow && startrow < nrows);
881 while( naggrs <= maxaggrs )
909 cutcoefs, &cutrhs, cutinds, &cutnnz, &flowcoverefficacy, &cutrank, &flowcovercutislocal, &flowcoversuccess) );
913 flowcoversuccess =
FALSE;
919 knapsackcoverefficacy = flowcoverefficacy;
924 cutcoefs, &cutrhs, cutinds, &cutnnz, &knapsackcoverefficacy, &cutrank, &knapsackcovercutislocal, &knapsackcoversuccess) );
928 knapsackcoversuccess =
FALSE;
935 cutefficacy = knapsackcoverefficacy;
939 SCIP_CALL(
SCIPcutGenerationHeuristicCMIR(
scip,
sol,
POSTPROCESS,
BOUNDSWITCH,
USEVBDS, allowlocal, maxtestdelta,
NULL,
NULL,
MINFRAC,
MAXFRAC,
940 aggrdata->
aggrrow, cutcoefs, &cutrhs, cutinds, &cutnnz, &cutefficacy, &cutrank, &cmircutislocal, &cmirsuccess) );
951 cmircutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objcmir" :
"cmir",
cutoff, ncuts, &cut) );
953 else if ( knapsackcoversuccess )
957 knapsackcovercutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objlci" :
"lci",
cutoff, ncuts, &cut) );
959 else if ( flowcoversuccess )
963 flowcovercutislocal,
sepadata->dynamiccuts, cutrank, startrow < 0 ?
"objflowcover" :
"flowcover",
cutoff, ncuts, &cut) );
987 for(
i = 0;
i < nrows; ++
i )
991 rowlhsscores[rowinds[
i]] *= fac;
992 rowrhsscores[rowinds[
i]] *= fac;
1006 if( naggrs == maxaggrs )
1008 SCIPdebugMsg(
scip,
" -> abort aggregation: maximal number of aggregations reached\n");
1013 &naggrs, &aggrsuccess) );
1021 SCIPdebugMsg(
scip,
" -> current aggregation has %d/%d nonzeros and consists of %d/%d rows\n",
1047 for(
i = 0;
i < nlpnonz; ++
i )
1119 int knapsackcoverfreq;
1126 sepadata->sepflowcover = flowcoverfreq > 0 ? (
depth % flowcoverfreq) == 0 : flowcoverfreq ==
depth;
1127 sepadata->sepknapsackcover = knapsackcoverfreq > 0 ? (
depth % knapsackcoverfreq) == 0 : knapsackcoverfreq ==
depth;
1149#ifdef IMPLINTSARECONT
1182 fractionalities[v] =
MIN(fractionalities[v], 1.0 - fractionalities[v]);
1190 for( ; v <
nvars; ++v )
1209 fractionalities[v] = 0.0;
1210 if( closestvlbidx != -1 &&
SCIPisEQ(
scip, varsolvals[v], closestvlb) )
1219 fractionalities[v] +=
frac;
1222 if( closestvubidx != -1 &&
SCIPisEQ(
scip, varsolvals[v], closestvub) )
1231 fractionalities[v] +=
frac;
1241 maxsepacuts =
sepadata->maxsepacutsroot;
1249 maxsepacuts =
sepadata->maxsepacuts;
1259 for(
r = 0;
r < nrows;
r++ )
1269 rowlhsscores[
r] = 0.0;
1270 rowrhsscores[
r] = 0.0;
1287 objnorm =
MAX(objnorm, 1.0);
1295 rownorm =
MAX(rownorm, 0.1);
1298 fracscore = fracact / rownorm;
1300 slack = (activity - lhs)/rownorm;
1301 dualscore =
MAX(fracscore * dualsol/objnorm, 0.0001);
1303 && rowdensity <= sepadata->maxrowdensity
1304 && rowdensity <= sepadata->maxaggdensity )
1306 rowlhsscores[
r] = dualscore +
sepadata->densityscore * (1.0-rowdensity) +
sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1307 assert(rowlhsscores[
r] > 0.0);
1310 rowlhsscores[
r] = 0.0;
1312 slack = (rhs - activity)/rownorm;
1313 dualscore =
MAX(-fracscore * dualsol/objnorm, 0.0001);
1315 && rowdensity <= sepadata->maxrowdensity
1316 && rowdensity <= sepadata->maxaggdensity )
1318 rowrhsscores[
r] = dualscore +
sepadata->densityscore * (1.0-rowdensity) +
sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1319 assert(rowrhsscores[
r] > 0.0);
1322 rowrhsscores[
r] = 0.0;
1325 if( fracscore != 0.0 )
1327 roworder[nnonzrows] =
r;
1328 rowscores[nnonzrows] = fracscore;
1334 rowlhsscores[
r], rowrhsscores[
r], rowscores[
r]);
1336 assert(nnonzrows <= nrows);
1360 -1, 2 * maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
FALSE, &ncuts) );
1366 for(
r = 0;
r < nnonzrows && ntries < maxtries && ncuts < maxsepacuts && !
SCIPisStopped(
scip);
r++ )
1370 roworder[
r], maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
FALSE, &ncuts) );
1378 roworder[
r], maxaggrs, &wastried, &
cutoff, cutinds, cutcoefs,
TRUE, &ncuts) );
1390 if( ncuts == oldncuts )
1393 if( nfails >= maxfails )
1418 else if ( ncuts > 0 )
1553 sepaExeclpAggregation, sepaExecsolAggregation,
1573 "maximal number of cmir separation rounds per node (-1: unlimited)",
1576 "separating/" SEPA_NAME "/maxroundsroot",
1577 "maximal number of cmir separation rounds in the root node (-1: unlimited)",
1581 "maximal number of rows to start aggregation with per separation round (-1: unlimited)",
1584 "separating/" SEPA_NAME "/maxtriesroot",
1585 "maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited)",
1589 "maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)",
1592 "separating/" SEPA_NAME "/maxfailsroot",
1593 "maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)",
1597 "maximal number of aggregations for each row per separation round",
1600 "separating/" SEPA_NAME "/maxaggrsroot",
1601 "maximal number of aggregations for each row per separation round in the root node",
1605 "maximal number of cmir cuts separated per separation round",
1608 "separating/" SEPA_NAME "/maxsepacutsroot",
1609 "maximal number of cmir cuts separated per separation round in the root node",
1613 "maximal slack of rows to be used in aggregation",
1616 "separating/" SEPA_NAME "/maxslackroot",
1617 "maximal slack of rows to be used in aggregation in the root node",
1620 "separating/" SEPA_NAME "/densityscore",
1621 "weight of row density in the aggregation scoring of the rows",
1625 "weight of slack in the aggregation scoring of the rows",
1628 "separating/" SEPA_NAME "/maxaggdensity",
1629 "maximal density of aggregated row",
1632 "separating/" SEPA_NAME "/maxrowdensity",
1633 "maximal density of row to be used in aggregation",
1636 "separating/" SEPA_NAME "/densityoffset",
1637 "additional number of variables allowed in row on top of density",
1641 "maximal row aggregation factor",
1644 "separating/" SEPA_NAME "/maxtestdelta",
1645 "maximal number of different deltas to try (-1: unlimited)",
1649 "tolerance for bound distances used to select continuous variable in current aggregated constraint to be eliminated",
1652 "separating/" SEPA_NAME "/trynegscaling",
1653 "should negative values also be tested in scaling?",
1656 "separating/" SEPA_NAME "/fixintegralrhs",
1657 "should an additional variable be complemented if f0 = 0?",
1661 "should generated cuts be removed from the LP if they are no longer tight?",
#define DEFAULT_MAXSEPACUTSROOT
#define DEFAULT_MAXSEPACUTS
#define DEFAULT_MAXROUNDSROOT
#define DEFAULT_MAXROUNDS
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)
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
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_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_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)
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)
struct SCIP_AggrRow SCIP_AGGRROW
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)
struct SCIP_Sepa SCIP_SEPA
#define SCIP_DECL_SEPACOPY(x)