/** creates the distributiondiving heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurDistributiondiving(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
SCIP_EVENTHDLRDATA* eventhdlrdata;
/* create distributiondiving data */
heurdata = NULL;
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
heurdata->memsize = 0;
heurdata->rowmeans = NULL;
heurdata->rowvariances = NULL;
heurdata->rowinfinitiesdown = NULL;
heurdata->rowinfinitiesup = NULL;
heurdata->varfilterposs = NULL;
heurdata->currentlbs = NULL;
heurdata->currentubs = NULL;
/* create event handler first to finish heuristic data */
eventhdlrdata = NULL;
SCIP_CALL( SCIPallocMemory(scip, &eventhdlrdata) );
eventhdlrdata->heurdata = heurdata;
heurdata->eventhdlr = NULL;
SCIP_CALL( SCIPincludeEventhdlrBasic(scip, &heurdata->eventhdlr, EVENTHDLR_NAME,
"event handler for dynamic acitivity distribution updating",
eventExecDistribution, eventhdlrdata) );
assert( heurdata->eventhdlr != NULL);
SCIP_CALL( SCIPsetEventhdlrFree(scip, heurdata->eventhdlr, eventFreeDistributiondiving) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecDistributiondiving, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyDistributiondiving) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeDistributiondiving) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitDistributiondiving) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitDistributiondiving) );
SCIP_CALL( SCIPcreateDiveset(scip, NULL, heur, HEUR_NAME, DEFAULT_MINRELDEPTH,
DEFAULT_MAXRELDEPTH, DEFAULT_MAXLPITERQUOT, DEFAULT_MAXDIVEUBQUOT,
DEFAULT_MAXDIVEAVGQUOT, DEFAULT_MAXDIVEUBQUOTNOSOL,
DEFAULT_MAXDIVEAVGQUOTNOSOL, DEFAULT_LPRESOLVEDOMCHGQUOT, DEFAULT_LPSOLVEFREQ,
DEFAULT_MAXLPITEROFS, DEFAULT_BACKTRACK, DEFAULT_ONLYLPBRANCHCANDS, DIVESET_DIVETYPES,
divesetGetScoreDistributiondiving) );
SCIP_CALL( SCIPaddCharParam(scip, "heuristics/" HEUR_NAME "/scoreparam",
"the score;largest 'd'ifference, 'l'owest cumulative probability,'h'ighest c.p., 'v'otes lowest c.p., votes highest c.p.('w'), 'r'evolving",
&heurdata->scoreparam, TRUE, DEFAULT_SCOREPARAM, "lvdhwr", NULL, NULL) );
return SCIP_OKAY;
}
/** creates the fix-and-infer primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurFixandinfer(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Fixandinfer primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecFixandinfer, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyFixandinfer) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeFixandinfer) );
/* fixandinfer heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/fixandinfer/proprounds",
"maximal number of propagation rounds in probing subproblems (-1: no limit, 0: auto)",
&heurdata->proprounds, TRUE, DEFAULT_PROPROUNDS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/fixandinfer/minfixings",
"minimal number of fixings to apply before dive may be aborted",
&heurdata->minfixings, TRUE, DEFAULT_MINFIXINGS, 0, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the local primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurForward(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Local primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/*
heurdata->
*/
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecForward, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyForward) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeForward) );
return SCIP_OKAY;
}
/** creates the all variables full strong LP branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchruleAllfullstrong(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create allfullstrong branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
branchruledata->lastcand = 0;
branchruledata->skipup = NULL;
branchruledata->skipdown = NULL;
/* include allfullstrong branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non-fundamental callbacks via specific setter functions*/
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyAllfullstrong) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreeAllfullstrong) );
SCIP_CALL( SCIPsetBranchruleInit(scip, branchrule, branchInitAllfullstrong) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpAllfullstrong) );
SCIP_CALL( SCIPsetBranchruleExecPs(scip, branchrule, branchExecpsAllfullstrong) );
return SCIP_OKAY;
}
/** creates the impliedbounds separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaImpliedbounds(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_SEPADATA* sepadata;
SCIP_SEPA* sepa;
/* create impliedbounds separator data */
SCIP_CALL( SCIPallocMemory(scip, &sepadata) );
assert(sepadata != NULL);
/* include separator */
SCIP_CALL( SCIPincludeSepaBasic(scip, &sepa, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST,
SEPA_USESSUBSCIP, SEPA_DELAY,
sepaExeclpImpliedbounds, sepaExecsolImpliedbounds,
sepadata) );
assert(sepa != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyImpliedbounds) );
SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeImpliedbounds) );
/* add separator parameters */
SCIP_CALL( SCIPaddBoolParam(scip, "separating/impliedbounds/usetwosizecliques",
"should violated inequalities for cliques with 2 variables be separated?",
&sepadata->usetwosizecliques, TRUE, DEFAULT_USETWOSIZECLIQUES, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the myfullstrong branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchruleMyfullstrong(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create myfullstrong branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
/* TODO: (optional) create branching rule specific data here */
/* include branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreeMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleInit(scip, branchrule, branchInitMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleExit(scip, branchrule, branchExitMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleExecPs(scip, branchrule, branchExecpsMyfullstrong) );
#if 0
SCIP_CALL( SCIPsetBranchruleInitsol(scip, branchrule, branchInitsolMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleExitsol(scip, branchrule, branchExitsolMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleExecExt(scip, branchrule, branchExecextMyfullstrong) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpMyfullstrong) );
#endif
return SCIP_OKAY;
}
/** creates the multi-aggregated branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchruleStp(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create stp branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
branchruledata->lastcand = 0;
/* include branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyStp) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreeStp) );
SCIP_CALL( SCIPsetBranchruleInit(scip, branchrule, branchInitStp) );
SCIP_CALL( SCIPsetBranchruleExit(scip, branchrule, branchExitStp) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpStp) );
return SCIP_OKAY;
}
/** create linear ordering problem instance */
SCIP_RETCODE LOPcreateProb(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< name of file to read */
)
{
SCIP_PROBDATA* probdata = NULL;
char probname[SCIP_MAXSTRLEN];
/* allocate memory */
SCIP_CALL( SCIPallocMemory(scip, &probdata) );
/* take filename as problem name */
SCIP_CALL( getProblemName(filename, probname, SCIP_MAXSTRLEN) );
SCIPinfoMessage(scip, NULL, "File name:\t\t%s\n", filename);
SCIPinfoMessage(scip, NULL, "Problem name:\t\t%s\n", probname);
/* read file */
SCIP_CALL( LOPreadFile(scip, filename, probdata) );
probdata->vars = NULL;
SCIP_CALL( SCIPcreateProb(scip, probname, probdelorigLOP, NULL, NULL,
NULL, NULL, probcopyLOP, probdata) );
return SCIP_OKAY;
}
/** creates the fracdiving heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurFracdiving(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Fracdiving primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecFracdiving, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyFracdiving) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeFracdiving) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitFracdiving) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitFracdiving) );
/* create a diveset (this will automatically install some additional parameters for the heuristic)*/
SCIP_CALL( SCIPcreateDiveset(scip, NULL, heur, HEUR_NAME, DEFAULT_MINRELDEPTH, DEFAULT_MAXRELDEPTH, DEFAULT_MAXLPITERQUOT,
DEFAULT_MAXDIVEUBQUOT, DEFAULT_MAXDIVEAVGQUOT, DEFAULT_MAXDIVEUBQUOTNOSOL, DEFAULT_MAXDIVEAVGQUOTNOSOL,
DEFAULT_LPRESOLVEDOMCHGQUOT, DEFAULT_LPSOLVEFREQ, DEFAULT_MAXLPITEROFS,
DEFAULT_BACKTRACK, DEFAULT_ONLYLPBRANCHCANDS, DIVESET_DIVETYPES, divesetGetScoreFracdiving) );
return SCIP_OKAY;
}
/** creates the handler for origbranch constraints and includes it in SCIP */
SCIP_RETCODE SCIPincludeConshdlrOrigbranch(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_CONSHDLRDATA* conshdlrData;
SCIPdebugMessage("Including branch orig constraint handler.\n");
SCIP_CALL( SCIPallocMemory(scip, &conshdlrData) );
conshdlrData->stack = NULL;
conshdlrData->nstack = 0;
conshdlrData->maxstacksize = 25;
conshdlrData->rootcons = NULL;
/* include constraint handler */
SCIP_CALL( SCIPincludeConshdlr(scip, CONSHDLR_NAME, CONSHDLR_DESC,
CONSHDLR_SEPAPRIORITY, CONSHDLR_ENFOPRIORITY, CONSHDLR_CHECKPRIORITY,
CONSHDLR_SEPAFREQ, CONSHDLR_PROPFREQ, CONSHDLR_EAGERFREQ, CONSHDLR_MAXPREROUNDS,
CONSHDLR_DELAYSEPA, CONSHDLR_DELAYPROP, CONSHDLR_DELAYPRESOL, CONSHDLR_NEEDSCONS,
SCIP_PROPTIMING_ALWAYS,
consCopyOrigbranch, consFreeOrigbranch, consInitOrigbranch, consExitOrigbranch,
consInitpreOrigbranch, consExitpreOrigbranch, consInitsolOrigbranch, consExitsolOrigbranch,
consDeleteOrigbranch, consTransOrigbranch, consInitlpOrigbranch,
consSepalpOrigbranch, consSepasolOrigbranch, consEnfolpOrigbranch, consEnfopsOrigbranch, consCheckOrigbranch,
consPropOrigbranch, consPresolOrigbranch, consRespropOrigbranch, consLockOrigbranch,
consActiveOrigbranch, consDeactiveOrigbranch,
consEnableOrigbranch, consDisableOrigbranch,
consDelvarsOrigbranch, consPrintOrigbranch, consCopyOrigbranch, consParseOrigbranch,
consGetVarsOrigbranch, consGetNVarsOrigbranch,
conshdlrData) );
return SCIP_OKAY;
}
/** includes event handler for best solution found */
SCIP_RETCODE SCIPincludeEventHdlrSofttimelimit(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_EVENTHDLRDATA* eventhdlrdata;
SCIP_EVENTHDLR* eventhdlr;
SCIP_CALL( SCIPallocMemory(scip, &eventhdlrdata) );
eventhdlrdata->filterpos = -1;
eventhdlr = NULL;
/* create event handler for events on watched variables */
SCIP_CALL( SCIPincludeEventhdlrBasic(scip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC, eventExecSofttimelimit, eventhdlrdata) );
assert(eventhdlr != NULL);
SCIP_CALL( SCIPsetEventhdlrCopy(scip, eventhdlr, eventCopySofttimelimit) );
SCIP_CALL( SCIPsetEventhdlrFree(scip, eventhdlr, eventFreeSofttimelimit) );
SCIP_CALL( SCIPsetEventhdlrInit(scip, eventhdlr, eventInitSofttimelimit) );
SCIP_CALL( SCIPsetEventhdlrExit(scip, eventhdlr, eventExitSofttimelimit) );
SCIP_CALL( SCIPaddRealParam(scip, "limits/softtime",
"soft time limit which should be applied after first solution was found",
&eventhdlrdata->softtimelimit, FALSE, -1.0, -1.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the reoptsols primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurReoptsols(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create reoptsols primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecReoptsols, heurdata) );
assert(heur != NULL);
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyReoptsols) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeReoptsols) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitReoptsols) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitReoptsols) );
SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolReoptsols) );
SCIP_CALL( SCIPsetHeurExitsol(scip, heur, heurExitsolReoptsols) );
/* parameters */
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/maxsols", "maximal number solutions which should be checked. (-1: all)",
&heurdata->maxsols, TRUE, 1000, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/maxruns", "check solutions of the last k runs. (-1: all)",
&heurdata->maxruns, TRUE, -1, -1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the binpacking variable pricer and includes it in SCIP */
SCIP_RETCODE SCIPincludePricerBinpacking(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_PRICERDATA* pricerdata;
SCIP_PRICER* pricer;
/* create binpacking variable pricer data */
SCIP_CALL( SCIPallocMemory(scip, &pricerdata) );
pricerdata->conshdlr = SCIPfindConshdlr(scip, "samediff");
assert(pricerdata->conshdlr != NULL);
pricerdata->conss = NULL;
pricerdata->weights = NULL;
pricerdata->ids = NULL;
pricerdata->nitems = 0;
pricerdata->capacity = 0;
/* include variable pricer */
SCIP_CALL( SCIPincludePricerBasic(scip, &pricer, PRICER_NAME, PRICER_DESC, PRICER_PRIORITY, PRICER_DELAY,
pricerRedcostBinpacking, pricerFarkasBinpacking, pricerdata) );
SCIP_CALL( SCIPsetPricerFree(scip, pricer, pricerFreeBinpacking) );
SCIP_CALL( SCIPsetPricerInit(scip, pricer, pricerInitBinpacking) );
SCIP_CALL( SCIPsetPricerExitsol(scip, pricer, pricerExitsolBinpacking) );
/* add binpacking variable pricer parameters */
/* TODO: (optional) add variable pricer specific parameters with SCIPaddTypeParam() here */
return SCIP_OKAY;
}
/** creates the redcost propagator and includes it in SCIP */
SCIP_RETCODE SCIPincludePropRedcost(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_PROPDATA* propdata;
SCIP_PROP* prop;
/* create redcost propagator data */
SCIP_CALL( SCIPallocMemory(scip, &propdata) );
/* include propagator */
SCIP_CALL( SCIPincludePropBasic(scip, &prop, PROP_NAME, PROP_DESC, PROP_PRIORITY, PROP_FREQ, PROP_DELAY, PROP_TIMING,
propExecRedcost, propdata) );
assert(prop != NULL);
/* set optional callbacks via setter functions */
SCIP_CALL( SCIPsetPropCopy(scip, prop, propCopyRedcost) );
SCIP_CALL( SCIPsetPropInitsol(scip, prop, propInitsolRedcost) );
SCIP_CALL( SCIPsetPropFree(scip, prop, propFreeRedcost) );
/* add redcost propagator parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"propagating/"PROP_NAME"/continuous",
"should reduced cost fixing be also applied to continuous variables?",
&propdata->continuous, FALSE, DEFAULT_CONTINUOUS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"propagating/"PROP_NAME"/useimplics",
"should implications be used to strength the reduced cost for binary variables?",
&propdata->useimplics, FALSE, DEFAULT_USEIMPLICS, NULL, NULL) );
return SCIP_OKAY;
}
/** includes the cip file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderCip(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
SCIP_READER* reader;
/* create cip reader data */
SCIP_CALL( SCIPallocMemory(scip, &readerdata) );
/* include reader */
SCIP_CALL( SCIPincludeReaderBasic(scip, &reader, READER_NAME, READER_DESC, READER_EXTENSION, readerdata) );
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetReaderCopy(scip, reader, readerCopyCip) );
SCIP_CALL( SCIPsetReaderFree(scip, reader, readerFreeCip) );
SCIP_CALL( SCIPsetReaderRead(scip, reader, readerReadCip) );
SCIP_CALL( SCIPsetReaderWrite(scip, reader, readerWriteCip) );
/* add cip reader parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/cipreader/writefixedvars", "should fixed and aggregated variables be printed (if not, re-parsing might fail)",
&readerdata->writefixedvars, FALSE, DEFAULT_CIP_WRITEFIXEDVARS, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the random branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchruleRandom(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create random branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
branchruledata->seed = 0;
/* include allfullstrong branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non-fundamental callbacks via specific setter functions*/
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyRandom) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreeRandom) );
SCIP_CALL( SCIPsetBranchruleInit(scip, branchrule, branchInitRandom) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpRandom) );
SCIP_CALL( SCIPsetBranchruleExecExt(scip, branchrule, branchExecextRandom) );
SCIP_CALL( SCIPsetBranchruleExecPs(scip, branchrule, branchExecpsRandom) );
SCIP_CALL( SCIPaddIntParam(scip, "branching/" BRANCHRULE_NAME "/seed", "initial random seed value",
&branchruledata->initseed, FALSE, DEFAULT_INITSEED, 0, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the node selector for best first search and includes it in SCIP */
SCIP_RETCODE SCIPincludeNodeselBfs(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_NODESELDATA* nodeseldata;
/* allocate and initialize node selector data; this has to be freed in the destructor */
SCIP_CALL( SCIPallocMemory(scip, &nodeseldata) );
/* include node selector */
SCIP_CALL( SCIPincludeNodesel(scip, NODESEL_NAME, NODESEL_DESC, NODESEL_STDPRIORITY, NODESEL_MEMSAVEPRIORITY,
nodeselCopyBfs,
nodeselFreeBfs, nodeselInitBfs, nodeselExitBfs,
nodeselInitsolBfs, nodeselExitsolBfs, nodeselSelectBfs, nodeselCompBfs,
nodeseldata) );
/* add node selector parameters */
SCIP_CALL( SCIPaddIntParam(scip,
"nodeselection/bfs/minplungedepth",
"minimal plunging depth, before new best node may be selected (-1 for dynamic setting)",
&nodeseldata->minplungedepth, TRUE, MINPLUNGEDEPTH, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"nodeselection/bfs/maxplungedepth",
"maximal plunging depth, before new best node is forced to be selected (-1 for dynamic setting)",
&nodeseldata->maxplungedepth, TRUE, MAXPLUNGEDEPTH, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"nodeselection/bfs/maxplungequot",
"maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where plunging is performed",
&nodeseldata->maxplungequot, TRUE, MAXPLUNGEQUOT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the stp variable pricer and includes it in SCIP */
SCIP_RETCODE SCIPincludePricerStp(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_PRICERDATA* pricerdata;
SCIP_PRICER* pricer;
SCIPdebugPrintf("include Pricer \n");
/* create stp variable pricer data */
SCIP_CALL( SCIPallocMemory(scip, &pricerdata) );
pricerdata->scip = scip;
/* include variable pricer */
pricer = NULL;
SCIP_CALL( SCIPincludePricerBasic(scip, &pricer, PRICER_NAME, PRICER_DESC, PRICER_PRIORITY, PRICER_DELAY,
pricerRedcostStp, pricerFarkasStp, pricerdata) );
assert(pricer != NULL);
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetPricerCopy(scip, pricer, pricerCopyStp) );
SCIP_CALL( SCIPsetPricerFree(scip, pricer, pricerFreeStp) );
SCIP_CALL( SCIPsetPricerInit(scip, pricer, pricerInitStp) );
SCIP_CALL( SCIPsetPricerInitsol(scip, pricer, pricerInitsolStp) );
SCIP_CALL( SCIPsetPricerExitsol(scip, pricer, pricerExitsolStp) );
return SCIP_OKAY;
}
/** creates the rootsoldiving heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurRootsoldiving(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Rootsoldiving primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecRootsoldiving, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyRootsoldiving) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeRootsoldiving) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitRootsoldiving) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitRootsoldiving) );
/* rootsoldiving heuristic parameters */
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/minreldepth",
"minimal relative depth to start diving",
&heurdata->minreldepth, TRUE, DEFAULT_MINRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/maxreldepth",
"maximal relative depth to start diving",
&heurdata->maxreldepth, TRUE, DEFAULT_MAXRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/maxlpiterquot",
"maximal fraction of diving LP iterations compared to node LP iterations",
&heurdata->maxlpiterquot, FALSE, DEFAULT_MAXLPITERQUOT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/rootsoldiving/maxlpiterofs",
"additional number of allowed LP iterations",
&heurdata->maxlpiterofs, FALSE, DEFAULT_MAXLPITEROFS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/rootsoldiving/maxsols",
"total number of feasible solutions found up to which heuristic is called (-1: no limit)",
&heurdata->maxsols, TRUE, DEFAULT_MAXSOLS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/depthfac",
"maximal diving depth: number of binary/integer variables times depthfac",
&heurdata->depthfac, TRUE, DEFAULT_DEPTHFAC, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/depthfacnosol",
"maximal diving depth factor if no feasible solution was found yet",
&heurdata->depthfacnosol, TRUE, DEFAULT_DEPTHFACNOSOL, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/rootsoldiving/alpha",
"soft rounding factor to fade out objective coefficients",
&heurdata->alpha, TRUE, DEFAULT_ALPHA, 0.0, 1.0, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the zeroobj primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurZeroobj(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
heur = NULL;
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecZeroobj, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyZeroobj) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeZeroobj) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitZeroobj) );
/* add zeroobj primal heuristic parameters */
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/maxnodes",
"maximum number of nodes to regard in the subproblem",
&heurdata->maxnodes, TRUE,DEFAULT_MAXNODES, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/nodesofs",
"number of nodes added to the contingent of the total nodes",
&heurdata->nodesofs, FALSE, DEFAULT_NODESOFS, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/minnodes",
"minimum number of nodes required to start the subproblem",
&heurdata->minnodes, TRUE, DEFAULT_MINNODES, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/maxlpiters",
"maximum number of LP iterations to be performed in the subproblem",
&heurdata->maxlpiters, TRUE, DEFAULT_MAXLPITERS, -1LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/nodesquot",
"contingent of sub problem nodes in relation to the number of nodes of the original problem",
&heurdata->nodesquot, FALSE, DEFAULT_NODESQUOT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minimprove",
"factor by which zeroobj should at least improve the incumbent",
&heurdata->minimprove, TRUE, DEFAULT_MINIMPROVE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/addallsols",
"should all subproblem solutions be added to the original SCIP?",
&heurdata->addallsols, TRUE, DEFAULT_ADDALLSOLS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/onlywithoutsol",
"should heuristic only be executed if no primal solution was found, yet?",
&heurdata->onlywithoutsol, TRUE, DEFAULT_ONLYWITHOUTSOL, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the handler for stp constraints and includes it in SCIP */
SCIP_RETCODE SCIPincludeConshdlrStp(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_CONSHDLRDATA* conshdlrdata;
SCIP_CONSHDLR* conshdlr;
/* create stp constraint handler data */
SCIP_CALL( SCIPallocMemory(scip, &conshdlrdata) );
conshdlr = NULL;
/* include constraint handler */
SCIP_CALL( SCIPincludeConshdlrBasic(scip, &conshdlr, CONSHDLR_NAME, CONSHDLR_DESC,
CONSHDLR_ENFOPRIORITY, CONSHDLR_CHECKPRIORITY, CONSHDLR_EAGERFREQ, CONSHDLR_NEEDSCONS,
consEnfolpStp, consEnfopsStp, consCheckStp, consLockStp,
conshdlrdata) );
assert(conshdlr != NULL);
SCIP_CALL( SCIPsetConshdlrCopy(scip, conshdlr, conshdlrCopyStp, consCopyStp) );
SCIP_CALL( SCIPsetConshdlrDelete(scip, conshdlr, consDeleteStp) );
SCIP_CALL( SCIPsetConshdlrTrans(scip, conshdlr, consTransStp) );
SCIP_CALL( SCIPsetConshdlrProp(scip, conshdlr, consPropStp, CONSHDLR_PROPFREQ, CONSHDLR_DELAYPROP,
CONSHDLR_PROP_TIMING) );
SCIP_CALL( SCIPsetConshdlrSepa(scip, conshdlr, consSepalpStp, NULL, CONSHDLR_SEPAFREQ,
CONSHDLR_SEPAPRIORITY, CONSHDLR_DELAYSEPA) );
SCIP_CALL( SCIPsetConshdlrFree(scip, conshdlr, consFreeStp) );
SCIP_CALL( SCIPaddBoolParam(scip, "constraints/stp/backcut", "Try Back-Cuts",
&conshdlrdata->backcut, TRUE, DEFAULT_BACKCUT, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "constraints/stp/creepflow", "Use Creep-Flow",
&conshdlrdata->creepflow, TRUE, DEFAULT_CREEPFLOW, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "constraints/stp/disjunctcut", "Only disjunct Cuts",
&conshdlrdata->disjunctcut, TRUE, DEFAULT_DISJUNCTCUT, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "constraints/stp/nestedcut", "Try Nested-Cuts",
&conshdlrdata->nestedcut, TRUE, DEFAULT_NESTEDCUT, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "constraints/stp/flowsep", "Try Flow-Cuts",
&conshdlrdata->flowsep, TRUE, DEFAULT_FLOWSEP, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"constraints/"CONSHDLR_NAME"/maxrounds",
"maximal number of separation rounds per node (-1: unlimited)",
&conshdlrdata->maxrounds, FALSE, DEFAULT_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"constraints/"CONSHDLR_NAME"/maxroundsroot",
"maximal number of separation rounds per node in the root node (-1: unlimited)",
&conshdlrdata->maxroundsroot, FALSE, DEFAULT_MAXROUNDSROOT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"constraints/"CONSHDLR_NAME"/maxsepacuts",
"maximal number of cuts separated per separation round",
&conshdlrdata->maxsepacuts, FALSE, DEFAULT_MAXSEPACUTS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"constraints/"CONSHDLR_NAME"/maxsepacutsroot",
"maximal number of cuts separated per separation round in the root node",
&conshdlrdata->maxsepacutsroot, FALSE, DEFAULT_MAXSEPACUTSROOT, 0, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates RENS primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurGcgrens(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
/* create heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeur(scip, HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP,
heurCopyGcgrens,
heurFreeGcgrens, heurInitGcgrens, heurExitGcgrens,
heurInitsolGcgrens, heurExitsolGcgrens, heurExecGcgrens,
heurdata) );
/* add rens primal heuristic parameters */
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minfixingrate",
"minimum percentage of integer variables that have to be fixable",
&heurdata->minfixingrate, FALSE, DEFAULT_MINFIXINGRATE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/maxnodes",
"maximum number of nodes to regard in the subproblem",
&heurdata->maxnodes, TRUE,DEFAULT_MAXNODES, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/nodesofs",
"number of nodes added to the contingent of the total nodes",
&heurdata->nodesofs, FALSE, DEFAULT_NODESOFS, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/minnodes",
"minimum number of nodes required to start the subproblem",
&heurdata->minnodes, TRUE, DEFAULT_MINNODES, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/nodesquot",
"contingent of sub problem nodes in relation to the number of nodes of the original problem",
&heurdata->nodesquot, FALSE, DEFAULT_NODESQUOT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minimprove",
"factor by which RENS should at least improve the incumbent",
&heurdata->minimprove, TRUE, DEFAULT_MINIMPROVE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/binarybounds",
"should general integers get binary bounds [floor(.),ceil(.)] ?",
&heurdata->binarybounds, TRUE, DEFAULT_BINARYBOUNDS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/uselprows",
"should subproblem be created out of the rows in the LP rows?",
&heurdata->uselprows, TRUE, DEFAULT_USELPROWS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/copycuts",
"if uselprows == FALSE, should all active cuts from cutpool be copied to constraints in subproblem?",
&heurdata->copycuts, TRUE, DEFAULT_COPYCUTS, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the pseudo cost branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchrulePscost(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create pscost branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
/* include allfullstrong branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non-fundamental callbacks via specific setter functions*/
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyPscost) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreePscost) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpPscost) );
SCIP_CALL( SCIPsetBranchruleExecExt(scip, branchrule, branchExecextPscost) );
SCIP_CALL( SCIPaddCharParam(scip, "branching/"BRANCHRULE_NAME"/strategy",
"strategy for utilizing pseudo-costs of external branching candidates (multiply as in pseudo costs 'u'pdate rule, or by 'd'omain reduction, or by domain reduction of 's'ibling, or by 'v'ariable score)",
&branchruledata->strategy, FALSE, BRANCHRULE_STRATEGY_DEFAULT, BRANCHRULE_STRATEGIES, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/minscoreweight",
"weight for minimum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoreminweight, TRUE, BRANCHRULE_SCOREMINWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/maxscoreweight",
"weight for maximum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoremaxweight, TRUE, BRANCHRULE_SCOREMAXWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/sumscoreweight",
"weight for sum of scores of a branching candidate when building weighted sum of min/max/sum of scores",
&branchruledata->scoresumweight, TRUE, BRANCHRULE_SCORESUMWEIGHT_DEFAULT, -SCIPinfinity(scip), SCIPinfinity(scip), NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "branching/"BRANCHRULE_NAME"/nchildren",
"number of children to create in n-ary branching",
&branchruledata->nchildren, FALSE, BRANCHRULE_NCHILDREN_DEFAULT, 2, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "branching/"BRANCHRULE_NAME"/narymaxdepth",
"maximal depth where to do n-ary branching, -1 to turn off",
&branchruledata->narymaxdepth, FALSE, BRANCHRULE_NARYMAXDEPTH_DEFAULT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/naryminwidth",
"minimal domain width in children when doing n-ary branching, relative to global bounds",
&branchruledata->naryminwidth, FALSE, BRANCHRULE_NARYMINWIDTH_DEFAULT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "branching/"BRANCHRULE_NAME"/narywidthfactor",
"factor of domain width in n-ary branching when creating nodes with increasing distance from branching value",
&branchruledata->narywidthfactor, FALSE, BRANCHRULE_NARYWIDTHFAC_DEFAULT, 1.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the guideddiving heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurGuideddiving(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Guideddiving primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include primal heuristic */
SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecGuideddiving, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyGuideddiving) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeGuideddiving) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitGuideddiving) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitGuideddiving) );
/* guideddiving heuristic parameters */
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/guideddiving/minreldepth",
"minimal relative depth to start diving",
&heurdata->minreldepth, TRUE, DEFAULT_MINRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/guideddiving/maxreldepth",
"maximal relative depth to start diving",
&heurdata->maxreldepth, TRUE, DEFAULT_MAXRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/guideddiving/maxlpiterquot",
"maximal fraction of diving LP iterations compared to node LP iterations",
&heurdata->maxlpiterquot, FALSE, DEFAULT_MAXLPITERQUOT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/guideddiving/maxlpiterofs",
"additional number of allowed LP iterations",
&heurdata->maxlpiterofs, FALSE, DEFAULT_MAXLPITEROFS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/guideddiving/maxdiveubquot",
"maximal quotient (curlowerbound - lowerbound)/(cutoffbound - lowerbound) where diving is performed (0.0: no limit)",
&heurdata->maxdiveubquot, TRUE, DEFAULT_MAXDIVEUBQUOT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/guideddiving/maxdiveavgquot",
"maximal quotient (curlowerbound - lowerbound)/(avglowerbound - lowerbound) where diving is performed (0.0: no limit)",
&heurdata->maxdiveavgquot, TRUE, DEFAULT_MAXDIVEAVGQUOT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/guideddiving/backtrack",
"use one level of backtracking if infeasibility is encountered?",
&heurdata->backtrack, FALSE, DEFAULT_BACKTRACK, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the inference history branching rule and includes it in SCIP */
SCIP_RETCODE SCIPincludeBranchruleInference(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_BRANCHRULEDATA* branchruledata;
SCIP_BRANCHRULE* branchrule;
/* create inference branching rule data */
SCIP_CALL( SCIPallocMemory(scip, &branchruledata) );
/* include branching rule */
SCIP_CALL( SCIPincludeBranchruleBasic(scip, &branchrule, BRANCHRULE_NAME, BRANCHRULE_DESC, BRANCHRULE_PRIORITY,
BRANCHRULE_MAXDEPTH, BRANCHRULE_MAXBOUNDDIST, branchruledata) );
assert(branchrule != NULL);
/* set non-fundamental callbacks via specific setter functions*/
SCIP_CALL( SCIPsetBranchruleCopy(scip, branchrule, branchCopyInference) );
SCIP_CALL( SCIPsetBranchruleFree(scip, branchrule, branchFreeInference) );
SCIP_CALL( SCIPsetBranchruleExecLp(scip, branchrule, branchExeclpInference) );
SCIP_CALL( SCIPsetBranchruleExecExt(scip, branchrule, branchExecextInference) );
SCIP_CALL( SCIPsetBranchruleExecPs(scip, branchrule, branchExecpsInference) );
/* inference branching rule parameters */
SCIP_CALL( SCIPaddRealParam(scip,
"branching/inference/conflictweight",
"weight in score calculations for conflict score",
&branchruledata->conflictweight, TRUE, DEFAULT_CONFLICTWEIGHT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"branching/inference/inferenceweight",
"weight in score calculations for inference score",
&branchruledata->inferenceweight, TRUE, DEFAULT_INFERENCEWEIGHT, SCIP_REAL_MIN, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"branching/inference/cutoffweight",
"weight in score calculations for cutoff score",
&branchruledata->cutoffweight, TRUE, DEFAULT_CUTOFFWEIGHT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"branching/inference/fractionals",
"should branching on LP solution be restricted to the fractional variables?",
&branchruledata->fractionals, TRUE, DEFAULT_FRACTIONALS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"branching/inference/useweightedsum",
"should a weighted sum of inference, conflict and cutoff weights be used?",
&branchruledata->useweightedsum, FALSE, DEFAULT_USEWEIGHTEDSUM, NULL, NULL) );
/* inference branching rule parameters */
SCIP_CALL( SCIPaddRealParam(scip,
"branching/inference/reliablescore",
"weight in score calculations for conflict score",
&branchruledata->reliablescore, TRUE, DEFAULT_RELIABLESCORE, 0.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the Strong CG cut separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaStrongcg(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_SEPADATA* sepadata;
SCIP_SEPA* sepa;
/* create separator data */
SCIP_CALL( SCIPallocMemory(scip, &sepadata) );
sepadata->lastncutsfound = 0;
/* include separator */
SCIP_CALL( SCIPincludeSepaBasic(scip, &sepa, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST,
SEPA_USESSUBSCIP, SEPA_DELAY,
sepaExeclpStrongcg, NULL,
sepadata) );
assert(sepa != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyStrongcg) );
SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeStrongcg) );
/* add separator parameters */
SCIP_CALL( SCIPaddIntParam(scip,
"separating/strongcg/maxrounds",
"maximal number of strong CG separation rounds per node (-1: unlimited)",
&sepadata->maxrounds, FALSE, DEFAULT_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/strongcg/maxroundsroot",
"maximal number of strong CG separation rounds in the root node (-1: unlimited)",
&sepadata->maxroundsroot, FALSE, DEFAULT_MAXROUNDSROOT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/strongcg/maxsepacuts",
"maximal number of strong CG cuts separated per separation round",
&sepadata->maxsepacuts, FALSE, DEFAULT_MAXSEPACUTS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/strongcg/maxsepacutsroot",
"maximal number of strong CG cuts separated per separation round in the root node",
&sepadata->maxsepacutsroot, FALSE, DEFAULT_MAXSEPACUTSROOT, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"separating/strongcg/maxweightrange",
"maximal valid range max(|weights|)/min(|weights|) of row weights",
&sepadata->maxweightrange, TRUE, DEFAULT_MAXWEIGHTRANGE, 1.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/strongcg/dynamiccuts",
"should generated cuts be removed from the LP if they are no longer tight?",
&sepadata->dynamiccuts, FALSE, DEFAULT_DYNAMICCUTS, NULL, NULL) );
return SCIP_OKAY;
}
/** copies user data of source SCIP for the target SCIP */
static
SCIP_DECL_PROBCOPY(probcopyLOP)
{
int n;
int i;
int j;
assert( scip != NULL );
assert( sourcescip != NULL );
assert( sourcedata != NULL );
assert( targetdata != NULL );
/* set up data */
SCIP_CALL( SCIPallocMemory(scip, targetdata) );
n = sourcedata->n;
(*targetdata)->n = n;
/* set matrices */
SCIP_CALL( SCIPallocMemoryArray(scip, &((*targetdata)->W), n) );
SCIP_CALL( SCIPallocMemoryArray(scip, &((*targetdata)->vars), n) );
for( i = 0; i < n; ++i )
{
SCIP_CALL( SCIPallocMemoryArray(scip, &((*targetdata)->W[i]), n) ); /*lint !e866*/
SCIP_CALL( SCIPallocMemoryArray(scip, &((*targetdata)->vars[i]), n) ); /*lint !e866*/
for( j = 0; j < n; ++j )
{
if( i != j )
{
SCIP_VAR* var;
SCIP_Bool success;
SCIP_CALL( SCIPgetTransformedVar(sourcescip, sourcedata->vars[i][j], &var) );
SCIP_CALL( SCIPgetVarCopy(sourcescip, scip, var, &((*targetdata)->vars[i][j]), varmap, consmap, global, &success) );
assert(success);
assert((*targetdata)->vars[i][j] != NULL);
SCIP_CALL( SCIPcaptureVar(scip, (*targetdata)->vars[i][j]) );
}
else
(*targetdata)->vars[i][j] = NULL;
}
}
*result = SCIP_SUCCESS;
return SCIP_OKAY;
}
/** creates the objpscostdiving heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurObjpscostdiving(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
/* create heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
/* include heuristic */
SCIP_CALL( SCIPincludeHeur(scip, HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP,
heurCopyObjpscostdiving,
heurFreeObjpscostdiving, heurInitObjpscostdiving, heurExitObjpscostdiving,
heurInitsolObjpscostdiving, heurExitsolObjpscostdiving, heurExecObjpscostdiving,
heurdata) );
/* objpscostdiving heuristic parameters */
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/objpscostdiving/minreldepth",
"minimal relative depth to start diving",
&heurdata->minreldepth, TRUE, DEFAULT_MINRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/objpscostdiving/maxreldepth",
"maximal relative depth to start diving",
&heurdata->maxreldepth, TRUE, DEFAULT_MAXRELDEPTH, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/objpscostdiving/maxlpiterquot",
"maximal fraction of diving LP iterations compared to total iteration number",
&heurdata->maxlpiterquot, FALSE, DEFAULT_MAXLPITERQUOT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/objpscostdiving/maxlpiterofs",
"additional number of allowed LP iterations",
&heurdata->maxlpiterofs, FALSE, DEFAULT_MAXLPITEROFS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/objpscostdiving/maxsols",
"total number of feasible solutions found up to which heuristic is called (-1: no limit)",
&heurdata->maxsols, TRUE, DEFAULT_MAXSOLS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/objpscostdiving/depthfac",
"maximal diving depth: number of binary/integer variables times depthfac",
&heurdata->depthfac, TRUE, DEFAULT_DEPTHFAC, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"heuristics/objpscostdiving/depthfacnosol",
"maximal diving depth factor if no feasible solution was found yet",
&heurdata->depthfacnosol, TRUE, DEFAULT_DEPTHFACNOSOL, 0.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** includes the blk file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderBlk(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
/* create blk reader data */
SCIP_CALL( SCIPallocMemory(scip, &readerdata) );
/* include blk reader */
SCIP_CALL( SCIPincludeReader(scip, READER_NAME, READER_DESC, READER_EXTENSION, NULL,
readerFreeBlk, readerReadBlk, readerWriteBlk, readerdata) );
return SCIP_OKAY;
}
/** creates separator data */
static
SCIP_RETCODE sepadataCreate(
SCIP* scip, /**< SCIP data structure */
SCIP_SEPADATA** sepadata /**< pointer to store separator data */
)
{
assert(sepadata != NULL);
SCIP_CALL( SCIPallocMemory(scip, sepadata) );
(*sepadata)->objrow = NULL;
(*sepadata)->objvar = NULL;
(*sepadata)->setoff = 0.0;
return SCIP_OKAY;
}