48 #define SEPA_NAME "aggregation" 49 #define SEPA_DESC "aggregation heuristic for complemented mixed integer rounding cuts and flowcover cuts" 50 #define SEPA_PRIORITY -3000 52 #define SEPA_MAXBOUNDDIST 1.0 53 #define SEPA_USESSUBSCIP FALSE 54 #define SEPA_DELAY FALSE 56 #define DEFAULT_MAXROUNDS -1 57 #define DEFAULT_MAXROUNDSROOT -1 58 #define DEFAULT_MAXTRIES 200 60 #define DEFAULT_MAXTRIESROOT -1 62 #define DEFAULT_MAXFAILS 20 63 #define DEFAULT_MAXFAILSROOT 100 65 #define DEFAULT_MAXAGGRS 3 66 #define DEFAULT_MAXAGGRSROOT 6 67 #define DEFAULT_MAXSEPACUTS 100 68 #define DEFAULT_MAXSEPACUTSROOT 500 69 #define DEFAULT_MAXSLACK 0.0 70 #define DEFAULT_MAXSLACKROOT 0.1 71 #define DEFAULT_DENSITYSCORE 1e-4 72 #define DEFAULT_SLACKSCORE 1e-3 73 #define DEFAULT_MAXAGGDENSITY 0.20 74 #define DEFAULT_MAXROWDENSITY 0.05 75 #define DEFAULT_DENSITYOFFSET 100 76 #define DEFAULT_MAXROWFAC 1e+4 77 #define DEFAULT_MAXTESTDELTA -1 78 #define DEFAULT_AGGRTOL 1e-2 82 #define DEFAULT_TRYNEGSCALING TRUE 83 #define DEFAULT_FIXINTEGRALRHS TRUE 84 #define DEFAULT_DYNAMICCUTS TRUE 86 #define BOUNDSWITCH 0.5 87 #define POSTPROCESS TRUE 91 #define MAKECONTINTEGRAL FALSE 92 #define IMPLINTSARECONT 169 const char* cutclassname,
175 assert(scip != NULL);
176 assert(cutcoefs != NULL);
177 assert(cutoff != NULL);
178 assert(ncuts != NULL);
198 cutislocal,
FALSE, cutremovable) );
202 for( i = 0; i < cutnnz; ++i )
210 SCIPdebugMsg(scip,
" -> found potential %s cut <%s>: rhs=%f, eff=%f\n",
211 cutclassname, cutname, cutrhs, cutefficacy);
227 makeintegral =
FALSE;
238 SCIPdebugMsg(scip,
" -> %s cut <%s> no longer efficacious: rhs=%f, eff=%f\n",
239 cutclassname, cutname, cutrhs, cutefficacy);
248 SCIPdebugMsg(scip,
" -> found %s cut <%s>: rhs=%f, eff=%f, rank=%d, min=%f, max=%f (range=%g)\n",
318 firstcontvar = nvars - ncontvars;
320 for( i = nbinvars + nintvars; i < nvars; ++i )
349 if( bestvlbidx >= 0 )
350 bestlb =
MAX(bestlb, bestvlb);
351 if( bestvubidx >= 0 )
352 bestub = MIN(bestub, bestvub);
355 distlb = primsol - bestlb;
356 distub = bestub - primsol;
358 bounddist = MIN(distlb, distub);
359 bounddist =
MAX(bounddist, 0.0);
362 if( i < firstcontvar )
384 int aggrrowsminsize = aggrdata->
naggrrows + ncolnonzeros;
392 for( k = 0; k < ncolnonzeros; ++k )
431 for( k = beg; k < end; ++k )
437 int nextgoodrowpos = beg + ngoodrows;
438 if( k > nextgoodrowpos )
556 firstcontvar = nbinvars + nintvars;
565 for( i = 0; i < nnz; ++i )
570 if( inds[i] < firstcontvar )
575 if( bounddist == 0.0 )
578 badvarinds[nbadvars] = inds[i];
579 badvarbddist[nbadvars] = bounddist;
595 for( i = nbadvars - 1; i >= 0; --i )
605 if( badvarbddist[i] > 0.0 )
610 minbddist = -badvarbddist[i] * (1.0 - sepadata->aggrtol);
613 if( -badvarbddist[i] < minbddist )
616 probvaridx = badvarinds[i];
622 assert(ngoodrows > 0);
624 for( k = 0; k < ngoodrows; ++k )
642 SCIP_Real rowscore =
MAX(rowlhsscores[lppos], rowrhsscores[lppos]);
645 if( aggrfac == 0.0 || rowscore > bestrowscore )
647 bestrow = candrows[k];
648 aggrfac = rowaggrfac;
649 bestrowscore = rowscore;
665 for( i = 0; i < nbadvars; ++i )
675 if( badvarbddist[i] < 0.0 )
680 minbddist = badvarbddist[i] * (1.0 - sepadata->aggrtol);
683 if( badvarbddist[i] < minbddist )
686 probvaridx = badvarinds[i];
694 assert(ngoodrows == 0);
696 for( k = 0; k < nrows; ++k )
722 rowscore = rowlhsscores[lppos];
727 rowscore = rowrhsscores[lppos];
732 if( aggrfac == 0.0 ||
SCIPisGT(scip, rowscore, bestrowscore) ||
735 bestrow = candrows[k];
736 aggrfac = rowaggrfac;
737 bestrowscore = rowscore;
738 bestrowside = rowside;
792 assert(scip != NULL);
793 assert(sepa != NULL);
794 assert(rowlhsscores != NULL);
795 assert(rowrhsscores != NULL);
796 assert(wastried != NULL);
797 assert(cutoff != NULL);
798 assert(ncuts != NULL);
801 assert(sepadata != NULL);
806 assert(nrows == 0 || rows != NULL);
807 assert(0 <= startrow && startrow < nrows);
812 maxaggrnonzs = (int)(sepadata->maxaggdensity *
SCIPgetNLPCols(scip)) + sepadata->densityoffset;
821 maxtestdelta = sepadata->maxtestdelta == -1 ? INT_MAX : sepadata->maxtestdelta;
830 while( naggrs <= maxaggrs )
850 cutcoefs, &cutrhs, cutinds, &cutnnz, &flowcoverefficacy, &cutrank, &flowcovercutislocal, &flowcoversuccess) );
852 cutefficacy = flowcoverefficacy;
853 SCIP_CALL(
SCIPcutGenerationHeuristicCMIR(scip, sol,
POSTPROCESS,
BOUNDSWITCH,
USEVBDS, allowlocal, maxtestdelta, NULL, NULL,
MINFRAC,
MAXFRAC,
854 aggrdata->
aggrrow, cutcoefs, &cutrhs, cutinds, &cutnnz, &cutefficacy, &cutrank, &cmircutislocal, &cmirsuccess) );
860 SCIP_CALL(
addCut(scip, sol, sepadata->cmir,
FALSE, cutcoefs, cutinds, cutnnz, cutrhs, cutefficacy, cmircutislocal,
861 sepadata->dynamiccuts, cutrank,
"cmir", cutoff, ncuts, &cut) );
863 else if ( flowcoversuccess )
865 SCIP_CALL(
addCut(scip, sol, sepadata->flowcover,
FALSE, cutcoefs, cutinds, cutnnz, cutrhs, cutefficacy, flowcovercutislocal,
866 sepadata->dynamiccuts, cutrank,
"flowcover", cutoff, ncuts, &cut) );
890 for( i = 0; i < nrows; ++i )
894 rowlhsscores[rowinds[i]] *= fac;
895 rowrhsscores[rowinds[i]] *= fac;
900 SCIPdebugMsg(scip,
" -> abort aggregation: cut found\n");
909 if( naggrs == maxaggrs )
911 SCIPdebugMsg(scip,
" -> abort aggregation: maximal number of aggregations reached\n");
916 &naggrs, &aggrsuccess) );
924 SCIPdebugMsg(scip,
" -> current aggregation has %d/%d nonzeros and consists of %d/%d rows\n",
952 for( i = 0; i < nlpnonz; ++i )
1008 assert(result != NULL);
1012 assert(sepadata != NULL);
1018 if( (depth == 0 && sepadata->maxroundsroot >= 0 && ncalls >= sepadata->maxroundsroot)
1019 || (depth > 0 && sepadata->maxrounds >= 0 && ncalls >= sepadata->maxrounds) )
1024 assert(nrows == 0 || rows != NULL);
1038 #ifdef IMPLINTSARECONT 1041 nintvars = nvars - ncontvars;
1042 assert(nvars == 0 || vars != NULL);
1068 for( v = 0; v < nintvars; ++v )
1070 fractionalities[v] =
SCIPfeasFrac(scip, varsolvals[v]);
1071 fractionalities[v] = MIN(fractionalities[v], 1.0 - fractionalities[v]);
1079 for( ; v < nvars; ++v )
1098 fractionalities[v] = 0.0;
1099 if( closestvlbidx != -1 &&
SCIPisEQ(scip, varsolvals[v], closestvlb) )
1105 assert(frac >= 0.0 && frac < 1.0);
1106 frac = MIN(frac, 1.0 - frac) * vlbcoefs[closestvlbidx];
1107 fractionalities[v] += frac;
1110 if( closestvubidx != -1 &&
SCIPisEQ(scip, varsolvals[v], closestvub) )
1116 assert(frac >= 0.0 && frac < 1.0);
1117 frac = MIN(frac, 1.0 - frac) * vubcoefs[closestvubidx];
1118 fractionalities[v] += frac;
1125 maxtries = sepadata->maxtriesroot;
1126 maxfails = sepadata->maxfailsroot;
1127 maxaggrs = sepadata->maxaggrsroot;
1128 maxsepacuts = sepadata->maxsepacutsroot;
1129 maxslack = sepadata->maxslackroot;
1133 maxtries = sepadata->maxtries;
1134 maxfails = sepadata->maxfails;
1135 maxaggrs = sepadata->maxaggrs;
1136 maxsepacuts = sepadata->maxsepacuts;
1137 maxslack = sepadata->maxslack;
1147 for( r = 0; r < nrows; r++ )
1158 rowlhsscores[r] = 0.0;
1159 rowrhsscores[r] = 0.0;
1164 roworder[nrows - zerorows] = r;
1181 objnorm =
MAX(objnorm, 1.0);
1189 rownorm =
MAX(rownorm, 0.1);
1192 fracscore = fracact / rownorm;
1194 slack = (activity - lhs)/rownorm;
1195 dualscore =
MAX(fracscore * dualsol/objnorm, 0.0001);
1198 && rowdensity <= sepadata->maxrowdensity
1199 && rowdensity <= sepadata->maxaggdensity )
1201 rowlhsscores[r] = dualscore + sepadata->densityscore * (1.0-rowdensity)
1202 + sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1203 assert(rowlhsscores[r] > 0.0);
1206 rowlhsscores[r] = 0.0;
1208 slack = (rhs - activity)/rownorm;
1209 dualscore =
MAX(-fracscore * dualsol/objnorm, 0.0001);
1212 && rowdensity <= sepadata->maxrowdensity
1213 && rowdensity <= sepadata->maxaggdensity )
1215 rowrhsscores[r] = dualscore + sepadata->densityscore * (1.0-rowdensity)
1216 + sepadata->slackscore *
MAX(1.0 - slack, 0.0);
1217 assert(rowrhsscores[r] > 0.0);
1220 rowrhsscores[r] = 0.0;
1223 rowscores[r] = fracscore;
1224 if( rowscores[r] == 0.0 )
1228 roworder[nrows - zerorows] = r;
1233 for( i = nnonzrows; i > 0 && rowscores[r] > rowscores[roworder[i - 1]]; --i )
1234 roworder[i] = roworder[i - 1];
1242 rowlhsscores[r], rowrhsscores[r], rowscores[r]);
1244 assert(nrows == nnonzrows + zerorows);
1260 for( r = 0; r < nnonzrows && ntries < maxtries && ncuts < maxsepacuts && !
SCIPisStopped(scip); r++ )
1267 roworder[r], maxaggrs, &wastried, &cutoff, cutinds, cutcoefs,
FALSE, &ncuts) );
1272 if( sepadata->trynegscaling && !cutoff )
1275 roworder[r], maxaggrs, &wastried, &cutoff, cutinds, cutcoefs,
TRUE, &ncuts) );
1287 if( ncuts == oldncuts )
1290 if( nfails >= maxfails )
1316 else if ( ncuts > 0 )
1330 assert(scip != NULL);
1331 assert(sepa != NULL);
1348 assert(sepadata != NULL);
1435 assert(sepadata->flowcover != NULL);
1440 assert(sepadata->cmir != NULL);
1445 sepaExeclpAggregation, sepaExecsolAggregation,
1448 assert(sepa != NULL);
1457 "maximal number of cmir separation rounds per node (-1: unlimited)",
1460 "separating/" SEPA_NAME "/maxroundsroot",
1461 "maximal number of cmir separation rounds in the root node (-1: unlimited)",
1465 "maximal number of rows to start aggregation with per separation round (-1: unlimited)",
1468 "separating/" SEPA_NAME "/maxtriesroot",
1469 "maximal number of rows to start aggregation with per separation round in the root node (-1: unlimited)",
1473 "maximal number of consecutive unsuccessful aggregation tries (-1: unlimited)",
1476 "separating/" SEPA_NAME "/maxfailsroot",
1477 "maximal number of consecutive unsuccessful aggregation tries in the root node (-1: unlimited)",
1481 "maximal number of aggregations for each row per separation round",
1484 "separating/" SEPA_NAME "/maxaggrsroot",
1485 "maximal number of aggregations for each row per separation round in the root node",
1489 "maximal number of cmir cuts separated per separation round",
1492 "separating/" SEPA_NAME "/maxsepacutsroot",
1493 "maximal number of cmir cuts separated per separation round in the root node",
1497 "maximal slack of rows to be used in aggregation",
1500 "separating/" SEPA_NAME "/maxslackroot",
1501 "maximal slack of rows to be used in aggregation in the root node",
1504 "separating/" SEPA_NAME "/densityscore",
1505 "weight of row density in the aggregation scoring of the rows",
1509 "weight of slack in the aggregation scoring of the rows",
1512 "separating/" SEPA_NAME "/maxaggdensity",
1513 "maximal density of aggregated row",
1516 "separating/" SEPA_NAME "/maxrowdensity",
1517 "maximal density of row to be used in aggregation",
1520 "separating/" SEPA_NAME "/densityoffset",
1521 "additional number of variables allowed in row on top of density",
1525 "maximal row aggregation factor",
1528 "separating/" SEPA_NAME "/maxtestdelta",
1529 "maximal number of different deltas to try (-1: unlimited)",
1533 "tolerance for bound distances used to select continuous variable in current aggregated constraint to be eliminated",
1536 "separating/" SEPA_NAME "/trynegscaling",
1537 "should negative values also be tested in scaling?",
1540 "separating/" SEPA_NAME "/fixintegralrhs",
1541 "should an additional variable be complemented if f0 = 0?",
1545 "should generated cuts be removed from the LP if they are no longer tight?",
enum SCIP_Result SCIP_RESULT
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 SEPA_MAXBOUNDDIST
int SCIPgetNIntVars(SCIP *scip)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
#define DEFAULT_DENSITYSCORE
void SCIPaggrRowFree(SCIP *scip, SCIP_AGGRROW **aggrrow)
int SCIPaggrRowGetNRows(SCIP_AGGRROW *aggrrow)
#define DEFAULT_MAXFAILSROOT
SCIP_Real * SCIPvarGetVlbCoefs(SCIP_VAR *var)
#define DEFAULT_MAXTESTDELTA
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaggrRowAddRow(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_ROW *row, SCIP_Real weight, int sidetype)
static SCIP_DECL_SEPACOPY(sepaCopyAggregation)
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
#define DEFAULT_MAXROUNDSROOT
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
static SCIP_DECL_SEPAEXECSOL(sepaExecsolAggregation)
#define DEFAULT_MAXSLACKROOT
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
#define DEFAULT_FIXINTEGRALRHS
const char * SCIProwGetName(SCIP_ROW *row)
int SCIProwGetNLPNonz(SCIP_ROW *row)
void SCIPswapPointers(void **pointer1, void **pointer2)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
methods for the aggregation rows
#define DEFAULT_SLACKSCORE
SCIP_Real SCIPinfinity(SCIP *scip)
int SCIPsnprintf(char *t, int len, const char *s,...)
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
enum SCIP_Retcode SCIP_RETCODE
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 SCIPincludeSepaAggregation(SCIP *scip)
int SCIPvarGetProbindex(SCIP_VAR *var)
static SCIP_Real negate(SCIP_Real x)
void SCIPswapReals(SCIP_Real *value1, SCIP_Real *value2)
int SCIPaggrRowGetNNz(SCIP_AGGRROW *aggrrow)
#define SCIPfreeBlockMemory(scip, ptr)
SCIP_VAR ** SCIPvarGetVlbVars(SCIP_VAR *var)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
SCIP_Real SCIPfeasFrac(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPACOPY((*sepacopy)))
SCIP_Real SCIProwGetDualsol(SCIP_ROW *row)
flow cover and complemented mixed integer rounding cuts separator (Marchand's version) ...
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)
int SCIPgetNContVars(SCIP *scip)
SCIP_Real SCIPgetObjNorm(SCIP *scip)
SCIP_Real SCIPepsilon(SCIP *scip)
SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)
SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)
SCIP_Bool SCIPaggrRowHasRowBeenAdded(SCIP_AGGRROW *aggrrow, SCIP_ROW *row)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
#define DEFAULT_MAXROWFAC
SCIP_Bool SCIPisCutEfficacious(SCIP *scip, SCIP_SOL *sol, SCIP_ROW *cut)
static SCIP_Real aggrdataGetBoundDist(AGGREGATIONDATA *aggrdata, int probvaridx)
static SCIP_RETCODE separateCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_Bool allowlocal, SCIP_RESULT *result)
SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)
int * SCIPaggrRowGetRowInds(SCIP_AGGRROW *aggrrow)
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)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
SCIP_RETCODE SCIPgetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
#define DEFAULT_MAXAGGRSROOT
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
#define SCIPfreeBufferArrayNull(scip, ptr)
int SCIPsepaGetNCallsAtNode(SCIP_SEPA *sepa)
SCIP_Bool SCIPisEfficacious(SCIP *scip, SCIP_Real efficacy)
#define DEFAULT_MAXROWDENSITY
void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
int * SCIPaggrRowGetInds(SCIP_AGGRROW *aggrrow)
static SCIP_DECL_SEPAEXECLP(sepaExeclpAggregation)
void SCIPaggrRowRemoveZeros(SCIP *scip, SCIP_AGGRROW *aggrrow, SCIP_Bool *valid)
SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
SCIP_Real * SCIPvarGetVubCoefs(SCIP_VAR *var)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
SCIP_Bool SCIProwIsModifiable(SCIP_ROW *row)
SCIP_Bool SCIPsortedvecFindInt(int *intarray, int val, int len, int *pos)
SCIP_COL ** SCIProwGetCols(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)
#define SCIPallocBufferArray(scip, ptr, num)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
public data structures and miscellaneous methods
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
int SCIPgetNImplVars(SCIP *scip)
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)
static SCIP_Bool getRowAggregationCandidates(AGGREGATIONDATA *aggrdata, int probvaridx, SCIP_ROW ***rows, SCIP_Real **rowvarcoefs, int *nrows, int *ngoodrows)
SCIP_Bool SCIPvarIsInLP(SCIP_VAR *var)
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)
int SCIPgetDepth(SCIP *scip)
int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)
SCIP_RETCODE SCIPaddPoolCut(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)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
static void destroyAggregationData(SCIP *scip, AGGREGATIONDATA *aggrdata)
static SCIP_RETCODE setupAggregationData(SCIP *scip, SCIP_SOL *sol, SCIP_Bool allowlocal, AGGREGATIONDATA *aggrdata)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
#define DEFAULT_TRYNEGSCALING
SCIP_Bool SCIPisCutNew(SCIP *scip, SCIP_ROW *row)
int SCIPgetNBinVars(SCIP *scip)
int SCIProwGetRank(SCIP_ROW *row)
int SCIPgetNVars(SCIP *scip)
#define DEFAULT_MAXSEPACUTS
#define DEFAULT_MAXAGGDENSITY
SCIP_Real SCIProwGetParallelism(SCIP_ROW *row1, SCIP_ROW *row2, char orthofunc)
#define DEFAULT_MAXROUNDS
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define DEFAULT_DENSITYOFFSET
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
void SCIProwChgRank(SCIP_ROW *row, int rank)
static SCIP_DECL_SEPAFREE(sepaFreeAggregation)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPaggrRowCreate(SCIP *scip, SCIP_AGGRROW **aggrrow)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
SCIP_VAR ** SCIPvarGetVubVars(SCIP_VAR *var)
#define DEFAULT_DYNAMICCUTS
static SCIP_Real getRowFracActivity(SCIP_ROW *row, SCIP_Real *fractionalities)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
static INLINE SCIP_Real SCIPaggrRowGetProbvarValue(SCIP_AGGRROW *aggrrow, int probindex)
int SCIPgetNLPCols(SCIP *scip)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPsumepsilon(SCIP *scip)
#define BMSclearMemoryArray(ptr, num)
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
#define DEFAULT_MAXTRIESROOT
void SCIPaggrRowClear(SCIP_AGGRROW *aggrrow)
#define DEFAULT_MAXSEPACUTSROOT
SCIP_Longint SCIPgetNLPs(SCIP *scip)
int SCIPcolGetNLPNonz(SCIP_COL *col)
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_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
SCIP_Real SCIProwGetNorm(SCIP_ROW *row)
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)
struct SCIP_SepaData SCIP_SEPADATA
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)
int SCIPgetNSepaRounds(SCIP *scip)
struct AggregationData AGGREGATIONDATA
#define SCIPreallocBufferArray(scip, ptr, num)