/** deletes the transformed problem */
static
SCIP_DECL_PROBDELTRANS(probdeltransColoring)
{
int i;
assert(scip != NULL);
assert(probdata != NULL);
/* relese constraints and free array for constraints */
for ( i = 0; i < tcliqueGetNNodes((*probdata)->graph); i++)
{
SCIP_CALL( SCIPreleaseCons(scip, &((*probdata)->constraints[i])) );
}
SCIPfreeMemoryArray(scip, &((*probdata)->constraints));
/* free the arrays for the stable sets and relese the related variables */
for ( i = (*probdata)->nstablesets-1; i >= 0; i-- )
{
SCIPfreeBlockMemoryArray(scip, &((*probdata)->stablesets[i]), (*probdata)->stablesetlengths[i]); /*lint !e866*/
SCIP_CALL( SCIPreleaseVar(scip, &((*probdata)->stablesetvars[i])) );
}
SCIPfreeMemoryArray(scip, &((*probdata)->new2oldnode));
SCIPfreeMemoryArray(scip, &((*probdata)->deletednodes));
SCIPfreeMemoryArray(scip, &((*probdata)->stablesetvars));
SCIPfreeMemoryArray(scip, &((*probdata)->stablesetlengths));
SCIPfreeMemoryArray(scip, &((*probdata)->stablesets));
tcliqueFree(&(*probdata)->graph);
SCIPfreeMemory(scip, probdata);
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;
}
/** frees the memory of the given problem data */
static
SCIP_RETCODE probdataFree(
SCIP* scip, /**< SCIP data structure */
SCIP_PROBDATA** probdata /**< pointer to problem data */
)
{
int i;
assert(scip != NULL);
assert(probdata != NULL);
/* release all variables */
for( i = 0; i < (*probdata)->nvars; ++i )
{
SCIP_CALL( SCIPreleaseVar(scip, &(*probdata)->vars[i]) );
}
/* release all constraints */
for( i = 0; i < (*probdata)->nitems; ++i )
{
SCIP_CALL( SCIPreleaseCons(scip, &(*probdata)->conss[i]) );
}
/* free memory of arrays */
SCIPfreeMemoryArray(scip, &(*probdata)->vars);
SCIPfreeMemoryArray(scip, &(*probdata)->conss);
SCIPfreeMemoryArray(scip, &(*probdata)->weights);
SCIPfreeMemoryArray(scip, &(*probdata)->ids);
/* free probdata */
SCIPfreeMemory(scip, probdata);
return SCIP_OKAY;
}
/** delete problem data */
static
SCIP_DECL_PROBDELORIG(probdelorigLOP)
{ /*lint --e{831} */
int i, j;
assert( probdata != NULL );
assert( *probdata != NULL );
/* free matrix and release and free variables */
assert( (*probdata)->W != NULL );
assert( (*probdata)->vars != NULL );
for (i = 0; i < (*probdata)->n; ++i)
{
for (j = 0; j < (*probdata)->n; ++j)
{
if (j != i)
SCIP_CALL( SCIPreleaseVar(scip, &(*probdata)->vars[i][j]) );
}
SCIPfreeMemoryArray(scip, &(*probdata)->vars[i]);
SCIPfreeMemoryArray(scip, &((*probdata)->W[i]));
}
SCIPfreeMemoryArray(scip, &(*probdata)->vars);
SCIPfreeMemoryArray(scip, &((*probdata)->W));
/* free probdata */
SCIPfreeMemory(scip, probdata);
return SCIP_OKAY;
}
/** destructor of branching rule to free user data (called when SCIP is exiting) */
static
SCIP_DECL_BRANCHFREE(branchFreePscost)
{ /*lint --e{715}*/
SCIP_BRANCHRULEDATA* branchruledata;
/* free branching rule data */
branchruledata = SCIPbranchruleGetData(branchrule);
SCIPfreeMemory(scip, &branchruledata);
SCIPbranchruleSetData(branchrule, NULL);
return SCIP_OKAY;
}
/** destructor of reader to free user data (called when SCIP is exiting) */
static
SCIP_DECL_READERFREE(readerFreeCip)
{
SCIP_READERDATA* readerdata;
assert(strcmp(SCIPreaderGetName(reader), READER_NAME) == 0);
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
SCIPfreeMemory(scip, &readerdata);
return SCIP_OKAY;
}
/** destructor of reader to free user data (called when SCIP is exiting) */
static
SCIP_DECL_READERFREE(readerFreeBlk)
{
SCIP_READERDATA* readerdata;
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
SCIPfreeMemory(scip, &readerdata);
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventFreeDistributiondiving)
{
SCIP_EVENTHDLRDATA* eventhdlrdata;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
SCIPfreeMemory(scip, &eventhdlrdata);
SCIPeventhdlrSetData(eventhdlr, NULL);
return SCIP_OKAY;
}
/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
static
SCIP_DECL_HEURFREE(heurFreeFixandinfer) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
/* free heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** destructor of node selector to free user data (called when SCIP is exiting) */
static
SCIP_DECL_NODESELFREE(nodeselFreeMaster)
{
SCIP_NODESELDATA* nodeseldata;
assert(nodesel != NULL);
nodeseldata = SCIPnodeselGetData(nodesel);
assert(nodeseldata != NULL);
SCIPfreeMemory(scip, &nodeseldata);
return SCIP_OKAY;
}
/** destructor of branching rule to free user data (called when SCIP is exiting) */
static
SCIP_DECL_BRANCHFREE(branchFreeMyfullstrong)
{ /*lint --e{715}*/
SCIP_BRANCHRULEDATA* branchruledata;
branchruledata = SCIPbranchruleGetData(branchrule);
assert(branchruledata != NULL);
SCIPfreeMemory(scip, &branchruledata);
SCIPbranchruleSetData(branchrule, NULL);
return SCIP_OKAY;
}
/** destructor of presolver to free user data (called when SCIP is exiting) */
static
SCIP_DECL_PRESOLFREE(presolFreeBoundshift)
{ /*lint --e{715}*/
SCIP_PRESOLDATA* presoldata;
/* free presolver data */
presoldata = SCIPpresolGetData(presol);
assert(presoldata != NULL);
SCIPfreeMemory(scip, &presoldata);
SCIPpresolSetData(presol, NULL);
return SCIP_OKAY;
}
/** destructor of branching rule to free user data (called when SCIP is exiting) */
static
SCIP_DECL_BRANCHFREE(branchFreeAllfullstrong)
{ /*lint --e{715}*/
SCIP_BRANCHRULEDATA* branchruledata;
/* free branching rule data */
branchruledata = SCIPbranchruleGetData(branchrule);
SCIPfreeMemoryArrayNull(scip, &branchruledata->skipdown);
SCIPfreeMemoryArrayNull(scip, &branchruledata->skipup);
SCIPfreeMemory(scip, &branchruledata);
SCIPbranchruleSetData(branchrule, NULL);
return SCIP_OKAY;
}
/** frees separator data */
static
SCIP_RETCODE sepadataFree(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPADATA** sepadata /**< pointer to separator data */
)
{
assert(sepadata != NULL);
assert(*sepadata != NULL);
assert((*sepadata)->objrow == NULL);
assert((*sepadata)->objvar == NULL);
SCIPfreeMemory(scip, sepadata);
return SCIP_OKAY;
}
/** destructor of propagator to free user data (called when SCIP is exiting) */
static
SCIP_DECL_PROPFREE(propFreeRedcost)
{ /*lint --e{715}*/
SCIP_PROPDATA* propdata;
/* free propagator data */
propdata = SCIPpropGetData(prop);
assert(propdata != NULL);
SCIPfreeMemory(scip, &propdata);
SCIPpropSetData(prop, NULL);
return SCIP_OKAY;
}
/* free data of the heuristic */
static
SCIP_DECL_HEURFREE(heurFreeReoptsols)
{
SCIP_HEURDATA* heurdata;
assert(scip != NULL );
assert(heur != NULL );
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL );
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
static
SCIP_DECL_HEURFREE(heurFreeZirounding)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
/* free heuristic data */
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
static
SCIP_DECL_HEURFREE(heurFreeLinesearchdiving)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(heur != NULL);
assert(scip != NULL);
/* free heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** deinitialization method of primal heuristic (called before transformed problem is freed) */
static
SCIP_DECL_HEUREXIT(heurExitSimplerounding) /*lint --e{715}*/
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
/* free heuristic data */
heurdata = SCIPheurGetData(heur);
assert(heurdata != NULL);
SCIP_CALL( SCIPfreeSol(scip, &heurdata->sol) );
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** destructor of node selector to free user data (called when SCIP is exiting) */
static
SCIP_DECL_NODESELFREE(nodeselFreeBfs)
{ /*lint --e{715}*/
SCIP_NODESELDATA* nodeseldata;
assert(nodesel != NULL);
assert(strcmp(SCIPnodeselGetName(nodesel), NODESEL_NAME) == 0);
assert(scip != NULL);
/* free user data of node selector */
nodeseldata = SCIPnodeselGetData(nodesel);
assert(nodeseldata != NULL);
SCIPfreeMemory(scip, &nodeseldata);
SCIPnodeselSetData(nodesel, nodeseldata);
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventFreeSofttimelimit)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
assert(strcmp(SCIPeventhdlrGetName(eventhdlr), EVENTHDLR_NAME) == 0);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
SCIPfreeMemory(scip, &eventhdlrdata);
SCIPeventhdlrSetData(eventhdlr, NULL);
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventFreeBoundwriting)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
assert(scip != NULL);
assert(eventhdlr != NULL);
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(!eventhdlrdata->isopen);
assert(eventhdlrdata->file == NULL);
SCIPfreeMemory(scip, &eventhdlrdata);
return SCIP_OKAY;
}
/** destructor of separator to free user data (called when SCIP is exiting) */
static
SCIP_DECL_SEPAFREE(sepaFreeGomory)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
/* free separator data */
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
SCIPfreeMemory(scip, &sepadata);
SCIPsepaSetData(sepa, NULL);
return SCIP_OKAY;
}
/** destructor of separator to free user data (called when SCIP is exiting) */
static
SCIP_DECL_SEPAFREE(sepaFreeImpliedbounds)
{ /*lint --e{715}*/
SCIP_SEPADATA* sepadata;
assert(scip != NULL);
assert(sepa != NULL);
assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
/* get separation data and free it */
sepadata = SCIPsepaGetData(sepa);
assert(sepadata != NULL);
SCIPfreeMemory(scip, &sepadata);
/* reset data pointer to NULL */
SCIPsepaSetData(sepa, NULL);
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;
}
/** destructor of variable pricer to free user data (called when SCIP is exiting) */
static
SCIP_DECL_PRICERFREE(pricerFreeStp)
{
SCIP_PRICERDATA* pricerdata;
SCIPdebugPrintf("pricerfree \n");
assert(scip != NULL);
/* get pricerdata */
pricerdata = SCIPpricerGetData(pricer);
/* free memory for pricerdata*/
if ( pricerdata != NULL )
{
SCIPfreeMemory(scip, &pricerdata);
}
SCIPpricerSetData(pricer, NULL);
return SCIP_OKAY;
}
/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
static
SCIP_DECL_HEURFREE(heurFreeIndicator)
{ /*lint --e{715}*/
SCIP_HEURDATA* heurdata;
assert( heur != NULL );
assert( scip != NULL );
/* get heuristic data */
heurdata = SCIPheurGetData(heur);
assert( heurdata != NULL );
SCIPfreeBlockMemoryArrayNull(scip, &(heurdata->indconss), heurdata->nindconss);
SCIPfreeBlockMemoryArrayNull(scip, &(heurdata->solcand), heurdata->nindconss);
/* free heuristic data */
SCIPfreeMemory(scip, &heurdata);
SCIPheurSetData(heur, NULL);
return SCIP_OKAY;
}
/** destructor of variable pricer to free user data (called when SCIP is exiting) */
static
SCIP_DECL_PRICERFREE(pricerFreeBinpacking)
{
SCIP_PRICERDATA* pricerdata;
assert(scip != NULL);
assert(pricer != NULL);
pricerdata = SCIPpricerGetData(pricer);
if( pricerdata != NULL)
{
/* free memory */
SCIPfreeMemoryArrayNull(scip, &pricerdata->conss);
SCIPfreeMemoryArrayNull(scip, &pricerdata->weights);
SCIPfreeMemoryArrayNull(scip, &pricerdata->ids);
SCIPfreeMemory(scip, &pricerdata);
}
return SCIP_OKAY;
}
/** destructor of event handler to free user data (called when SCIP is exiting) */
static
SCIP_DECL_EVENTFREE(eventhdlrFreeJava)
{ /*lint --e{715}*/
SCIP_EVENTHDLRDATA* eventhdlrdata;
JNIEnv* env;
jobject jobj;
jlong jscip;
jlong jeventhdlr;
eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
assert(eventhdlrdata != NULL);
assert(eventhdlrdata->javaeventhdlr != NULL);
assert(eventhdlrdata->scip_free != NULL);
jscip = (jlong) (size_t) scip;
jeventhdlr = (jlong) (size_t) eventhdlr;
env = eventhdlrdata->env;
jobj = eventhdlrdata->jobj;
/* call virtual method of eventhdlr object */
JNISCIP_CALL( (*env)->CallIntMethod(env, jobj, eventhdlrdata->scip_free, jscip, jeventhdlr) );
/* free eventhdlr object
*
* ??????????????????????????
*/
// if( eventhdlrdata->deleteobject )
// delete eventhdlrdata->objeventhdlr;
/* free eventhdlr data */
SCIPfreeMemory(scip, &eventhdlrdata)
SCIPeventhdlrSetData(eventhdlr, NULL); /*lint !e64*/
return SCIP_OKAY;
}
static
SCIP_DECL_PROBDELORIG(probdelorigColoring)
{
int i;
assert(probdata != NULL);
assert(*probdata != NULL);
SCIPfreeMemoryArray(scip, &((*probdata)->new2oldnode));
SCIPfreeMemoryArray(scip, &((*probdata)->deletednodes));
for ( i = (*probdata)->nstablesets-1; i >= 0; i-- )
{
SCIPfreeBlockMemoryArray(scip, &((*probdata)->stablesets[i]), (*probdata)->stablesetlengths[i]); /*lint !e866*/
SCIP_CALL( SCIPreleaseVar(scip, &((*probdata)->stablesetvars[i])) );
}
SCIPfreeMemoryArray(scip, &((*probdata)->stablesetvars));
SCIPfreeMemoryArray(scip, &((*probdata)->stablesetlengths));
SCIPfreeMemoryArray(scip, &((*probdata)->stablesets));
/* release Constraints */
for ( i = 0; i < tcliqueGetNNodes((*probdata)->graph); i++ )
{
SCIP_CALL( SCIPreleaseCons(scip, &((*probdata)->constraints[i])) );
}
SCIPfreeMemoryArray(scip, &((*probdata)->constraints));
/* free memory used for graph */
tcliqueFree(&((*probdata)->graph));
tcliqueFree(&((*probdata)->oldgraph));
/* free probdata */
SCIPfreeMemory(scip, probdata);
return SCIP_OKAY;
}