/** 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; }