/** presolving method of propagator */
static
SCIP_DECL_PROPPRESOL(propPresolDualfix)
{ /*lint --e{715}*/
SCIP_Bool cutoff;
SCIP_Bool unbounded;
int oldnfixedvars;
assert(prop != NULL);
assert(strcmp(SCIPpropGetName(prop), PROP_NAME) == 0);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
if( !SCIPallowDualReds(scip) )
return SCIP_OKAY;
cutoff = FALSE;
unbounded = FALSE;
oldnfixedvars = *nfixedvars;
SCIP_CALL( performDualfix(scip, nfixedvars, &unbounded, &cutoff) );
/* evaluate propagation result */
if( cutoff )
*result = SCIP_CUTOFF;
else if( unbounded )
*result = SCIP_UNBOUNDED;
else if( *nfixedvars > oldnfixedvars )
*result = SCIP_SUCCESS;
else
*result = SCIP_DIDNOTFIND;
return SCIP_OKAY;
}
/** execution method of propagator */
static
SCIP_DECL_PROPEXEC(propExecDualfix)
{ /*lint --e{715}*/
int nfixedvars;
SCIP_Bool cutoff;
SCIP_Bool unbounded;
assert(prop != NULL);
assert(strcmp(SCIPpropGetName(prop), PROP_NAME) == 0);
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
/** @warning Don't run in probing or in repropagation since this can lead to wrong conclusion
*
* do not run if propagation w.r.t. current objective is not allowed
*/
if( SCIPinProbing(scip) || SCIPinRepropagation(scip) || !SCIPallowDualReds(scip) )
return SCIP_OKAY;
cutoff = FALSE;
unbounded = FALSE;
nfixedvars = 0;
SCIP_CALL( performDualfix(scip, &nfixedvars, &unbounded, &cutoff) );
/* evaluate propagation result */
if( cutoff )
*result = SCIP_CUTOFF;
else if( unbounded )
*result = SCIP_UNBOUNDED;
else if( nfixedvars > 0 )
*result = SCIP_REDUCEDDOM;
else
*result = SCIP_DIDNOTFIND;
return SCIP_OKAY;
}
/** execution method of presolver */
static
SCIP_DECL_PRESOLEXEC(presolExecDualagg)
{ /*lint --e{715}*/
SCIPMILPMATRIX* matrix;
SCIP_Bool initialized;
SCIP_Bool complete;
assert(result != NULL);
*result = SCIP_DIDNOTRUN;
if( (SCIPgetStage(scip) != SCIP_STAGE_PRESOLVING) || SCIPinProbing(scip) || SCIPisNLPEnabled(scip) )
return SCIP_OKAY;
if( SCIPisStopped(scip) || SCIPgetNActivePricers(scip) > 0 )
return SCIP_OKAY;
if( SCIPgetNBinVars(scip) == 0 )
return SCIP_OKAY;
if( !SCIPallowDualReds(scip) )
return SCIP_OKAY;
*result = SCIP_DIDNOTFIND;
matrix = NULL;
SCIP_CALL( SCIPmatrixCreate(scip, &matrix, &initialized, &complete) );
/* we only work on pure MIPs currently */
if( initialized && complete )
{
AGGRTYPE* aggtypes;
SCIP_VAR** binvars;
int nvaragg;
int ncols;
ncols = SCIPmatrixGetNColumns(matrix);
nvaragg = 0;
SCIP_CALL( SCIPallocBufferArray(scip, &aggtypes, ncols) );
BMSclearMemoryArray(aggtypes, ncols);
SCIP_CALL( SCIPallocBufferArray(scip, &binvars, ncols) );
SCIPdebug( BMSclearMemoryArray(binvars, ncols) );
/* search for aggregations */
SCIP_CALL( findUplockAggregations(scip, matrix, &nvaragg, aggtypes, binvars) );
SCIP_CALL( findDownlockAggregations(scip, matrix, &nvaragg, aggtypes, binvars) );
/* apply aggregations, if we found any */
if( nvaragg > 0 )
{
int v;
for( v = 0; v < ncols; v++ )
{
if( aggtypes[v] != NOAGG )
{
SCIP_Bool infeasible;
SCIP_Bool redundant;
SCIP_Bool aggregated;
SCIP_Real ub;
SCIP_Real lb;
ub = SCIPmatrixGetColUb(matrix, v);
lb = SCIPmatrixGetColLb(matrix, v);
/* aggregate variable */
assert(binvars[v] != NULL);
if( aggtypes[v] == BIN0UBOUND )
{
SCIP_CALL( SCIPaggregateVars(scip, SCIPmatrixGetVar(matrix, v), binvars[v], 1.0, ub-lb,
ub, &infeasible, &redundant, &aggregated) );
}
else
{
assert(aggtypes[v] == BIN0LBOUND);
SCIP_CALL( SCIPaggregateVars(scip, SCIPmatrixGetVar(matrix, v), binvars[v], 1.0, lb-ub,
lb, &infeasible, &redundant, &aggregated) );
}
/* infeasible aggregation */
if( infeasible )
{
SCIPdebugMessage(" -> infeasible aggregation\n");
*result = SCIP_CUTOFF;
return SCIP_OKAY;
}
if( aggregated )
(*naggrvars)++;
}
}
/* set result pointer */
if( (*naggrvars) > 0 )
*result = SCIP_SUCCESS;
}
SCIPfreeBufferArray(scip, &binvars);
SCIPfreeBufferArray(scip, &aggtypes);
}
SCIPmatrixFree(scip, &matrix);
return SCIP_OKAY;
}