/** 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;
}
/** creates and captures a samediff constraint */
SCIP_RETCODE SCIPcreateConsSamediff(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** cons, /**< pointer to hold the created constraint */
const char* name, /**< name of constraint */
int itemid1, /**< item id one */
int itemid2, /**< item id two */
CONSTYPE type, /**< stores whether the items have to be in the SAME or DIFFER packing */
SCIP_NODE* node, /**< the node in the B&B-tree at which the cons is sticking */
SCIP_Bool local /**< is constraint only valid locally? */
)
{
SCIP_CONSHDLR* conshdlr;
SCIP_CONSDATA* consdata;
/* find the samediff constraint handler */
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("samediff constraint handler not found\n");
return SCIP_PLUGINNOTFOUND;
}
/* create the constraint specific data */
SCIP_CALL( consdataCreate(scip, &consdata, itemid1, itemid2, type, node) );
/* create constraint */
SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, FALSE, FALSE, FALSE, FALSE, TRUE,
local, FALSE, FALSE, FALSE, TRUE) );
SCIPdebugMessage("created constraint: ");
SCIPdebug( consdataPrint(scip, consdata, NULL) );
return SCIP_OKAY;
}
/** creates and captures a Benders constraint */
SCIP_RETCODE SCIPcreateConsBenders(
SCIP * scip,
SCIP_CONS ** cons,
const char * name)
{
SCIP_CONSHDLR * conshdlr = NULL;
SCIP_CONSDATA * consdata = NULL;
/* find the Benders constraint handler */
conshdlr = SCIPfindConshdlr(scip, name);
assert(conshdlr);
/* create constraint data */
//SCIP_CALL(SCIPallocMemory(scip_, &consdata));
/* create constraint */
SCIP_CALL(SCIPcreateCons(scip, cons, name, conshdlr, consdata,
false, /**< being in the initial LP? */
true, /**< separated during LP process? */
true, /**< enforced? */
true, /**< checked for feasibility? */
true, /**< propagate? */
false, /**< only locally valid? */
false, /**< modifiable? */
false, /**< is constraint subject to aging? */
true, /**< removable? */
false));
return SCIP_OKAY;
}
/** creates and captures a stp constraint */
SCIP_RETCODE SCIPcreateConsStp(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** cons, /**< pointer to hold the created constraint */
const char* name, /**< name of constraint */
GRAPH* graph /**< graph data structure */
)
{
SCIP_CONSHDLR* conshdlr;
SCIP_CONSDATA* consdata;
/* find the stp constraint handler */
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("stp constraint handler not found\n");
return SCIP_PLUGINNOTFOUND;
}
SCIP_CALL( SCIPallocBlockMemory(scip, &consdata) );
consdata->graph = graph;
/* create constraint */
SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, FALSE, TRUE, TRUE, TRUE, TRUE,
FALSE, FALSE, FALSE, FALSE, FALSE) );
return SCIP_OKAY;
}
/** creates and captures a xyz constraint
*
* @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
*/
SCIP_RETCODE SCIPcreateConsXyz(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** cons, /**< pointer to hold the created constraint */
const char* name, /**< name of constraint */
int nvars, /**< number of variables in the constraint */
SCIP_VAR** vars, /**< array with variables of constraint entries */
SCIP_Real* coefs, /**< array with coefficients of constraint entries */
SCIP_Real lhs, /**< left hand side of constraint */
SCIP_Real rhs, /**< right hand side of constraint */
SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
* Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
SCIP_Bool separate, /**< should the constraint be separated during LP processing?
* Usually set to TRUE. */
SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
* TRUE for model constraints, FALSE for additional, redundant constraints. */
SCIP_Bool check, /**< should the constraint be checked for feasibility?
* TRUE for model constraints, FALSE for additional, redundant constraints. */
SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
* Usually set to TRUE. */
SCIP_Bool local, /**< is constraint only valid locally?
* Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
* Usually set to FALSE. In column generation applications, set to TRUE if pricing
* adds coefficients to this constraint. */
SCIP_Bool dynamic, /**< is constraint subject to aging?
* Usually set to FALSE. Set to TRUE for own cuts which
* are separated as constraints. */
SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
* Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
* if it may be moved to a more global node?
* Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
)
{
/* TODO: (optional) modify the definition of the SCIPcreateConsXyz() call, if you don't need all the information */
SCIP_CONSHDLR* conshdlr;
SCIP_CONSDATA* consdata;
SCIPerrorMessage("method of xyz constraint handler not implemented yet\n");
SCIPABORT(); /*lint --e{527} --e{715}*/
/* find the xyz constraint handler */
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("xyz constraint handler not found\n");
return SCIP_PLUGINNOTFOUND;
}
/* create constraint data */
consdata = NULL;
/* TODO: create and store constraint specific data here */
/* create constraint */
SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial, separate, enforce, check, propagate,
local, modifiable, dynamic, removable, stickingatnode) );
return SCIP_OKAY;
}
/** creates and captures a disjunction constraint
*
* @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
*/
SCIP_RETCODE SCIPcreateConsDisjunction(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** cons, /**< pointer to hold the created constraint */
const char* name, /**< name of constraint */
int nconss, /**< number of initial constraints in disjunction */
SCIP_CONS** conss, /**< initial constraint in disjunction */
SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
* Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
* TRUE for model constraints, FALSE for additional, redundant constraints. */
SCIP_Bool check, /**< should the constraint be checked for feasibility?
* TRUE for model constraints, FALSE for additional, redundant constraints. */
SCIP_Bool local, /**< is constraint only valid locally?
* Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
* Usually set to FALSE. In column generation applications, set to TRUE if pricing
* adds coefficients to this constraint. */
SCIP_Bool dynamic /**< is constraint subject to aging?
* Usually set to FALSE. Set to TRUE for own cuts which
* are separated as constraints. */
)
{
SCIP_CONSHDLR* conshdlr;
SCIP_CONSDATA* consdata;
/* find the disjunction constraint handler */
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("disjunction constraint handler not found\n");
return SCIP_PLUGINNOTFOUND;
}
/* create constraint data */
SCIP_CALL( consdataCreate(scip, &consdata, conss, nconss) );
/* create constraint */
SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, initial, FALSE, enforce, check, FALSE,
local, modifiable, dynamic, FALSE, FALSE) );
return SCIP_OKAY;
}
/** transforms constraint data into data belonging to the transformed problem */
static
SCIP_DECL_CONSTRANS(consTransDisjunction)
{ /*lint --e{715}*/
SCIP_CONSDATA* sourcedata;
SCIP_CONSDATA* targetdata;
/* get constraint data of source constraint */
sourcedata = SCIPconsGetData(sourcecons);
assert(sourcedata != NULL);
SCIP_CALL( consdataCreate(scip, &targetdata, sourcedata->conss, sourcedata->nconss) );
/* 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;
}
/** transforms constraint data into data belonging to the transformed problem */
static
SCIP_DECL_CONSTRANS(consTransConjunction)
{ /*lint --e{715}*/
SCIP_CONSDATA* sourcedata;
SCIP_CONSDATA* targetdata;
int c;
/* create constraint data for target constraint */
SCIP_CALL( SCIPallocBlockMemory(scip, &targetdata) );
/* get constraint data of source constraint */
sourcedata = SCIPconsGetData(sourcecons);
if( sourcedata->nconss > 0 )
{
targetdata->consssize = sourcedata->nconss;
targetdata->nconss = sourcedata->nconss;
SCIP_CALL( SCIPallocBlockMemoryArray(scip, &targetdata->conss, targetdata->consssize) );
for( c = 0; c < sourcedata->nconss; ++c )
{
SCIP_CALL( SCIPtransformCons(scip, sourcedata->conss[c], &targetdata->conss[c]) );
}
}
else
{
targetdata->conss = NULL;
targetdata->consssize = 0;
targetdata->nconss = 0;
}
/* 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;
}
/** creates and captures a origbranch constraint */
SCIP_RETCODE GCGcreateConsOrigbranch(
SCIP* scip, /**< SCIP data structure */
SCIP_CONS** cons, /**< pointer to hold the created constraint */
const char* name, /**< name of constraint */
SCIP_NODE* node, /**< the node to which this origbranch constraint belongs */
SCIP_CONS* parentcons, /**< origbranch constraint associated with the father node */
SCIP_BRANCHRULE* branchrule, /**< the branching rule that created the b&b node the constraint belongs to */
GCG_BRANCHDATA* branchdata /**< branching data storing information about the branching restrictions at the
* corresponding node */
)
{
SCIP_CONSHDLR* conshdlr;
SCIP_CONSDATA* consdata;
assert(scip != NULL);
assert((parentcons == NULL) == (node == NULL));
/* find the origbranch constraint handler */
conshdlr = SCIPfindConshdlr(scip, CONSHDLR_NAME);
if( conshdlr == NULL )
{
SCIPerrorMessage("origbranch constraint handler not found\n");
return SCIP_PLUGINNOTFOUND;
}
/* create constraint data */
SCIP_CALL( SCIPallocBlockMemory(scip, &consdata) );
/* initialize the fields in the constraint data */
consdata->parentcons = parentcons;
consdata->node = node;
consdata->child1cons = NULL;
consdata->child2cons = NULL;
consdata->probingtmpcons = NULL;
consdata->mastercons = NULL;
consdata->branchrule = branchrule;
consdata->branchdata = branchdata;
consdata->npropbounds = 0;
consdata->maxpropbounds = 0;
consdata->propvars = NULL;
consdata->propboundtypes = NULL;
consdata->propbounds = NULL;
SCIPdebugMessage("Creating branch orig constraint: <%s>.\n", name);
/* create constraint */
SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, FALSE, FALSE, FALSE, FALSE, FALSE,
TRUE, FALSE, FALSE, FALSE, TRUE) );
/* store the pointer to the new constraint in the origbranch constraint of the parent node */
if( parentcons != NULL )
{
SCIP_CONSDATA* parentdata;
parentdata = SCIPconsGetData(parentcons);
assert(parentdata != NULL);
if( parentdata->child1cons == NULL )
{
parentdata->child1cons = *cons;
}
else
{
assert(parentdata->child2cons == NULL || SCIPinProbing(scip));
/* store the second child in case we are in probing and have to overwrite it */
if( SCIPinProbing(scip) )
{
assert(parentdata->probingtmpcons == NULL);
parentdata->probingtmpcons = parentdata->child2cons;
}
parentdata->child2cons = *cons;
}
}
return SCIP_OKAY;
}