/** includes the cip file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderCip(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
SCIP_READER* reader;
/* create reader data */
readerdata = NULL;
/* 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( SCIPsetReaderRead(scip, reader, readerReadCip) );
SCIP_CALL( SCIPsetReaderWrite(scip, reader, readerWriteCip) );
/* add cip reader parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/"READER_NAME"/dynamicconss", "should model constraints be subject to aging?",
NULL, FALSE, TRUE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/"READER_NAME"/dynamiccols", "should columns be added and removed dynamically to the LP?",
NULL, FALSE, FALSE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/"READER_NAME"/dynamicrows", "should rows be added and removed dynamically to the LP?",
NULL, FALSE, FALSE, NULL, NULL) );
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 cnf file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderCnf(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
SCIP_READER* reader;
/* create reader data */
readerdata = NULL;
/* 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, readerCopyCnf) );
SCIP_CALL( SCIPsetReaderRead(scip, reader, readerReadCnf) );
/* add cnf reader parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/cnfreader/dynamicconss", "should model constraints be subject to aging?",
NULL, FALSE, TRUE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/cnfreader/dynamiccols", "should columns be added and removed dynamically to the LP?",
NULL, FALSE, FALSE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/cnfreader/dynamicrows", "should rows be added and removed dynamically to the LP?",
NULL, FALSE, FALSE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/cnfreader/useobj", "should an artificial objective, depending on the number of clauses a variable appears in, be used?",
NULL, FALSE, FALSE, 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 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 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;
}
/** 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 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 oneopt primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurOneopt(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Oneopt 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, heurExecOneopt, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyOneopt) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeOneopt) );
SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolOneopt) );
SCIP_CALL( SCIPsetHeurExitsol(scip, heur, heurExitsolOneopt) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitOneopt) );
/* add oneopt primal heuristic parameters */
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/oneopt/weightedobj",
"should the objective be weighted with the potential shifting value when sorting the shifting candidates?",
&heurdata->weightedobj, TRUE, DEFAULT_WEIGHTEDOBJ, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/oneopt/duringroot",
"should the heuristic be called before and during the root node?",
&heurdata->duringroot, TRUE, DEFAULT_DURINGROOT, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/oneopt/forcelpconstruction",
"should the construction of the LP be forced even if LP solving is deactivated?",
&heurdata->forcelpconstruction, TRUE, DEFAULT_FORCELPCONSTRUCTION, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/oneopt/beforepresol",
"should the heuristic be called before presolving?",
&heurdata->beforepresol, TRUE, DEFAULT_BEFOREPRESOL, 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 indicator primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurIndicator(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Indicator primal heuristic data */
SCIP_CALL( SCIPallocMemory(scip, &heurdata) );
heurdata->nindconss = 0;
heurdata->indconss = NULL;
heurdata->solcand = NULL;
heurdata->lastsol = NULL;
heurdata->indicatorconshdlr = NULL;
/* 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, heurExecIndicator, heurdata) );
assert( heur != NULL );
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyIndicator) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitIndicator) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeIndicator) );
/* add parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/" HEUR_NAME "/oneopt",
"whether the one-opt heuristic should be started",
&heurdata->oneopt, TRUE, DEFAULT_ONEOPT, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/" HEUR_NAME "/improvesols",
"Try to improve other solutions by one-opt?",
&heurdata->improvesols, TRUE, DEFAULT_IMPROVESOLS, NULL, NULL) );
return SCIP_OKAY;
}
/** includes the ppm file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderPpm(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
SCIP_READER* reader;
/* create ppm reader data */
SCIP_CALL( SCIPallocMemory(scip, &readerdata) );
initReaderdata(readerdata);
/* include reader */
SCIP_CALL( SCIPincludeReaderBasic(scip, &reader, READER_NAME, READER_DESC, READER_EXTENSION, readerdata) );
assert(reader != NULL);
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetReaderCopy(scip, reader, readerCopyPpm) );
SCIP_CALL( SCIPsetReaderFree(scip, reader, readerFreePpm) );
SCIP_CALL( SCIPsetReaderWrite(scip, reader, readerWritePpm) );
/* add ppm reader parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/ppmreader/rgbrelativ", "should the coloring values be relativ or absolute",
&readerdata->rgb_relativ, FALSE, DEFAULT_PPM_RGB_RELATIVE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/ppmreader/rgbascii", "should the output format be binary(P6) (otherwise plain(P3) format)",
&readerdata->rgb_ascii, FALSE, DEFAULT_PPM_RGB_ASCII, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"reading/ppmreader/coefficientlimit",
"splitting coefficients in this number of intervals",
&readerdata->coef_limit, FALSE, DEFAULT_PPM_COEF_LIMIT, 3, 16, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"reading/ppmreader/rgblimit",
"maximal color value",
&readerdata->rgb_limit, FALSE, DEFAULT_PPM_RGB_LIMIT, 0, 255, 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;
}
/** creates the rand rounding heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurRandrounding(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create 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, heurExecRandrounding, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyRandrounding) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitRandrounding) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitRandrounding) );
SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolRandrounding) );
SCIP_CALL( SCIPsetHeurExitsol(scip, heur, heurExitsolRandrounding) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeRandrounding) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/" HEUR_NAME "/oncepernode",
"should the heuristic only be called once per node?",
&heurdata->oncepernode, TRUE, DEFAULT_ONCEPERNODE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/" HEUR_NAME "/usesimplerounding", "should the heuristic apply the variable lock strategy of simple rounding, if possible?",
&heurdata->usesimplerounding, TRUE, DEFAULT_USESIMPLEROUNDING, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/" HEUR_NAME "/propagateonlyroot",
"should the probing part of the heuristic be applied exclusively at the root node?",
&heurdata->propagateonlyroot, TRUE, DEFAULT_PROPAGATEONLYROOT, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/maxproprounds",
"limit of rounds for each propagation call",
&heurdata->maxproprounds, TRUE, DEFAULT_MAXPROPROUNDS,
-1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the boundshift presolver and includes it in SCIP */
SCIP_RETCODE SCIPincludePresolBoundshift(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_PRESOLDATA* presoldata;
SCIP_PRESOL* presolptr;
/* create boundshift presolver data */
SCIP_CALL( SCIPallocMemory(scip, &presoldata) );
initPresoldata(presoldata);
/* include presolver */
SCIP_CALL( SCIPincludePresolBasic(scip, &presolptr, PRESOL_NAME, PRESOL_DESC, PRESOL_PRIORITY, PRESOL_MAXROUNDS, PRESOL_DELAY,
presolExecBoundshift,
presoldata) );
assert(presolptr != NULL);
SCIP_CALL( SCIPsetPresolCopy(scip, presolptr, presolCopyBoundshift) );
SCIP_CALL( SCIPsetPresolFree(scip, presolptr, presolFreeBoundshift) );
/* add probing presolver parameters */
SCIP_CALL( SCIPaddLongintParam(scip,
"presolving/boundshift/maxshift",
"absolute value of maximum shift",
&presoldata->maxshift, TRUE, DEFAULT_MAXSHIFT, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"presolving/boundshift/flipping",
"is flipping allowed (multiplying with -1)?",
&presoldata->flipping, TRUE, DEFAULT_FLIPPING, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"presolving/boundshift/integer",
"shift only integer ranges?",
&presoldata->integer, TRUE, DEFAULT_INTEGER, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the zirounding primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurZirounding(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create zirounding 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, heurExecZirounding, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyZirounding) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeZirounding) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitZirounding) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitZirounding) );
SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolZirounding) );
/* add zirounding primal heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/zirounding/maxroundingloops",
"determines maximum number of rounding loops",
&heurdata->maxroundingloops, TRUE, DEFAULT_MAXROUNDINGLOOPS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/zirounding/stopziround",
"flag to determine if Zirounding is deactivated after a certain percentage of unsuccessful calls",
&heurdata->stopziround, TRUE, DEFAULT_STOPZIROUND, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,"heuristics/zirounding/stoppercentage",
"if percentage of found solutions falls below this parameter, Zirounding will be deactivated",
&heurdata->stoppercentage, TRUE, DEFAULT_STOPPERCENTAGE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/zirounding/minstopncalls",
"determines the minimum number of calls before percentage-based deactivation of Zirounding is applied",
&heurdata->minstopncalls, TRUE, DEFAULT_MINSTOPNCALLS, 1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the rounding heuristic with infeasibility recovering and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurRounding(
SCIP* scip /**< SCIP data structure */,
SCIP_HEUR** heu
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Rounding 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, heurExecRounding, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
/* SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyRounding) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeRounding) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitRounding) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitRounding) );
SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolRounding) );
SCIP_CALL( SCIPsetHeurExitsol(scip, heur, heurExitsolRounding) ); */
/* add rounding primal heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/""special_rounding""/successfactor",
"number of calls per found solution that are considered as standard success, a higher factor causes the heuristic to be called more often",
&heurdata->successfactor, TRUE, DEFAULT_SUCCESSFACTOR, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/""special_rounding""/oncepernode",
"should the heuristic only be called once per node?",
&heurdata->oncepernode, TRUE, DEFAULT_ONCEPERNODE, NULL, NULL) );
*heu = heur;
return SCIP_OKAY;
}
/** includes event handler for writing primal- and dualbound for all open nodes */
SCIP_RETCODE SCIPincludeEventHdlrBoundwriting(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_EVENTHDLRDATA* eventhdlrdata;
SCIP_EVENTHDLR* eventhdlr;
/* create bounds reader data */
SCIP_CALL( SCIPallocMemory(scip, &eventhdlrdata) );
initEventhdlrdata(eventhdlrdata);
eventhdlr = NULL;
/* create event handler for events on watched variables */
SCIP_CALL( SCIPincludeEventhdlrBasic(scip, &eventhdlr, EVENTHDLR_NAME, EVENTHDLR_DESC,
eventExecBoundwriting, eventhdlrdata) );
assert(eventhdlr != NULL);
SCIP_CALL( SCIPsetEventhdlrCopy(scip, eventhdlr, eventCopyBoundwriting) );
SCIP_CALL( SCIPsetEventhdlrFree(scip, eventhdlr, eventFreeBoundwriting) );
SCIP_CALL( SCIPsetEventhdlrInit(scip, eventhdlr, eventInitBoundwriting) );
SCIP_CALL( SCIPsetEventhdlrExit(scip, eventhdlr, eventExitBoundwriting) );
/* add boundwriting parameters */
SCIP_CALL( SCIPaddLongintParam(scip,
"eventhdlr/"EVENTHDLR_NAME"/freq",
"in which frequency should all bounds be written(0: never)",
&eventhdlrdata->freq, FALSE, DEFAULT_FREQ, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddStringParam(scip,
"eventhdlr/"EVENTHDLR_NAME"/filename",
"filename to write all bounds to",
&eventhdlrdata->filename, FALSE, DEFAULT_FILENAME, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"eventhdlr/"EVENTHDLR_NAME"/writesubmipdualbound",
"should the dualbound of the submip-root which was created out of an open node be printed",
&eventhdlrdata->writesubmipdualbound, FALSE, DEFAULT_WRITESUBMIPDUALBOUND, NULL, NULL) );
return SCIP_OKAY;
}
/** includes the sch file reader in SCIP */
SCIP_RETCODE SCIPincludeReaderSm(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_READERDATA* readerdata;
SCIP_READER* reader;
/* create sch reader data */
readerdata = NULL;
/* include sch reader */
SCIP_CALL( SCIPincludeReaderBasic(scip, &reader, READER_NAME, READER_DESC, READER_EXTENSION, readerdata) );
assert(reader != NULL);
SCIP_CALL( SCIPsetReaderCopy(scip, reader, readerCopySm) );
SCIP_CALL( SCIPsetReaderRead(scip, reader, readerReadSm) );
/* add reader parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"reading/"READER_NAME"/mipmodel", "create MIP model?",
NULL, FALSE, FALSE, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the crossover primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurCrossover(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Crossover 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, heurExecCrossover, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyCrossover) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeCrossover) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitCrossover) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitCrossover) );
/* add crossover primal heuristic parameters */
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"/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"/minnodes",
"minimum number of nodes required to start the subproblem",
&heurdata->minnodes, TRUE, DEFAULT_MINNODES, 0LL, SCIP_LONGINT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/nusedsols",
"number of solutions to be taken into account",
&heurdata->nusedsols, FALSE, DEFAULT_NUSEDSOLS, 2, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddLongintParam(scip, "heuristics/"HEUR_NAME"/nwaitingnodes",
"number of nodes without incumbent change that heuristic should wait",
&heurdata->nwaitingnodes, TRUE, DEFAULT_NWAITINGNODES, 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"/minfixingrate",
"minimum percentage of integer variables that have to be fixed",
&heurdata->minfixingrate, FALSE, DEFAULT_MINFIXINGRATE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minimprove",
"factor by which Crossover should at least improve the incumbent",
&heurdata->minimprove, TRUE, DEFAULT_MINIMPROVE, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/randomization",
"should the choice which sols to take be randomized?",
&heurdata->randomization, TRUE, DEFAULT_RANDOMIZATION, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/dontwaitatroot",
"should the nwaitingnodes parameter be ignored at the root node?",
&heurdata->dontwaitatroot, TRUE, DEFAULT_DONTWAITATROOT, 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) );
SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/"HEUR_NAME"/permute",
"should the subproblem be permuted to increase diversification?",
&heurdata->permute, TRUE, DEFAULT_PERMUTE, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the Gomory MIR cut separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaGomory(
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,
sepaExeclpGomory, NULL,
sepadata) );
assert(sepa != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyGomory) );
SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeGomory) );
/* add separator parameters */
SCIP_CALL( SCIPaddIntParam(scip,
"separating/gomory/maxrounds",
"maximal number of gomory separation rounds per node (-1: unlimited)",
&sepadata->maxrounds, FALSE, DEFAULT_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/gomory/maxroundsroot",
"maximal number of gomory separation rounds in the root node (-1: unlimited)",
&sepadata->maxroundsroot, FALSE, DEFAULT_MAXROUNDSROOT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/gomory/maxsepacuts",
"maximal number of gomory cuts separated per separation round",
&sepadata->maxsepacuts, FALSE, DEFAULT_MAXSEPACUTS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/gomory/maxsepacutsroot",
"maximal number of gomory cuts separated per separation round in the root node",
&sepadata->maxsepacutsroot, FALSE, DEFAULT_MAXSEPACUTSROOT, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"separating/gomory/away",
"minimal integrality violation of a basis variable in order to try Gomory cut",
&sepadata->away, FALSE, DEFAULT_AWAY, 0.0, 0.5, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"separating/gomory/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/gomory/dynamiccuts",
"should generated cuts be removed from the LP if they are no longer tight?",
&sepadata->dynamiccuts, FALSE, DEFAULT_DYNAMICCUTS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/gomory/makeintegral",
"try to scale cuts to integral coefficients",
&sepadata->makeintegral, TRUE, DEFAULT_MAKEINTEGRAL, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/gomory/forcecuts",
"if conversion to integral coefficients failed still use the cut",
&sepadata->forcecuts, TRUE, DEFAULT_FORCECUTS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/gomory/separaterows",
"separate rows with integral slack",
&sepadata->separaterows, TRUE, DEFAULT_SEPARATEROWS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/gomory/delayedcuts",
"should cuts be added to the delayed cut pool?",
&sepadata->delayedcuts, TRUE, DEFAULT_DELAYEDCUTS, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the rapidlearning separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaRapidlearning(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_SEPADATA* sepadata;
/* create rapidlearning separator data */
SCIP_CALL( SCIPallocMemory(scip, &sepadata) );
/* include separator */
SCIP_CALL( SCIPincludeSepa(scip, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST,
SEPA_USESSUBSCIP, SEPA_DELAY,
sepaCopyRapidlearning, sepaFreeRapidlearning, sepaInitRapidlearning, sepaExitRapidlearning,
sepaInitsolRapidlearning, sepaExitsolRapidlearning,
sepaExeclpRapidlearning, sepaExecsolRapidlearning,
sepadata) );
/* add rapidlearning separator parameters */
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/applyconflicts",
"should the found conflicts be applied in the original SCIP?",
&sepadata->applyconflicts, TRUE, DEFAULT_APPLYCONFLICTS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/applybdchgs",
"should the found global bound deductions be applied in the original SCIP?",
&sepadata->applybdchgs, TRUE, DEFAULT_APPLYBDCHGS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/applyinfervals",
"should the inference values be used as initialization in the original SCIP?",
&sepadata->applyinfervals, TRUE, DEFAULT_APPLYINFERVALS, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/reducedinfer",
"should the inference values only be used when "SEPA_NAME" found other reductions?",
&sepadata->reducedinfer, TRUE, DEFAULT_REDUCEDINFER, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/applyprimalsol",
"should the incumbent solution be copied to the original SCIP?",
&sepadata->applyprimalsol, TRUE, DEFAULT_APPLYPRIMALSOL, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/applysolved",
"should a solved status be copied to the original SCIP?",
&sepadata->applysolved, TRUE, DEFAULT_APPLYSOLVED, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/contvars",
"should rapid learning be applied when there are continuous variables?",
&sepadata->contvars, TRUE, DEFAULT_CONTVARS, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "separating/"SEPA_NAME"/contvarsquot",
"maximal portion of continuous variables to apply rapid learning",
&sepadata->contvarsquot, TRUE, DEFAULT_CONTVARSQUOT, 0.0, 1.0, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "separating/"SEPA_NAME"/lpiterquot",
"maximal fraction of LP iterations compared to node LP iterations",
&sepadata->lpiterquot, TRUE, DEFAULT_LPITERQUOT, 0.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/"SEPA_NAME"/maxnvars",
"maximum problem size (variables) for which rapid learning will be called",
&sepadata->maxnvars, TRUE, DEFAULT_MAXNVARS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/"SEPA_NAME"/maxnconss",
"maximum problem size (constraints) for which rapid learning will be called",
&sepadata->maxnconss, TRUE, DEFAULT_MAXNCONSS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/"SEPA_NAME"/maxnodes",
"maximum number of nodes considered in rapid learning run",
&sepadata->maxnodes, TRUE, DEFAULT_MAXNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/"SEPA_NAME"/minnodes",
"minimum number of nodes considered in rapid learning run",
&sepadata->minnodes, TRUE, DEFAULT_MINNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/copycuts",
"should all active cuts from cutpool be copied to constraints in subproblem?",
&sepadata->copycuts, TRUE, DEFAULT_COPYCUTS, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the disjunctive cut separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaDisjunctive(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_SEPADATA* sepadata = NULL;
SCIP_SEPA* sepa = NULL;
/* create separator data */
SCIP_CALL( SCIPallocMemory(scip, &sepadata) );
sepadata->conshdlr = NULL;
sepadata->lastncutsfound = 0;
/* include separator */
SCIP_CALL( SCIPincludeSepaBasic(scip, &sepa, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST,
SEPA_USESSUBSCIP, SEPA_DELAY, sepaExeclpDisjunctive, NULL, sepadata) );
assert( sepa != NULL );
/* set non fundamental callbacks via setter functions */
SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyDisjunctive) );
SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeDisjunctive) );
SCIP_CALL( SCIPsetSepaInitsol(scip, sepa, sepaInitsolDisjunctive) );
/* add separator parameters */
SCIP_CALL( SCIPaddBoolParam(scip, "separating/"SEPA_NAME"/strengthen",
"strengthen cut if integer variables are present.",
&sepadata->strengthen, TRUE, DEFAULT_STRENGTHEN, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxdepth",
"node depth of separating bipartite disjunctive cuts (-1: no limit)",
&sepadata->maxdepth, TRUE, DEFAULT_MAXDEPTH, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxrounds",
"maximal number of separation rounds per iteration in a branching node (-1: no limit)",
&sepadata->maxrounds, TRUE, DEFAULT_MAXROUNDS, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxroundsroot",
"maximal number of separation rounds in the root node (-1: no limit)",
&sepadata->maxroundsroot, TRUE, DEFAULT_MAXROUNDSROOT, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxinvcuts",
"maximal number of cuts investigated per iteration in a branching node",
&sepadata->maxinvcuts, TRUE, DEFAULT_MAXINVCUTS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxinvcutsroot",
"maximal number of cuts investigated per iteration in the root node",
&sepadata->maxinvcutsroot, TRUE, DEFAULT_MAXINVCUTSROOT, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxconfsdelay",
"delay separation if number of conflict graph edges is larger than predefined value (-1: no limit)",
&sepadata->maxconfsdelay, TRUE, DEFAULT_MAXCONFSDELAY, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxrank",
"maximal rank of a disj. cut that could not be scaled to integral coefficients (-1: unlimited)",
&sepadata->maxrank, FALSE, DEFAULT_MAXRANK, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "separating/" SEPA_NAME "/maxrankintegral",
"maximal rank of a disj. cut that could be scaled to integral coefficients (-1: unlimited)",
&sepadata->maxrankintegral, FALSE, DEFAULT_MAXRANKINTEGRAL, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "separating/" SEPA_NAME "/maxweightrange",
"maximal valid range max(|weights|)/min(|weights|) of row weights",
&sepadata->maxweightrange, TRUE, DEFAULT_MAXWEIGHTRANGE, 1.0, SCIP_REAL_MAX, NULL, NULL) );
return SCIP_OKAY;
}
static
SCIP_RETCODE run(
const char* nlfile, /**< name of AMPL .nl file */
const char* setfile, /**< SCIP settings file, or NULL to try default scip.set */
SCIP_Bool interactive /**< whether to start SCIP interactive shell instead of solving command */
)
{
SCIP* scip;
char buffer[SCIP_MAXSTRLEN];
SCIP_Bool printstat;
assert(nlfile != NULL);
/* setup SCIP and print version information */
SCIP_CALL( SCIPcreate(&scip) );
SCIPprintVersion(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
SCIP_CALL( SCIPincludeReaderNl(scip) );
SCIP_CALL( SCIPaddBoolParam(scip, "display/statistics",
"whether to print statistics on a solve",
NULL, FALSE, FALSE, NULL, NULL) );
SCIPprintExternalCodes(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
/* read setting file */
if( setfile != NULL )
{
SCIP_CALL( SCIPreadParams(scip, setfile) );
}
SCIP_CALL( SCIPgetBoolParam(scip, "display/statistics", &printstat) );
/* setup commands to be executed by SCIP */
SCIP_CALL( SCIPaddDialogInputLine(scip, "display param") );
/* add .nl extension, if not given */
(void) SCIPsnprintf(buffer, SCIP_MAXSTRLEN, "read %s%s", nlfile, (strlen(nlfile) < 3 || strcmp(nlfile+(strlen(nlfile)-3), ".nl") != 0) ? ".nl" : "");
SCIP_CALL( SCIPaddDialogInputLine(scip, buffer) );
if( !interactive )
{
/* SCIP_CALL( SCIPaddDialogInputLine(scip, "display problem") ); */
SCIP_CALL( SCIPaddDialogInputLine(scip, "optimize") );
SCIP_CALL( SCIPaddDialogInputLine(scip, "write amplsol") );
if( printstat )
{
SCIP_CALL( SCIPaddDialogInputLine(scip, "display statistics") );
}
SCIP_CALL( SCIPaddDialogInputLine(scip, "quit") );
}
/* run SCIP */
SCIP_CALL( SCIPstartInteraction(scip) );
SCIP_CALL( SCIPfree(&scip) );
return SCIP_OKAY;
}
/** creates the closecuts separator and includes it in SCIP */
SCIP_RETCODE SCIPincludeSepaClosecuts(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_SEPADATA* sepadata;
/* create closecuts separator data */
SCIP_CALL( SCIPallocMemory(scip, &sepadata) );
sepadata->sepasol = NULL;
sepadata->discardnode = -1;
sepadata->nunsuccessful = 0;
/* include separator */
SCIP_CALL( SCIPincludeSepa(scip, SEPA_NAME, SEPA_DESC, SEPA_PRIORITY, SEPA_FREQ, SEPA_MAXBOUNDDIST, SEPA_USESSUBSCIP, SEPA_DELAY,
sepaCopyClosecuts, sepaFreeClosecuts, sepaInitClosecuts, sepaExitClosecuts,
sepaInitsolClosecuts, sepaExitsolClosecuts, sepaExeclpClosecuts, sepaExecsolClosecuts,
sepadata) );
/* add closecuts separator parameters */
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/closecuts/separelint",
"generate close cuts w.r.t. relative interior point (best solution otherwise)?",
&sepadata->separelint, TRUE, SCIP_DEFAULT_SEPARELINT, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip,
"separating/closecuts/sepacombvalue",
"convex combination value for close cuts",
&sepadata->sepacombvalue, TRUE, SCIP_DEFAULT_SEPACOMBVALUE, 0.0, 1.0,
NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/closecuts/separootonly",
"generate close cuts in the root only?",
&sepadata->separootonly, TRUE, SCIP_DEFAULT_SEPAROOTONLY, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/closecuts/closethres",
"threshold on number of generated cuts below which the ordinary separation is started",
&sepadata->sepathreshold, TRUE, SCIP_DEFAULT_SEPATHRESHOLD, -1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/closecuts/inclobjcutoff",
"include an objective cutoff when computing the relative interior?",
&sepadata->inclobjcutoff, TRUE, SCIP_DEFAULT_INCLOBJCUTOFF, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"separating/closecuts/recomputerelint",
"recompute relative interior point in each separation call?",
&sepadata->recomputerelint, TRUE, SCIP_DEFAULT_RECOMPUTERELINT, NULL, NULL) );
SCIP_CALL( SCIPaddCharParam(scip,
"separating/closecuts/relintnormtype",
"type of norm to use when computing relative interior: 'o'ne norm, 's'upremum norm",
&sepadata->relintnormtype, TRUE, SCIP_DEFAULT_RELINTNORMTYPE, "os", NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"separating/closecuts/maxunsuccessful",
"turn off separation in current node after unsuccessful calls (-1 never turn off)",
&sepadata->maxunsuccessful, TRUE, SCIP_DEFAULT_MAXUNSUCCESSFUL, -1, INT_MAX, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the mutation primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurMutation(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Mutation 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, heurExecMutation, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyMutation) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeMutation) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitMutation) );
/* add mutation primal heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/nodesofs",
"number of nodes added to the contingent of the total nodes",
&heurdata->nodesofs, FALSE, DEFAULT_NODESOFS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/maxnodes",
"maximum number of nodes to regard in the subproblem",
&heurdata->maxnodes, TRUE, DEFAULT_MAXNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/minnodes",
"minimum number of nodes required to start the subproblem",
&heurdata->minnodes, TRUE, DEFAULT_MINNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/nwaitingnodes",
"number of nodes without incumbent change that heuristic should wait",
&heurdata->nwaitingnodes, TRUE, DEFAULT_NWAITINGNODES, 0, INT_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"/minfixingrate",
"percentage of integer variables that have to be fixed",
&heurdata->minfixingrate, FALSE, DEFAULT_MINFIXINGRATE, SCIPsumepsilon(scip), 1.0-SCIPsumepsilon(scip), NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minimprove",
"factor by which "HEUR_NAME" should at least improve the incumbent",
&heurdata->minimprove, TRUE, DEFAULT_MINIMPROVE, 0.0, 1.0, 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;
}
SCIP_RETCODE GamsScip::setupSCIP()
{
/*
#ifdef COIN_HAS_OSICPX
// change default LP solver to CPLEX, if license available
if( gmo != NULL && checkCplexLicense(gmo, pal) )
{
SCIP_CALL( SCIPlpiSwitchSetSolver(SCIP_LPISW_CPLEX) );
}
#endif
*/
if( scip == NULL )
{
// if called first time, create a new SCIP instance and include all plugins that we need and setup interface parameters
SCIP_MESSAGEHDLR* messagehdlr;
SCIP_NLPI* nlpiipopt;
SCIP_CALL( SCIPcreate(&scip) );
// create and install our message handler
SCIP_CALL( SCIPmessagehdlrCreate(&messagehdlr, FALSE, NULL, FALSE,
GamsScipPrintLogStat, GamsScipPrintLog, GamsScipPrintLog, NULL,
(SCIP_MESSAGEHDLRDATA*)gev) );
SCIP_CALL( SCIPsetMessagehdlr(scip, messagehdlr) );
SCIP_CALL( SCIPmessagehdlrRelease(&messagehdlr) );
SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
SCIP_CALL( SCIPincludeReaderGmo(scip) );
SCIP_CALL( SCIPincludeEventHdlrSolveTrace(scip, gmo) );
/* SCIP_CALL( SCIPincludePropDefaultBounds(scip) ); */
if( ipoptlicensed )
{
nlpiipopt = SCIPfindNlpi(scip, "ipopt");
if( nlpiipopt != NULL )
{
SCIPsetModifiedDefaultSettingsIpopt(nlpiipopt, "linear_solver ma27\nlinear_system_scaling mc19\n");
SCIP_CALL( SCIPincludeExternalCodeInformation(scip, "HSL MA27 and MC19", "Harwell Subroutine Libraries (www.hsl.rl.ac.uk) from commercially supported Ipopt") );
}
}
/*
else
{
nlpiipopt = SCIPfindNlpi(scip, "ipopt");
if( nlpiipopt != NULL )
{
SCIPsetModifiedDefaultSettingsIpopt(nlpiipopt, "linear_solver mumps\n");
}
}
*/
/* SCIP_CALL( SCIPaddBoolParam(scip, "gams/solvefinal",
* "whether the problem should be solved with fixed discrete variables to get dual values",
* NULL, FALSE, TRUE, NULL, NULL) );
*/
SCIP_CALL( SCIPaddBoolParam(scip, "display/statistics",
"whether to print statistics on a solve",
NULL, FALSE, FALSE, NULL, NULL) );
SCIP_CALL( SCIPaddStringParam(scip, "gams/interactive",
"command to be issued to the SCIP shell instead of issuing a solve command",
NULL, FALSE, "", NULL, NULL) );
#if 0
SCIP_CALL( SCIPaddStringParam(scip, "constraints/attrfile",
"name of file that specifies constraint attributes",
NULL, FALSE, "", NULL, NULL) );
#endif
/*
SCIP_CALL( SCIPaddStringParam(scip, "lp/solver",
"LP solver to use (clp, cplex, mosek, soplex, gurobi, xpress)",
NULL, FALSE, SCIP_LPISW_SOLVERNAMES[SCIPlpiSwitchGetCurrentSolver()], GamsScipParamChgdLpSolver, NULL) );
*/
}
else
{
// if called before, only clear up problem and reset parameters
SCIP_CALL( SCIPfreeProb(scip) );
SCIP_CALL( SCIPresetParams(scip) );
}
/** pass current GMO into GMO reader, so it does not read instance from file */
SCIPsetGMOReaderGmo(scip, gmo);
return SCIP_OKAY;
}
/** creates the octane primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurOctane(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Octane 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, heurExecOctane, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyOctane) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeOctane) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitOctane) );
SCIP_CALL( SCIPsetHeurExit(scip, heur, heurExitOctane) );
/* add octane primal heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/octane/fmax",
"number of 0-1-points to be tested as possible solutions by OCTANE",
&heurdata->f_max, TRUE, DEFAULT_FMAX, 1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip,
"heuristics/octane/ffirst",
"number of 0-1-points to be tested at first whether they violate a common row",
&heurdata->f_first, TRUE, DEFAULT_FFIRST, 1, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/usefracspace",
"execute OCTANE only in the space of fractional variables (TRUE) or in the full space?",
&heurdata->usefracspace, TRUE, DEFAULT_USEFRACSPACE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/useobjray",
"should the inner normal of the objective be used as one ray direction?",
&heurdata->useobjray, TRUE, TRUE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/useavgray",
"should the average of the basic cone be used as one ray direction?",
&heurdata->useavgray, TRUE, TRUE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/usediffray",
"should the difference between the root solution and the current LP solution be used as one ray direction?",
&heurdata->usediffray, TRUE, FALSE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/useavgwgtray",
"should the weighted average of the basic cone be used as one ray direction?",
&heurdata->useavgwgtray, TRUE, TRUE, NULL, NULL) );
SCIP_CALL( SCIPaddBoolParam(scip,
"heuristics/octane/useavgnbray",
"should the weighted average of the nonbasic cone be used as one ray direction?",
&heurdata->useavgnbray, TRUE, TRUE, NULL, NULL) );
return SCIP_OKAY;
}
/** creates the localbranching primal heuristic and includes it in SCIP */
SCIP_RETCODE SCIPincludeHeurLocalbranching(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_HEURDATA* heurdata;
SCIP_HEUR* heur;
/* create Localbranching 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, heurExecLocalbranching, heurdata) );
assert(heur != NULL);
/* set non-NULL pointers to callback methods */
SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyLocalbranching) );
SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeLocalbranching) );
SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitLocalbranching) );
/* add localbranching primal heuristic parameters */
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/nodesofs",
"number of nodes added to the contingent of the total nodes",
&heurdata->nodesofs, FALSE, DEFAULT_NODESOFS, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/neighborhoodsize",
"radius (using Manhattan metric) of the incumbent's neighborhood to be searched",
&heurdata->neighborhoodsize, FALSE, DEFAULT_NEIGHBORHOODSIZE, 1, INT_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"/lplimfac",
"factor by which the limit on the number of LP depends on the node limit",
&heurdata->lplimfac, TRUE, DEFAULT_LPLIMFAC, 1.0, SCIP_REAL_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/minnodes",
"minimum number of nodes required to start the subproblem",
&heurdata->minnodes, TRUE, DEFAULT_MINNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/maxnodes",
"maximum number of nodes to regard in the subproblem",
&heurdata->maxnodes, TRUE, DEFAULT_MAXNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddIntParam(scip, "heuristics/"HEUR_NAME"/nwaitingnodes",
"number of nodes without incumbent change that heuristic should wait",
&heurdata->nwaitingnodes, TRUE, DEFAULT_NWAITINGNODES, 0, INT_MAX, NULL, NULL) );
SCIP_CALL( SCIPaddRealParam(scip, "heuristics/"HEUR_NAME"/minimprove",
"factor by which localbranching should at least improve the incumbent",
&heurdata->minimprove, TRUE, DEFAULT_MINIMPROVE, 0.0, 1.0, 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;
}
