/** creates variable */
SCIP_RETCODE SCIPcreateVarBinpacking(
SCIP* scip, /**< SCIP data structure */
SCIP_VAR** var, /**< pointer to variable object */
const char* name, /**< name of variable, or NULL for automatic name creation */
SCIP_Real obj, /**< objective function value */
SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
SCIP_VARDATA* vardata /**< user data for this specific variable */
)
{
assert(scip != NULL);
assert(var != NULL);
/* create a basic variable object */
SCIP_CALL( SCIPcreateVarBasic(scip, var, name, 0.0, 1.0, obj, SCIP_VARTYPE_BINARY) );
assert(*var != NULL);
/* set callback functions */
SCIPvarSetData(*var, vardata);
SCIPvarSetDeltransData(*var, vardataDelTrans);
/* set initial and removable flag */
SCIP_CALL( SCIPvarSetInitial(*var, initial) );
SCIP_CALL( SCIPvarSetRemovable(*var, removable) );
SCIPvarMarkDeletable(*var);
SCIPdebug( SCIPprintVar(scip, *var, NULL) );
return SCIP_OKAY;
}
SCIP_VAR* scip_dvar(SCIP* scip, SCIP_VAR* a, SCIP_VAR* b)
{
assert(a != b);
static unsigned int n = 0;
SCIP_CONS* cons;
SCIP_VAR* rval;
char cons_id[64], rval_id[64];
SCIP_VAR* vars[3] = {b, a, NULL};
SCIP_Real coefs[3] = {1, -1, 1};
SCIP_Real oo = SCIPinfinity(scip);
sprintf(rval_id, "dvar%d", n);
sprintf(cons_id, "deq%d", n++);
sa(SCIPcreateVarBasic(scip, &rval, rval_id, -oo, oo, 0,
SCIP_VARTYPE_INTEGER));
sa(SCIPaddVar(scip, rval));
vars[2] = rval;
sa(SCIPcreateConsLinear
(scip, &cons, cons_id, 3, vars, coefs, 0, 0,
TRUE, TRUE, TRUE, TRUE, TRUE,
FALSE, FALSE, FALSE, FALSE, FALSE));
sa(SCIPaddCons(scip, cons));
return rval;
}
/** method for either Farkas or Redcost pricing */
static
SCIP_RETCODE pricing(
SCIP* scip, /**< SCIP data structure */
SCIP_PRICER* pricer, /**< pricer */
SCIP_Real* lowerbound, /**< lowerbound pointer */
SCIP_Bool farkas /**< TRUE: Farkas pricing; FALSE: Redcost pricing */
)
{
SCIP_PRICERDATA* pricerdata; /* the data of the pricer */
SCIP_PROBDATA* probdata;
GRAPH* graph;
SCIP_VAR* var;
PATH* path;
SCIP_Real* edgecosts; /* edgecosts of the current subproblem */
char varname[SCIP_MAXSTRLEN];
SCIP_Real newlowerbound = -SCIPinfinity(scip);
SCIP_Real redcost; /* reduced cost */
int tail;
int e;
int t;
int i;
assert(scip != NULL);
assert(pricer != NULL);
/* get pricer data */
pricerdata = SCIPpricerGetData(pricer);
assert(pricerdata != NULL);
/* get problem data */
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
SCIPdebugMessage("solstat=%d\n", SCIPgetLPSolstat(scip));
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
newlowerbound = SCIPgetSolTransObj(scip, NULL);
SCIPdebug( SCIP_CALL( SCIPprintSol(scip, NULL, NULL, FALSE) ) );
# if 0
if ( pricerdata->lowerbound <= 4 )
{
char label[SCIP_MAXSTRLEN];
(void)SCIPsnprintf(label, SCIP_MAXSTRLEN, "X%g.gml", pricerdata->lowerbound);
SCIP_CALL( SCIPprobdataPrintGraph(scip, label , NULL, TRUE) );
pricerdata->lowerbound++;
}
#endif
/* get the graph*/
graph = SCIPprobdataGetGraph(probdata);
/* get dual solutions and save them in mi and pi */
for( t = 0; t < pricerdata->realnterms; ++t )
{
if( farkas )
{
pricerdata->mi[t] = SCIPgetDualfarkasLinear(scip, pricerdata->pathcons[t]);
}
else
{
pricerdata->mi[t] = SCIPgetDualsolLinear(scip, pricerdata->pathcons[t]);
assert(!SCIPisNegative(scip, pricerdata->mi[t]));
}
}
for( e = 0; e < pricerdata->nedges; ++e )
{
if( !pricerdata->bigt )
{
for( t = 0; t < pricerdata->realnterms; ++t )
{
if( farkas )
{
pricerdata->pi[t * pricerdata->nedges + e] = SCIPgetDualfarkasLinear(
scip, pricerdata->edgecons[t * pricerdata->nedges + e]);
}
else
{
pricerdata->pi[t * pricerdata->nedges + e] = SCIPgetDualsolLinear(
scip, pricerdata->edgecons[t * pricerdata->nedges + e]);
}
}
}
else
{
if( farkas )
{
pricerdata->pi[e] = SCIPgetDualfarkasLinear(
scip, pricerdata->edgecons[e]);
}
else
{
pricerdata->pi[e] = SCIPgetDualsolLinear(
scip, pricerdata->edgecons[e]);
}
}
}
SCIP_CALL( SCIPallocMemoryArray(scip, &path, graph->knots) );
SCIP_CALL( SCIPallocMemoryArray(scip, &edgecosts, pricerdata->nedges) );
if( pricerdata->bigt )
{
for( e = 0; e < pricerdata->nedges; ++e )
{
edgecosts[e] = (-pricerdata->pi[e]);
}
}
/* find shortest r-t (r root, t terminal) paths and create corresponding variables iff reduced cost < 0 */
for( t = 0; t < pricerdata->realnterms; ++t )
{
for( e = 0; e < pricerdata->nedges; ++e )
{
if( !pricerdata->bigt )
{
edgecosts[e] = (-pricerdata->pi[t * pricerdata->nedges + e]);
}
assert(!SCIPisNegative(scip, edgecosts[e]));
}
for( i = 0; i < graph->knots; i++ )
graph->mark[i] = 1;
graph_path_exec(scip, graph, FSP_MODE, pricerdata->root, edgecosts, path);
/* compute reduced cost of shortest path to terminal t */
redcost = 0.0;
tail = pricerdata->realterms[t];
while( tail != pricerdata->root )
{
redcost += edgecosts[path[tail].edge];
tail = graph->tail[path[tail].edge];
}
redcost -= pricerdata->mi[t];
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
{
newlowerbound += redcost;
}
/* check if reduced cost < 0 */
if( SCIPisNegative(scip, redcost) )
{
/* create variable to the shortest path (having reduced cost < 0) */
var = NULL;
sprintf(varname, "PathVar%d_%d", t, pricerdata->ncreatedvars[t]);
++(pricerdata->ncreatedvars[t]);
SCIP_CALL( SCIPcreateVarBasic(scip, &var, varname, 0.0, SCIPinfinity(scip), 0.0, SCIP_VARTYPE_CONTINUOUS) );
SCIP_CALL( SCIPaddPricedVar(scip, var, -redcost) );
tail = pricerdata->realterms[t];
while( tail != pricerdata->root )
{
/* add variable to constraints */
if( !pricerdata->bigt )
{
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->edgecons[t * pricerdata->nedges + path[tail].edge], var, 1.0) );
}
else
{
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->edgecons[path[tail].edge], var, 1.0) );
}
tail = graph->tail[path[tail].edge];
}
SCIP_CALL( SCIPaddCoefLinear(scip, pricerdata->pathcons[t], var, 1.0) );
}
}
if( !farkas && SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
*lowerbound = newlowerbound;
SCIPfreeMemoryArray(scip, &edgecosts);
SCIPfreeMemoryArray(scip, &path);
return SCIP_OKAY;
}
/** initializes the pricing problem for the given capacity */
static
SCIP_RETCODE initPricing(
SCIP* scip, /**< SCIP data structure */
SCIP_PRICERDATA* pricerdata, /**< pricer data */
SCIP* subscip, /**< pricing SCIP data structure */
SCIP_VAR** vars /**< variable array for the items */
)
{
SCIP_CONS** conss;
SCIP_Longint* vals;
SCIP_CONS* cons;
SCIP_VAR* var;
SCIP_Longint* weights;
SCIP_Longint capacity;
SCIP_Real dual;
int nitems;
int nvars;
int c;
assert( SCIPgetStage(subscip) == SCIP_STAGE_PROBLEM );
assert(pricerdata != NULL);
nitems = pricerdata->nitems;
conss = pricerdata->conss;
weights = pricerdata->weights;
capacity = pricerdata->capacity;
nvars = 0;
SCIP_CALL( SCIPallocBufferArray(subscip, &vals, nitems) );
/* create for each order, which is not assigned yet, a variable with objective coefficient */
for( c = 0; c < nitems; ++c )
{
cons = conss[c];
/* check if each constraint is setppc constraint */
assert( !strncmp( SCIPconshdlrGetName( SCIPconsGetHdlr(cons) ), "setppc", 6) );
/* constraints which are (locally) disabled/redundant are not of
* interest since the corresponding job is assigned to a packing
*/
if( !SCIPconsIsEnabled(cons) )
continue;
if( SCIPgetNFixedonesSetppc(scip, cons) == 1 )
{
/* disable constraint locally */
SCIP_CALL( SCIPdelConsLocal(scip, cons) );
continue;
}
/* dual value in original SCIP */
dual = SCIPgetDualsolSetppc(scip, cons);
SCIP_CALL( SCIPcreateVarBasic(subscip, &var, SCIPconsGetName(cons), 0.0, 1.0, dual, SCIP_VARTYPE_BINARY) );
SCIP_CALL( SCIPaddVar(subscip, var) );
vals[nvars] = weights[c];
vars[nvars] = var;
nvars++;
/* release variable */
SCIP_CALL( SCIPreleaseVar(subscip, &var) );
}
/* create capacity constraint */
SCIP_CALL( SCIPcreateConsBasicKnapsack(subscip, &cons, "capacity", nvars, vars, vals,
capacity) );
SCIP_CALL( SCIPaddCons(subscip, cons) );
SCIP_CALL( SCIPreleaseCons(subscip, &cons) );
/* add constraint of the branching decisions */
SCIP_CALL( addBranchingDecisionConss(scip, subscip, vars, pricerdata->conshdlr) );
/* avoid to generate columns which are fixed to zero */
SCIP_CALL( addFixedVarsConss(scip, subscip, vars, conss, nitems) );
SCIPfreeBufferArray(subscip, &vals);
return SCIP_OKAY;
}
