/** solving process initialization method of constraint handler (called when branch and bound process is about to begin) */
static
SCIP_DECL_CONSINITSOL(consInitsolOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrData;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
conshdlrData = SCIPconshdlrGetData(conshdlr);
assert(conshdlrData != NULL);
/* prepare stack */
SCIP_CALL( SCIPallocMemoryArray(scip, &conshdlrData->stack, conshdlrData->maxstacksize) );
assert( conshdlrData->nstack >= 0 );
/* check consistency */
if( conshdlrData->rootcons != NULL )
{
SCIP_CALL( SCIPreleaseCons(scip, &conshdlrData->rootcons) );
conshdlrData->rootcons = NULL;
--(conshdlrData->nstack);
}
GCGconsOrigbranchCheckConsistency(scip);
return SCIP_OKAY;
}
/** constraint deactivation notification method of constraint handler */
static
SCIP_DECL_CONSDEACTIVE(consDeactiveSamediff)
{ /*lint --e{715}*/
SCIP_CONSDATA* consdata;
SCIP_PROBDATA* probdata;
assert(scip != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(cons != NULL);
consdata = SCIPconsGetData(cons);
assert(consdata != NULL);
assert(consdata->propagated || SCIPgetNChildren(scip) == 0);
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
/* check if all variables which are not fixed locally to zero are valid for this constraint/node */
assert( consdataCheck(scip, probdata, consdata) );
SCIPdebugMessage("deactivate constraint <%s> at node <%"SCIP_LONGINT_FORMAT"> in depth <%d>: ",
SCIPconsGetName(cons), SCIPnodeGetNumber(consdata->node), SCIPnodeGetDepth(consdata->node));
SCIPdebug( consdataPrint(scip, consdata, NULL) );
/* set the number of propagated variables to current number of variables is SCIP */
consdata->npropagatedvars = SCIPprobdataGetNVars(probdata);
/* check if all variables are valid for this constraint */
assert( consdataCheck(scip, probdata, consdata) );
return SCIP_OKAY;
}
/** adds constraint to the disjunction of constraints */
SCIP_RETCODE SCIPaddConsElemDisjunction(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS* cons, /**< disjunction constraint */
SCIP_CONS* addcons /**< additional constraint in disjunction */
)
{
SCIP_CONSDATA* consdata;
assert(cons != NULL);
assert(addcons != NULL);
if( strcmp(SCIPconshdlrGetName(SCIPconsGetHdlr(cons)), CONSHDLR_NAME) != 0 )
{
SCIPerrorMessage("constraint is not a disjunction constraint\n");
return SCIP_INVALIDDATA;
}
consdata = SCIPconsGetData(cons);
assert(consdata != NULL);
SCIP_CALL( consdataAddCons(scip, consdata, addcons) );
return SCIP_OKAY;
}
/** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) */
static
SCIP_DECL_CONSFREE(consFreeOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrData;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
conshdlrData = SCIPconshdlrGetData(conshdlr);
assert(conshdlrData != NULL);
SCIPdebugMessage("freeing branch orig constraint handler\n");
/* free constraint handler storage */
assert(conshdlrData->stack == NULL);
if( conshdlrData->rootcons != NULL )
{
SCIP_CALL( SCIPreleaseCons(scip, &conshdlrData->rootcons) );
}
SCIPfreeMemory(scip, &conshdlrData);
return SCIP_OKAY;
}
/** constraint activation notification method of constraint handler */
static
SCIP_DECL_CONSACTIVE(consActiveSamediff)
{ /*lint --e{715}*/
SCIP_CONSDATA* consdata;
assert(scip != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(cons != NULL);
consdata = SCIPconsGetData(cons);
assert(consdata != NULL);
assert(consdata->npropagatedvars <= SCIPprobdataGetNVars(SCIPgetProbData(scip)));
SCIPdebugMessage("activate constraint <%s> at node <%"SCIP_LONGINT_FORMAT"> in depth <%d>: ",
SCIPconsGetName(cons), SCIPnodeGetNumber(consdata->node), SCIPnodeGetDepth(consdata->node));
SCIPdebug( consdataPrint(scip, consdata, NULL) );
if( consdata->npropagatedvars != SCIPprobdataGetNVars(SCIPgetProbData(scip)) )
{
SCIPdebugMessage("-> mark constraint to be repropagated\n");
consdata->propagated = FALSE;
SCIP_CALL( SCIPrepropagateNode(scip, consdata->node) );
}
return SCIP_OKAY;
}
/** transforms constraint data into data belonging to the transformed problem */
static
SCIP_DECL_CONSTRANS(consTransSamediff)
{ /*lint --e{715}*/
SCIP_CONSDATA* sourcedata;
SCIP_CONSDATA* targetdata;
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(SCIPgetStage(scip) == SCIP_STAGE_TRANSFORMING);
assert(sourcecons != NULL);
assert(targetcons != NULL);
sourcedata = SCIPconsGetData(sourcecons);
assert(sourcedata != NULL);
/* create constraint data for target constraint */
SCIP_CALL( consdataCreate(scip, &targetdata,
sourcedata->itemid1, sourcedata->itemid2, sourcedata->type, sourcedata->node) );
/* create target constraint */
SCIP_CALL( SCIPcreateCons(scip, targetcons, SCIPconsGetName(sourcecons), conshdlr, targetdata,
SCIPconsIsInitial(sourcecons), SCIPconsIsSeparated(sourcecons), SCIPconsIsEnforced(sourcecons),
SCIPconsIsChecked(sourcecons), SCIPconsIsPropagated(sourcecons),
SCIPconsIsLocal(sourcecons), SCIPconsIsModifiable(sourcecons),
SCIPconsIsDynamic(sourcecons), SCIPconsIsRemovable(sourcecons), SCIPconsIsStickingAtNode(sourcecons)) );
return SCIP_OKAY;
}
/** constraint deactivation notification method of constraint handler */
static
SCIP_DECL_CONSDEACTIVE(consDeactiveOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrData;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(cons != NULL);
conshdlrData = SCIPconshdlrGetData(conshdlr);
assert(conshdlrData != NULL);
assert(conshdlrData->stack != NULL || conshdlrData->nstack <= 1);
assert(conshdlrData->nstack <= 1 || cons == conshdlrData->stack[conshdlrData->nstack-1]);
assert(SCIPconsGetData(cons) != NULL);
SCIPdebugMessage("Deactivating branch orig constraint: <%s> [stack size: %d].\n",
SCIPconsGetName(cons), conshdlrData->nstack-1);
/* remove constraint from the stack */
if( conshdlrData->nstack > 0 )
--(conshdlrData->nstack);
return SCIP_OKAY;
}
/** frees specific constraint data */
static
SCIP_DECL_CONSDELETE(consDeleteStp)
{ /*lint --e{715}*/
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(consdata != NULL);
assert(*consdata != NULL);
SCIPfreeBlockMemory(scip, consdata);
return SCIP_OKAY;
}
/** frees specific constraint data */
static
SCIP_DECL_CONSDELETE(consDeleteSamediff)
{ /*lint --e{715}*/
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(consdata != NULL);
assert(*consdata != NULL);
/* free LP row and logic or constraint */
SCIP_CALL( consdataFree(scip, consdata) );
return SCIP_OKAY;
}
/** copy method for constraint handler plugins (called when SCIP copies plugins) */
static
SCIP_DECL_CONSHDLRCOPY(conshdlrCopyStp)
{ /*lint --e{715}*/
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
/* call inclusion method of constraint handler */
SCIP_CALL( SCIPincludeConshdlrStp(scip) );
*valid = TRUE;
return SCIP_OKAY;
}
/** destructor of constraint handler to free constraint handler data (called when SCIP is exiting) */
static
SCIP_DECL_CONSFREE(consFreeStp)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrdata;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
/* free constraint handler data */
conshdlrdata = SCIPconshdlrGetData(conshdlr);
assert(conshdlrdata != NULL);
SCIPfreeMemory(scip, &conshdlrdata);
SCIPconshdlrSetData(conshdlr, NULL);
return SCIP_OKAY;
}
/** solving process deinitialization method of constraint handler (called before branch and bound process data is freed) */
static
SCIP_DECL_CONSEXITSOL(consExitsolOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrData;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
conshdlrData = SCIPconshdlrGetData(conshdlr);
assert(conshdlrData != NULL);
assert(conshdlrData->nstack <= 1);
SCIPdebugMessage("exiting solution process branch orig constraint handler\n");
/* free stack */
SCIPfreeMemoryArray(scip, &conshdlrData->stack);
conshdlrData->stack = NULL;
return SCIP_OKAY;
}
/** constraint activation notification method of constraint handler */
static
SCIP_DECL_CONSACTIVE(consActiveOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSHDLRDATA* conshdlrData;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(cons != NULL);
conshdlrData = SCIPconshdlrGetData(conshdlr);
assert(conshdlrData != NULL);
assert(conshdlrData->stack != NULL);
assert(SCIPconsGetData(cons) != NULL);
if( SCIPconsGetData(cons)->node == NULL )
SCIPconsGetData(cons)->node = SCIPgetRootNode(scip);
SCIPdebugMessage("Activating branch orig constraint: <%s>[stack size: %d].\n", SCIPconsGetName(cons),
conshdlrData->nstack+1);
/* put constraint on the stack */
if( conshdlrData->nstack >= conshdlrData->maxstacksize )
{
SCIP_CALL( SCIPreallocMemoryArray(scip, &(conshdlrData->stack), 2*(conshdlrData->maxstacksize)) );
conshdlrData->maxstacksize = 2*(conshdlrData->maxstacksize);
SCIPdebugMessage("reallocating Memory for stack! %d --> %d\n", conshdlrData->maxstacksize/2, conshdlrData->maxstacksize);
}
/* put constraint on the stack */
assert(conshdlrData->stack != NULL);
conshdlrData->stack[conshdlrData->nstack] = cons;
++(conshdlrData->nstack);
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;
}
/** domain propagation method of constraint handler */
static
SCIP_DECL_CONSPROP(consPropSamediff)
{ /*lint --e{715}*/
SCIP_PROBDATA* probdata;
SCIP_CONSDATA* consdata;
SCIP_VAR** vars;
int nvars;
int c;
assert(scip != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
SCIPdebugMessage("propagation constraints of constraint handler <"CONSHDLR_NAME">\n");
probdata = SCIPgetProbData(scip);
assert(probdata != NULL);
vars = SCIPprobdataGetVars(probdata);
nvars = SCIPprobdataGetNVars(probdata);
*result = SCIP_DIDNOTFIND;
for( c = 0; c < nconss; ++c )
{
consdata = SCIPconsGetData(conss[c]);
#ifndef NDEBUG
{
/* check if there are no equal consdatas */
SCIP_CONSDATA* consdata2;
int i;
for( i = c+1; i < nconss; ++i )
{
consdata2 = SCIPconsGetData(conss[i]);
assert( !(consdata->itemid1 == consdata2->itemid1
&& consdata->itemid2 == consdata2->itemid2
&& consdata->type == consdata2->type) );
assert( !(consdata->itemid1 == consdata2->itemid2
&& consdata->itemid2 == consdata2->itemid1
&& consdata->type == consdata2->type) );
}
}
#endif
if( !consdata->propagated )
{
SCIPdebugMessage("propagate constraint <%s> ", SCIPconsGetName(conss[c]));
SCIPdebug( consdataPrint(scip, consdata, NULL) );
SCIP_CALL( consdataFixVariables(scip, consdata, vars, nvars, result) );
consdata->npropagations++;
if( *result != SCIP_CUTOFF )
{
consdata->propagated = TRUE;
consdata->npropagatedvars = nvars;
}
else
break;
}
/* check if constraint is completely propagated */
assert( consdataCheck(scip, probdata, consdata) );
}
return SCIP_OKAY;
}
/** writes problem data to file with given reader or returns SCIP_DIDNOTRUN */
SCIP_RETCODE SCIPreaderWrite(
SCIP_READER* reader, /**< reader */
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
FILE* file, /**< output file (or NULL for standard output) */
const char* extension, /**< file format */
SCIP_Bool genericnames, /**< using generic variable and constraint names? */
SCIP_RESULT* result /**< pointer to store the result of the callback method */
)
{
SCIP_RETCODE retcode;
assert(reader != NULL);
assert(set != NULL);
assert(extension != NULL);
assert(result != NULL);
/* check, if reader is applicable on the given file */
if( readerIsApplicable(reader, extension) && reader->readerwrite != NULL )
{
SCIP_VAR** vars;
int nvars;
SCIP_VAR** fixedvars;
int nfixedvars;
SCIP_CONS** conss;
int nconss;
int i;
SCIP_CONS* cons;
char* name;
const char* consname;
const char** varnames;
const char** fixedvarnames;
const char** consnames;
varnames = NULL;
fixedvarnames = NULL;
consnames = NULL;
vars = prob->vars;
nvars = prob->nvars;
fixedvars = prob->fixedvars;
nfixedvars = prob->nfixedvars;
/* case of the transformed problem, we want to write currently valid problem */
if( prob->transformed )
{
SCIP_CONSHDLR** conshdlrs;
int nconshdlrs;
conshdlrs = set->conshdlrs;
nconshdlrs = set->nconshdlrs;
/* collect number of constraints which have to be enforced; these are the constraints which currency (locally)
* enabled; these also includes the local constraints
*/
nconss = 0;
for( i = 0; i < nconshdlrs; ++i )
{
/* check if all constraints of the constraint handler should be written */
if( set->write_allconss )
nconss += SCIPconshdlrGetNConss(conshdlrs[i]);
else
nconss += SCIPconshdlrGetNEnfoConss(conshdlrs[i]);
}
SCIPdebugMessage("Writing %d constraints.\n", nconss);
SCIP_ALLOC( BMSallocMemoryArray(&conss, nconss) );
/* copy the constraints */
nconss = 0;
for( i = 0; i < nconshdlrs; ++i )
{
SCIP_CONS** conshdlrconss;
int nconshdlrconss;
int c;
/* check if all constraints of the constraint handler should be written */
if( set->write_allconss )
{
conshdlrconss = SCIPconshdlrGetConss(conshdlrs[i]);
nconshdlrconss = SCIPconshdlrGetNConss(conshdlrs[i]);
}
else
{
conshdlrconss = SCIPconshdlrGetEnfoConss(conshdlrs[i]);
nconshdlrconss = SCIPconshdlrGetNEnfoConss(conshdlrs[i]);
}
SCIPdebugMessage("Conshdlr <%s> has %d constraints to write from all in all %d constraints.\n", SCIPconshdlrGetName(conshdlrs[i]), nconshdlrconss, SCIPconshdlrGetNConss(conshdlrs[i]));
for( c = 0; c < nconshdlrconss; ++c )
{
conss[nconss] = conshdlrconss[c];
nconss++;
}
}
}
else
{
conss = prob->conss;
nconss = prob->nconss;
}
if( genericnames )
{
SCIP_VAR* var;
int size;
/* save variable and constraint names and replace these names by generic names */
/* allocate memory for saving the original variable and constraint names */
SCIP_ALLOC( BMSallocMemoryArray(&varnames, nvars) );
SCIP_ALLOC( BMSallocMemoryArray(&fixedvarnames, nfixedvars) );
SCIP_ALLOC( BMSallocMemoryArray(&consnames, nconss) );
/* compute length of the generic variable names:
* - nvars + 1 to avoid log of zero
* - +3 (zero at end + 'x' + 1 because we round down)
* Example: 10 -> need 4 chars ("x10\0")
*/
size = (int) log10(nvars+1.0) + 3;
for( i = 0; i < nvars; ++i )
{
var = vars[i];
varnames[i] = SCIPvarGetName(var);
SCIP_ALLOC( BMSallocMemoryArray(&name, size) );
(void) SCIPsnprintf(name, size, "x%d", i + set->write_genoffset);
SCIPvarSetNamePointer(var, name);
}
/* compute length of the generic variable names */
size = (int) log10(nfixedvars+1.0) + 3;
for( i = 0; i < nfixedvars; ++i )
{
var = fixedvars[i];
fixedvarnames[i] = SCIPvarGetName(var);
SCIP_ALLOC( BMSallocMemoryArray(&name, size) );
(void) SCIPsnprintf(name, size, "y%d", i);
SCIPvarSetNamePointer(var, name);
}
/* compute length of the generic constraint names */
size = (int) log10(nconss+1.0) + 3;
for( i = 0; i < nconss; ++i )
{
cons = conss[i];
consnames[i] = SCIPconsGetName(cons);
SCIP_ALLOC( BMSallocMemoryArray(&name, size) );
(void) SCIPsnprintf(name, size, "c%d", i);
SCIPconsSetNamePointer(cons, name);
}
}
/* call reader to write problem */
retcode = reader->readerwrite(set->scip, reader, file, prob->name, prob->probdata, prob->transformed,
prob->transformed ? SCIP_OBJSENSE_MINIMIZE : prob->objsense, prob->objscale, prob->objoffset,
vars, nvars, prob->nbinvars, prob->nintvars, prob->nimplvars, prob->ncontvars,
fixedvars, nfixedvars, prob->startnvars,
conss, nconss, prob->maxnconss, prob->startnconss, genericnames, result);
/* reset variable and constraint names to original names */
if( genericnames )
{
assert(varnames != NULL);
assert(fixedvarnames != NULL);
assert(consnames != NULL);
for( i = 0; i < nvars; ++i )
resetVarname(vars[i], varnames[i]);
for( i = 0; i < nfixedvars; ++i )
resetVarname(fixedvars[i], fixedvarnames[i]);
for( i = 0; i < nconss; ++i )
{
cons = conss[i];
/* get pointer to temporary generic name and free the memory */
consname = SCIPconsGetName(cons);
BMSfreeMemory(&consname);
/* reset name */
SCIPconsSetNamePointer(cons, consnames[i]);
}
/* free memory */
BMSfreeMemoryArray(&varnames);
BMSfreeMemoryArray(&fixedvarnames);
BMSfreeMemoryArray(&consnames);
}
if( prob->transformed )
{
/* free memory */
BMSfreeMemoryArray(&conss);
}
}
else
{
*result = SCIP_DIDNOTRUN;
retcode = SCIP_OKAY;
}
/* check for reader errors */
if( retcode == SCIP_WRITEERROR )
return retcode;
SCIP_CALL( retcode );
return SCIP_OKAY;
}
/** writes problem to file */
SCIP_RETCODE SCIPwritePpm(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< output file, or NULL if standard output should be used */
const char* name, /**< problem name */
SCIP_READERDATA* readerdata, /**< information for reader */
SCIP_Bool transformed, /**< TRUE iff problem is the transformed problem */
SCIP_VAR** vars, /**< array with active variables ordered binary, integer, implicit, continuous */
int nvars, /**< number of active variables in the problem */
SCIP_CONS** conss, /**< array with constraints of the problem */
int nconss, /**< number of constraints in the problem */
SCIP_RESULT* result /**< pointer to store the result of the file writing call */
)
{ /*lint --e{715}*/
int c;
int v;
int i;
int linecnt;
char linebuffer[PPM_MAX_LINELEN];
SCIP_CONSHDLR* conshdlr;
const char* conshdlrname;
SCIP_CONS* cons;
SCIP_VAR** consvars;
SCIP_Real* consvals;
int nconsvars;
int i_max = 1;
SCIP_Real maxcoef = 0;
SCIP_Bool printbool = FALSE;
assert( scip != NULL );
assert(readerdata != NULL);
/* print statistics as comment to file */
if(readerdata->rgb_ascii)
SCIPinfoMessage(scip, file, "P6\n");
else
SCIPinfoMessage(scip, file, "P3\n");
SCIPinfoMessage(scip, file, "# %s\n", name);
SCIPinfoMessage(scip, file, "%d %d\n", nvars, nconss);
SCIPinfoMessage(scip, file, "255\n");
clearLine(linebuffer, &linecnt);
if(!(readerdata->rgb_relativ))
{
i_max = 2;
}
for(i = 0; i < i_max; ++i)
{
if(i)
{
printbool = TRUE;
SCIPdebugPrintf("Maximal coefficient = %g\n", maxcoef);
}
for(c = 0; c < nconss; ++c)
{
cons = conss[c];
assert( cons != NULL);
/* in case the transformed is written only constraint are posted which are enabled in the current node */
assert(!transformed || SCIPconsIsEnabled(cons));
conshdlr = SCIPconsGetHdlr(cons);
assert( conshdlr != NULL );
conshdlrname = SCIPconshdlrGetName(conshdlr);
assert( transformed == SCIPconsIsTransformed(cons) );
if( strcmp(conshdlrname, "linear") == 0 )
{
consvars = SCIPgetVarsLinear(scip, cons);
nconsvars = SCIPgetNVarsLinear(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( printLinearCons(scip, file, readerdata, consvars, SCIPgetValsLinear(scip, cons),
nconsvars, nvars, transformed, &maxcoef, printbool) );
}
}
else if( strcmp(conshdlrname, "setppc") == 0 )
{
consvars = SCIPgetVarsSetppc(scip, cons);
nconsvars = SCIPgetNVarsSetppc(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( printLinearCons(scip, file, readerdata, consvars, NULL,
nconsvars, nvars, transformed, &maxcoef, printbool) );
}
}
else if( strcmp(conshdlrname, "logicor") == 0 )
{
consvars = SCIPgetVarsLogicor(scip, cons);
nconsvars = SCIPgetNVarsLogicor(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( printLinearCons(scip, file, readerdata, consvars, NULL,
nconsvars, nvars, transformed, &maxcoef, printbool) );
}
}
else if( strcmp(conshdlrname, "knapsack") == 0 )
{
SCIP_Longint* weights;
consvars = SCIPgetVarsKnapsack(scip, cons);
nconsvars = SCIPgetNVarsKnapsack(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
/* copy Longint array to SCIP_Real array */
weights = SCIPgetWeightsKnapsack(scip, cons);
SCIP_CALL( SCIPallocBufferArray(scip, &consvals, nconsvars) );
for( v = 0; v < nconsvars; ++v )
consvals[v] = (SCIP_Real)weights[v];
if( nconsvars > 0 )
{
SCIP_CALL( printLinearCons(scip, file, readerdata, consvars, consvals, nconsvars, nvars, transformed, &maxcoef, printbool) );
}
SCIPfreeBufferArray(scip, &consvals);
}
else if( strcmp(conshdlrname, "varbound") == 0 )
{
SCIP_CALL( SCIPallocBufferArray(scip, &consvars, 2) );
SCIP_CALL( SCIPallocBufferArray(scip, &consvals, 2) );
consvars[0] = SCIPgetVarVarbound(scip, cons);
consvars[1] = SCIPgetVbdvarVarbound(scip, cons);
consvals[0] = 1.0;
consvals[1] = SCIPgetVbdcoefVarbound(scip, cons);
SCIP_CALL( printLinearCons(scip, file, readerdata, consvars, consvals, 2, nvars, transformed, &maxcoef, printbool) );
SCIPfreeBufferArray(scip, &consvars);
SCIPfreeBufferArray(scip, &consvals);
}
else
{
SCIPwarningMessage(scip, "constraint handler <%s> cannot print requested format\n", conshdlrname );
SCIPinfoMessage(scip, file, "\\ ");
SCIP_CALL( SCIPprintCons(scip, cons, file) );
SCIPinfoMessage(scip, file, ";\n");
}
}
}
*result = SCIP_SUCCESS;
return SCIP_OKAY;
}
/** writes problem to file */
SCIP_RETCODE SCIPwriteCcg(
SCIP* scip, /**< SCIP data structure */
FILE* file, /**< output file, or NULL if standard output should be used */
const char* name, /**< problem name */
SCIP_Bool transformed, /**< TRUE iff problem is the transformed problem */
SCIP_VAR** vars, /**< array with active variables ordered binary, integer, implicit, continuous */
int nvars, /**< number of active variables in the problem */
SCIP_CONS** conss, /**< array with constraints of the problem */
int nconss, /**< number of constraints in the problem */
SCIP_RESULT* result /**< pointer to store the result of the file writing call */
)
{ /*lint --e{715}*/
int c;
int v;
int i;
SCIP_CONSHDLR* conshdlr;
const char* conshdlrname;
SCIP_CONS* cons;
SCIP_VAR** consvars;
SCIP_Real* consvals;
int nconsvars;
SparseGraph G;
assert( scip != NULL );
assert( nvars >= 0 );
/* initialize graph */
SCIP_CALL( initGraph(scip, &G, (unsigned int) nvars, 10) );
/* check all constraints */
for( c = 0; c < nconss; ++c)
{
cons = conss[c];
assert( cons != NULL);
/* in case the transformed is written only constraint are posted which are enabled in the current node */
assert(!transformed || SCIPconsIsEnabled(cons));
conshdlr = SCIPconsGetHdlr(cons);
assert( conshdlr != NULL );
conshdlrname = SCIPconshdlrGetName(conshdlr);
assert( transformed == SCIPconsIsTransformed(cons) );
if( strcmp(conshdlrname, "linear") == 0 )
{
consvars = SCIPgetVarsLinear(scip, cons);
nconsvars = SCIPgetNVarsLinear(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( handleLinearCons(scip, SCIPgetVarsLinear(scip, cons), SCIPgetValsLinear(scip, cons),
SCIPgetNVarsLinear(scip, cons), transformed, &G) );
}
}
else if( strcmp(conshdlrname, "setppc") == 0 )
{
consvars = SCIPgetVarsSetppc(scip, cons);
nconsvars = SCIPgetNVarsSetppc(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( handleLinearCons(scip, consvars, NULL, nconsvars, transformed, &G) );
}
}
else if( strcmp(conshdlrname, "logicor") == 0 )
{
consvars = SCIPgetVarsLogicor(scip, cons);
nconsvars = SCIPgetNVarsLogicor(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
if( nconsvars > 0 )
{
SCIP_CALL( handleLinearCons(scip, SCIPgetVarsLogicor(scip, cons), NULL, SCIPgetNVarsLogicor(scip, cons), transformed, &G) );
}
}
else if( strcmp(conshdlrname, "knapsack") == 0 )
{
SCIP_Longint* w;
consvars = SCIPgetVarsKnapsack(scip, cons);
nconsvars = SCIPgetNVarsKnapsack(scip, cons);
assert( consvars != NULL || nconsvars == 0 );
/* copy Longint array to SCIP_Real array */
w = SCIPgetWeightsKnapsack(scip, cons);
SCIP_CALL( SCIPallocBufferArray(scip, &consvals, nconsvars) );
for( v = 0; v < nconsvars; ++v )
consvals[v] = (SCIP_Real)w[v];
if( nconsvars > 0 )
{
SCIP_CALL( handleLinearCons(scip, consvars, consvals, nconsvars, transformed, &G) );
}
SCIPfreeBufferArray(scip, &consvals);
}
else if( strcmp(conshdlrname, "varbound") == 0 )
{
SCIP_CALL( SCIPallocBufferArray(scip, &consvars, 2) );
SCIP_CALL( SCIPallocBufferArray(scip, &consvals, 2) );
consvars[0] = SCIPgetVarVarbound(scip, cons);
consvars[1] = SCIPgetVbdvarVarbound(scip, cons);
consvals[0] = 1.0;
consvals[1] = SCIPgetVbdcoefVarbound(scip, cons);
SCIP_CALL( handleLinearCons(scip, consvars, consvals, 2, transformed, &G) );
SCIPfreeBufferArray(scip, &consvars);
SCIPfreeBufferArray(scip, &consvals);
}
else
{
SCIPwarningMessage(scip, "constraint handler <%s> cannot print requested format\n", conshdlrname );
SCIPinfoMessage(scip, file, "\\ ");
SCIP_CALL( SCIPprintCons(scip, cons, file) );
SCIPinfoMessage(scip, file, ";\n");
}
}
/* output graph */
SCIPinfoMessage(scip, file, "c graph generated from %s\n", name);
SCIPinfoMessage(scip, file, "p edge %d %d\n", nvars, G.m);
for( i = 0; i < nvars; ++i )
{
unsigned int k;
int a;
k = 0;
a = G.A[i][k];
while( a >= 0 )
{
/* only output edges from lower to higher number */
if( i < a )
{
/* note: node numbers start with 1 in the DIMACS format */
SCIPinfoMessage(scip, file, "e %d %d %f\n", i+1, a+1, G.W[i][k]);
}
a = G.A[i][++k];
assert( k <= G.size[i] );
}
assert( k == G.deg[i] );
}
freeGraph(scip, &G);
*result = SCIP_SUCCESS;
return SCIP_OKAY;
}
/** frees specific constraint data */
static
SCIP_DECL_CONSDELETE(consDeleteOrigbranch)
{ /*lint --e{715}*/
SCIP_CONSDATA* parentdata;
assert(scip != NULL);
assert(conshdlr != NULL);
assert(cons != NULL);
assert(consdata != NULL);
assert(strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0);
assert(*consdata != NULL);
SCIPdebugMessage("Deleting branch orig constraint: <%s>.\n", SCIPconsGetName(cons));
/* set the origcons pointer of the corresponding mastercons to NULL */
if( (*consdata)->mastercons != NULL )
GCGconsMasterbranchSetOrigcons((*consdata)->mastercons, NULL);
/* set the pointer in the parent constraint to NULL */
if( (*consdata)->parentcons != NULL )
{
parentdata = SCIPconsGetData((*consdata)->parentcons);
if( parentdata->child1cons == cons )
parentdata->child1cons = NULL;
else if( parentdata->probingtmpcons == cons )
{
assert(SCIPinProbing(scip));
parentdata->probingtmpcons = NULL;
}
else
{
assert(parentdata->child2cons == cons);
parentdata->child2cons = NULL;
if( SCIPinProbing(scip) )
{
parentdata->child2cons = parentdata->probingtmpcons;
parentdata->probingtmpcons = NULL;
}
}
}
/* no child nodes may exist */
assert((*consdata)->child1cons == NULL);
assert((*consdata)->child2cons == NULL);
/* delete branchdata, if no mastercons is linked, which would still need the branchdata
* otherwise, the mastercons deletes the branchdata when it is deleted itself */
if( (*consdata)->mastercons == NULL && (*consdata)->branchdata != NULL )
{
SCIP_CALL( GCGrelaxBranchDataDelete(scip, (*consdata)->branchrule, &(*consdata)->branchdata) );
}
/* free propagation domain changes arrays */
if( (*consdata)->maxpropbounds > 0 )
{
SCIPfreeMemoryArray(scip, &((*consdata)->propvars));
SCIPfreeMemoryArray(scip, &((*consdata)->propboundtypes));
SCIPfreeMemoryArray(scip, &((*consdata)->propbounds));
}
/* free constraint data */
SCIPfreeBlockMemory(scip, consdata);
return SCIP_OKAY;
}
