void BasicOptions::initOptions(ProgramOptions::OptionGroup& root) {
OptionGroup basic("Basic Options");
basic.addOptions()
("stats" , storeTo(stats)->parser(&BasicOptions::mapStats)->setImplicit(),"Print extended statistics")
("quiet,q", bool_switch(&quiet), "Do not print models")
("asp09" , bool_switch(&asp09), "Write output in ASP Competition'09 format")
("time-limit" , storeTo(timeout), "Set time limit to <n> seconds", "<n>")
;
root.addOptions(basic, true);
}
void ImgInputConfig::initBoostOptions() {
options.add_options()
(key("file"), value(&file)->default_value(file),
"Image to process")
(key("roi"), value(&roi)->default_value(roi),
"apply ROI (x:y:w:h)")
#ifdef WITH_GERBIL_COMMON
(key("gradient"), bool_switch(&gradient)->default_value(gradient),
"compute spectral gradient")
(key("bands"), value(&bands)->default_value(bands),
"reduce number of bands by linear interpolation (0 means disabled)")
(key("bandlow"), value(&bandlow)->default_value(bandlow),
"apply lower bound of band ROI")
(key("bandhigh"), value(&bandhigh)->default_value(bandhigh),
"apply upper bound of band ROI")
#endif
;
}
void SimilarityMeasureConfig::initBoostOptions() {
options.add_options()
// global section
(key("graphical"), bool_switch(&isGraphical)->default_value(false),
"Show graphical output during runtime")
(key("metrics,M"), value(&selected_metrics)->default_value("ms"),
"\",\"-separated list of metrics to use for the template matching, possible values are ms,mrsd,ncc,cch,nmi,msh,mih,emd,gd.")
;
if (prefix_enabled)
return;
options.add_options()
(key("input1,I"), value(&input_file1)->default_value(""), "Input data file")
(key("input2,J"), value(&input_file2)->default_value(""), "Input data file 2")
(key("win1,W"), value(&win1)->default_value(""),
"\",\"-separated list of coordinates of window1. win1 and win2 must have the same size")
(key("win2,X"), value(&win2)->default_value(""),
"\",\"-separated list of coordinates of window2. win1 and win2 must have the same size")
(key("output,O"), value(&output_directory)->default_value("/tmp/"), "Output directory")
;
}
/////////////////////////////////////////////////////////////////////////////////////////
// Clasp specific search options
/////////////////////////////////////////////////////////////////////////////////////////
void SearchOptions::initOptions(ProgramOptions::OptionGroup& root, ProgramOptions::OptionGroup& hidden) {
OptionGroup search("Clasp - Search Options");
search.addOptions()
/*("lookahead" , storeTo(config->heuristic.lookahead)->setImplicit(),
"Configure failed-literal detection (fld)\n"
" Default: no (atom, if --nolookback)\n"
" Valid: atom, body, hybrid, no\n"
" atom : Apply failed-literal detection to atoms\n"
" body : Apply failed-literal detection to bodies\n"
" hybrid: Apply Nomore++-like failed-literal detection\n"
" no : Do not apply failed-literal detection", "<arg>")*/
("initial-lookahead", storeTo(config->heuristic.lookaheadNum), "Restrict fld to <n> decisions\n", "<n>")
("heuristic", storeTo(config->heuristic.heuristic)->parser(SearchOptions::mapHeuristic),
"Configure decision heuristic\n"
" Default: Berkmin (Unit, if --no-lookback)\n"
" Valid: Berkmin, Vmtf, Vsids, Unit, None\n"
" Berkmin: Apply BerkMin-like heuristic\n"
" Vmtf : Apply Siege-like heuristic\n"
" Vsids : Apply Chaff-like heuristic\n"
" Unit : Apply Smodels-like heuristic\n"
" None : Select the first free variable")
("rand-freq", storeTo(parseSolve)->parser(&SolveOptionsWrapper::mapRandFreq),
"Make random decisions with probability <p>\n"
" Default: 0.0\n"
" Valid: [0.0...1.0]\n", "<p>")
("rand-prob", storeTo(parseSolve)->parser(&SolveOptionsWrapper::mapRandProb)->setImplicit(),
"Configure random probing\n"
" Default: no\n"
" Valid: yes, no, <n1,n2> (<n1> >= 0, <n2> > 0)\n"
" yes : Run 50 random passes up to at most 20 conflicts each\n"
" no : Do not run random probing\n"
" <n1,n2>: Run <n1> random passes up to at most <n2> conflicts each\n", "<opts>")
("rand-watches", bool_switch()->defaultValue(true),
"Configure watched literal initialization\n"
" Default: yes\n"
" Valid: yes, no\n"
" yes: Randomly determine watched literals\n"
" no : Watch first and last literal in a nogood\n")
;
OptionGroup lookback("Clasp - Lookback Options");
lookback.addOptions()
//("no-lookback" ,bool_switch(), "Disable all lookback strategies\n")
("restarts,r", storeTo(parseSolve)->parser(&SolveOptionsWrapper::mapRestarts),
"Configure restart policy\n"
" Default: 100,1.5\n"
" Valid: <n1[,n2,n3]> (<n1> >= 0, <n2>,<n3> > 0), no\n"
" <n1> : Run Luby et al.'s sequence with unit length <n1>\n"
" <n1>,<n2> : Run geometric sequence of <n1>*(<n2>^i) conflicts\n"
" <n1>,<n2>,<n3>: Run Biere's inner-outer geometric sequence (<n3>=outer)\n"
" <n1> = 0, no : Disable restarts")
("local-restarts" , bool_switch(&config->solve.restart.local), "Enable Ryvchin et al.'s local restarts")
("bounded-restarts", bool_switch(&config->solve.restart.bounded), "Enable (bounded) restarts during model enumeration")
("reset-restarts", bool_switch(&config->solve.restart.resetOnModel), "Reset restart strategy during model enumeration")
("save-progress" , storeTo(solverOpts)->setImplicit()->parser(&SolverStrategiesWrapper::mapSaveProg), "Enable RSat-like progress saving on backjumps > <n>\n", "<n>")
("shuffle,s", storeTo(parseSolve)->parser(&SolveOptionsWrapper::mapShuffle),
"Configure shuffling after restarts\n"
" Default: 0,0\n"
" Valid: <n1,n2> (<n1> >= 0, <n2> >= 0)\n"
" <n1> > 0: Shuffle problem after <n1> and re-shuffle every <n2> restarts\n"
" <n1> = 0: Do not shuffle problem after restarts\n"
" <n2> = 0: Do not re-shuffle problem\n", "<n1,n2>")
("deletion,d", storeTo(parseSolve)->parser(&SolveOptionsWrapper::mapReduce),
"Configure size of learnt nogood database\n"
" Default: 3.0,1.1,3.0\n"
" Valid: <n1[,n2,n3]> (<n3> >= <n1> >= 0, <n2> >= 1.0), no\n"
" <n1,n2,n3>: Store at most min(P/<n1>*(<n2>^i),P*<n3>) learnt nogoods,\n"
" P and i being initial problem size and number of restarts\n"
" no : Do not delete learnt nogoods")
("reduce-on-restart", bool_switch(&config->solve.reduce.reduceOnRestart), "Delete some learnt nogoods after every restart\n")
("estimate", bool_switch(&config->solve.reduce.estimate), "Use estimated problem complexity to init learnt db\n")
("strengthen", storeTo(solverOpts)->parser(&SolverStrategiesWrapper::mapStrengthen),
"Configure conflict nogood strengthening\n"
" Default: all\n"
" Valid: bin, tern, all, no\n"
" bin : Check only binary antecedents for self-subsumption\n"
" tern: Check binary and ternary antecedents for self-subsumption\n"
" all : Check all antecedents for self-subsumption\n"
" no : Do not check antecedents for self-subsumption")
("recursive-str", bool_switch(&solverOpts.opts->strengthenRecursive), "Enable MiniSAT-like conflict nogood strengthening\n")
("loops", storeTo(config->api.loopRep),
"Configure representation and learning of loop formulas\n"
" Default: common\n"
" Valid: common, distinct, shared, no\n"
" common : Create loop nogoods for atoms in an unfounded set\n"
" distinct: Create distinct loop nogood for each atom in an unfounded set\n"
" shared : Create loop formula for a whole unfounded set\n"
" no : Do not learn loop formulas\n")
("contraction", storeTo(solverOpts)->parser(&SolverStrategiesWrapper::mapContract),
"Configure (temporary) contraction of learnt nogoods\n"
" Default: 250\n"
" Valid:\n"
" 0 : Do not contract learnt nogoods\n"
" > 0: Contract learnt nogoods containing more than <num> literals\n", "<num>")
;
hidden.addOptions()
("loops-in-heu", storeTo(config->heuristic.loops), "Consider loop nogoods in heuristic")
("berk-max", storeTo(config->heuristic.extra.berkMax), "Consider at most <n> nogoods in Berkmin")
("berk-moms", bool_switch(&config->heuristic.berkMoms), "Enable/Disable MOMs in Berkmin")
("berk-huang",bool_switch(&config->heuristic.berkHuang), "Enable/Disable Huang-scoring in Berkmin")
("vmtf-mtf",storeTo(config->heuristic.extra.vmtfMtf), "In Vmtf move up to <n> conflict-literals to the front")
("nant",bool_switch(&config->heuristic.nant), "In Unit count only atoms in NAnt(P)")
;
root.addOptions(search);
root.addOptions(lookback);
}
/////////////////////////////////////////////////////////////////////////////////////////
// Clasp specific mode options
/////////////////////////////////////////////////////////////////////////////////////////
void GeneralOptions::initOptions(ProgramOptions::OptionGroup& root, ProgramOptions::OptionGroup& hidden) {
OptionGroup general("Clasp - General Options");
general.addOptions()
("number,n", storeTo(config->enumerate.numModels),
"Enumerate at most <num> models (0 for all)\n"
" Default: 1 (0 when optimizing/computing consequences)", "<num>")
("seed" , value<int>()->parser(mapSeed), "Set random number generator's seed to <num>\n", "<num>")
("solution-recording", bool_switch(&config->enumerate.record), "Add conflicts for computed models")
("restart-on-model", bool_switch(&config->enumerate.restartOnModel), "Restart (instead of backtrack) after each model")
//("project", bool_switch(&config->enumerate.project), "Project models to named atoms in enumeration mode\n")
//("brave" , bool_switch(&config->enumerate.brave), "Compute brave consequences")
//("cautious" , bool_switch(&config->enumerate.cautious), "Compute cautious consequences\n")
("pre" , bool_switch(&config->onlyPre), "Run ASP preprocessor and exit")
("search-limit", value<std::pair<int, int> >(), "Terminate search after <n> conflicts or <m> restarts\n", "<n,m>")
("opt-all" , bool_switch(&config->enumerate.opt.all), "Compute all optimal models")
("opt-ignore" , bool_switch(&config->enumerate.opt.no), "Ignore minimize statements")
("opt-heu" , bool_switch(&config->enumerate.opt.heu), "Consider minimize statements in heuristics")
("opt-value" , value<vector<int> >(),
"Initialize objective function(s)\n"
" Valid: <n1[,n2,n3,...]>\n")
("supp-models",bool_switch(&config->api.supported), "Compute supported models (disable unfounded set check)\n")
("trans-ext", storeTo(config->api.transExt),
"Configure handling of Lparse-like extended rules\n"
" Default: no\n"
" Valid: all, choice, card, weight, integ, dynamic, no\n"
" all : Transform all extended rules to basic rules\n"
" choice : Transform choice rules, but keep cardinality and weight rules\n"
" card : Transform cardinality rules, but keep choice and weight rules\n"
" weight : Transform cardinality and weight rules, but keep choice rules\n"
" integ : Transform cardinality integrity constraints\n"
" dynamic: Transform \"simple\" extended rules, but keep more complex ones\n"
" no : Do not transform extended rules\n")
("eq", storeTo(config->api.eq),
"Configure equivalence preprocessing\n"
" Default: 5\n"
" Valid:\n"
" -1 : Run to fixpoint\n"
" 0 : Do not run equivalence preprocessing\n"
" > 0: Run for at most <n> iterations", "<n>")
("backprop",bool_switch(&config->api.backprop), "Enable backpropagation in ASP-preprocessing\n")
("sat-prepro", storeTo(solverOpts)->parser(&Strategies::mapSatElite)->setImplicit(),
"Configure SatELite-like preprocessing\n"
" Default: no\n"
" Valid: yes, no, <n1[,n2,n3]>\n"
" <n1>: Run for at most <n1> iterations (-1=run to fixpoint)\n"
" <n2>: Run variable elimination with cutoff <n2> (-1=no cutoff)\n"
" <n3>: Run for at most <n3> seconds (-1=no time limit)\n"
" yes : Run to fixpoint, no cutoff and no time limit\n","<opts>")
;
root.addOptions(general);
hidden.addOptions()
("project-opt", storeTo(config->enumerate.projectOpts), "Additional options for projection as octal digit\n")
;
}
