ArgumentHandlers contains functionality for parsing and handling command-line arguments. More...

Classes
struct	Arguments
	Arguments contains all defined parameters to be set on the command line. More...

Enumerations
enum	MMDP_method { ValueIteration, PolicyIteration, PolicyIterationGPU }

Functions
error_t	bgsolver_parse_argument (int key, char arg, struct argp_state state)

error_t	BnB_parse_argument (int key, char arg, struct argp_state state)

error_t	BNB_parse_argument (int key, char arg, struct argp_state state)

error_t	CE_parse_argument (int key, char arg, struct argp_state state)

error_t	eventPomdp_parse_argument (int key, char arg, struct argp_state state)

error_t	factoredQheur_parse_argument (int key, char arg, struct argp_state state)

error_t	globalOptions_parse_argument (int key, char arg, struct argp_state state)

error_t	gmaa_cluster_parse_argument (int key, char arg, struct argp_state state)

error_t	gmaa_parse_argument (int key, char arg, struct argp_state state)

error_t	JESP_parse_argument (int key, char arg, struct argp_state state)

error_t	jpolIndex_parse_argument (int key, char arg, struct argp_state state)

error_t	MaxPlus_parse_argument (int key, char arg, struct argp_state state)

error_t	mmdp_method_parse_argument (int key, char arg, struct argp_state state)

error_t	modelOptions_parse_argument (int key, char arg, struct argp_state state)

error_t	onlinePOMDP_parse_argument (int key, char arg, struct argp_state state)

error_t	outputFileOptions_parse_argument (int key, char arg, struct argp_state state)

static error_t	parse_main (int key, char arg, struct argp_state state)

error_t	perseus_parse_argument (int key, char arg, struct argp_state state)

error_t	perseusbackup_parse_argument (int key, char arg, struct argp_state state)

error_t	perseusbelief_parse_argument (int key, char arg, struct argp_state state)

error_t	problemFile_parse_argument (int key, char arg, struct argp_state state)

error_t	qheur_parse_argument (int key, char arg, struct argp_state state)

error_t	RL_parse_argument (int key, char arg, struct argp_state state)

error_t	simulation_parse_argument (int key, char arg, struct argp_state state)

template<typename T , unsigned N>
unsigned	size (T(&array)[N])

error_t	solutionMethodOptions_parse_argument (int key, char arg, struct argp_state state)

error_t	toi_parse_argument (int key, char arg, struct argp_state state)

error_t	toicentralized_parse_argument (int key, char arg, struct argp_state state)

Variables
static const int	ACCELERATEDPRUNINGTHRESHOLD = 4

static const int	AM_RESTARTS =1

const char *	argp_program_bug_address

static struct argp	bgsolver_argp = { bgsolver_options, bgsolver_parse_argument, bgsolver_args_doc, bgsolver_doc }

const char *	bgsolver_argp_version = "BGSOLVER options parser 0.1"

static const char *	bgsolver_args_doc = 0

const struct argp_child	bgsolver_child = {&bgsolver_argp, 0, "BGIP Solver options", GID_PROBLEMFILE}

static const char *	bgsolver_doc

static struct argp_option	bgsolver_options []

static struct argp	BnB_argp

const char *	BNB_argp_version = "BNB options parser 0.1"

static const char *	BNB_args_doc = 0

const struct argp_child	BnB_child = {&BnB_argp, 0, "BNB options", GID_BNB}

static const char *	BNB_doc

const int	BNB_KEEPALL = 1

static struct argp_option	BNB_options []

const int	BNB_RECOMPUTE = 3

const int	BNB_TYPE = 2

static struct argp	CE_argp

const char *	CE_argp_version = "CE options parser 0.1"

static const char *	CE_args_doc = 0

const struct argp_child	CE_child = {&CE_argp, 0, "CE options", GID_CE}

static const char *	CE_doc

static const int	CE_EVALUATION_RUNS = 2

static struct argp_option	CE_options []

static const int	CE_RESTARTS = 1

static struct argp	eventPomdp_argp

const char *	eventPomdp_argp_version = "Event-Driven POMDP options parser 0.1"

static const char *	eventPomdp_args_doc = 0

const struct argp_child	eventPomdp_child

static const char *	eventPomdp_doc

static struct argp_option	eventPomdp_options []

const struct argp_child	factoredQheur_child

static const int	GID_BGSOLVER =GID_SM

static const int	GID_BNB =GID_SM

static const int	GID_CE =GID_SM

static const int	GID_EVENTPOMDP =GID_SM

static const int	GID_GLOBALOPTIONS =8

static const int	GID_GMAA =GID_SM

static const int	GID_GMAA_CLUSTER =GID_SM

static const int	GID_INPUTARG =1

static const int	GID_JESP =GID_SM

static const int	GID_JPOLINDEX =GID_INPUTARG

static const int	GID_MaxPlus =GID_SM

static const int	GID_MMDP_METHOD =88

static const int	GID_MODELOPTIONS =3

static const int	GID_onlinePOMDP =GID_SM

static const int	GID_OUTPUTFILEOPTIONS =6

static const int	GID_PERSEUS =GID_SM

static const int	GID_PERSEUSBACKUP =GID_SM

static const int	GID_PERSEUSBELIEF =GID_SM

static const int	GID_PROBLEMFILE =GID_INPUTARG

static const int	GID_QHEUR =GID_SM

static const int	GID_RL =GID_SM

static const int	GID_SIMULATION =7

static const int	GID_SM =2

static struct argp	globalOptions_argp = { globalOptions_options, globalOptions_parse_argument, globalOptions_args_doc, globalOptions_doc }

const char *	globalOptions_argp_version = "global options parser 0.1"

static const char *	globalOptions_args_doc = 0

const struct argp_child	globalOptions_child = {&globalOptions_argp, 0, "General options", GID_GLOBALOPTIONS}

static const char *	globalOptions_doc

static struct argp_option	globalOptions_options []

static struct argp	gmaa_argp

const char *	gmaa_argp_version = "GMAA options parser 0.1"

static const char *	gmaa_args_doc = 0

const struct argp_child	gmaa_child = {&gmaa_argp, 0, "GMAA options", GID_GMAA}

static struct argp	gmaa_cluster_argp

const char *	gmaa_cluster_argp_version = "GMAA Cluster options parser 0.1"

static const char *	gmaa_cluster_args_doc = 0

const struct argp_child	gmaa_cluster_child = {&gmaa_cluster_argp, 0, "GMAA Cluster options", GID_GMAA_CLUSTER}

static const char *	gmaa_cluster_doc

static struct argp_option	gmaa_cluster_options []

static const char *	gmaa_doc

static struct argp_option	gmaa_options []

static struct argp	JESP_argp

const char *	JESP_argp_version = "JESP options parser 0.1"

static const char *	JESP_args_doc = 0

const struct argp_child	JESP_child = {&JESP_argp, 0, "JESP options", GID_JESP}

static const char *	JESP_doc

static struct argp_option	JESP_options []

static const int	JESP_TYPE = 2

static struct argp	jpolIndex_argp = { jpolIndex_options, jpolIndex_parse_argument, jpolIndex_args_doc, jpolIndex_doc }

const char *	jpolIndex_argp_version = "joint policy index argument parser 0.1"

static const char *	jpolIndex_args_doc = "JPOL-INDEX"

const struct argp_child	jpolIndex_child = {&jpolIndex_argp, 0, 0, GID_PROBLEMFILE}

static const char *	jpolIndex_doc

static struct argp_option	jpolIndex_options []

static struct argp	MaxPlus_argp

const char *	MaxPlus_argp_version = "MaxPlus options parser 0.1"

static const char *	MaxPlus_args_doc = 0

const struct argp_child	MaxPlus_child = {&MaxPlus_argp, 0, "MaxPlus options", GID_MaxPlus}

static const int	MAXPLUS_DAMP = 5

static const char *	MaxPlus_doc

static const int	MAXPLUS_ITER = 3

static struct argp_option	MaxPlus_options []

static const int	MAXPLUS_RESTARTS = 1

static const int	MAXPLUS_UPDATE = 2

static const int	MAXPLUS_VERB = 4

static struct argp	mmdp_method_argp = { mmdp_method_options, mmdp_method_parse_argument, mmdp_method_args_doc, mmdp_method_doc }

const char *	mmdp_method_argp_version = "MMDP_method options parser 0.1"

static const char *	mmdp_method_args_doc = 0

const struct argp_child	mmdp_method_child = {&mmdp_method_argp, 0, "mmdp_method options", GID_MMDP_METHOD}

static const char *	mmdp_method_doc

static struct argp_option	mmdp_method_options []

static struct argp	modelOptions_argp = { modelOptions_options, modelOptions_parse_argument, modelOptions_args_doc, modelOptions_doc }

const char *	modelOptions_argp_version = "Model options parser 0.1"

static const char *	modelOptions_args_doc = 0

const struct argp_child	modelOptions_child = {&modelOptions_argp, 0, "Model options", GID_MODELOPTIONS}

static const char *	modelOptions_doc

static struct argp_option	modelOptions_options []

static struct argp	onlinePOMDP_argp

const char *	onlinePOMDP_argp_version = "onlinePOMDP options parser 0.1"

static const char *	onlinePOMDP_args_doc = 0

const struct argp_child	onlinePOMDP_child = {&onlinePOMDP_argp, 0, "onlinePOMDP options", GID_onlinePOMDP}

static const char *	onlinePOMDP_doc

static struct argp_option	onlinePOMDP_options []

static const int	OPT_DEADLINE =1

static const int	OPT_EXTINGUISHPROB =8

static const int	OPT_GMAADEADLINE =3

static const int	OPT_INF =1

static const int	OPT_ISLANDCONF =4

static const int	OPT_MAXBACKLOG =5

static const int	OPT_NORECOMPUTE =2

static const int	OPT_NRAGENTS =1

static const int	OPT_NRFLS =3

static const int	OPT_NRHOUSES =2

static const int	OPT_PREFIX =1

static const int	OPT_REQUIREQCACHE =4

static const int	OPT_TOI =1

static const int	OPT_VARIATION =6

static struct argp_option	options_main []

static struct argp	outputFileOptions_argp = { outputFileOptions_options, outputFileOptions_parse_argument, outputFileOptions_args_doc, outputFileOptions_doc }

const char *	outputFileOptions_argp_version = "Output file options parser 0.1"

static const char *	outputFileOptions_args_doc = 0

const struct argp_child	outputFileOptions_child = {&outputFileOptions_argp, 0, "Output file options", GID_OUTPUTFILEOPTIONS}

static const char *	outputFileOptions_doc

static struct argp_option	outputFileOptions_options []

static struct argp	perseus_argp

const char *	perseus_argp_version = "Perseus options parser 0.1"

static const char *	perseus_args_doc = 0

const struct argp_child	perseus_child

static const char *	perseus_doc

static struct argp_option	perseus_options []

static struct argp	perseusbackup_argp

const char *	perseusbackup_argp_version = "Perseus Backup options parser 0.1"

static const char *	perseusbackup_args_doc = 0

const struct argp_child	perseusbackup_child

static const char *	perseusbackup_doc

static struct argp_option	perseusbackup_options []

static struct argp	perseusbelief_argp

const char *	perseusbelief_argp_version = "Perseus Belief options parser 0.1"

static const char *	perseusbelief_args_doc = 0

const struct argp_child	perseusbelief_child

static const char *	perseusbelief_doc

static struct argp_option	perseusbelief_options []

static struct argp	problemFile_argp = { problemFile_options, problemFile_parse_argument, problemFile_args_doc, problemFile_doc }

const char *	problemFile_argp_version = ".dpomdp file argument parser 0.1"

static const char *	problemFile_args_doc = "PROBLEM"

const struct argp_child	problemFile_child = {&problemFile_argp, 0, "Problem specification options", GID_PROBLEMFILE}

static const char *	problemFile_doc

static struct argp_option	problemFile_options []

static const int	PRUNEAFTERCROSSSUM = 2

static const int	PRUNEAFTERUNION = 1

static struct argp	qheur_argp

const char *	qheur_argp_version = "QHEUR options parser 0.1"

static const char *	qheur_args_doc = 0

const struct argp_child	qheur_child

static const char *	qheur_doc

static struct argp_option	qheur_options []

static struct argp	RL_argp

const char *	RL_argp_version = "RL options parser 0.1"

static const char *	RL_args_doc = 0

const struct argp_child	RL_child = {&RL_argp, 0, "RL options", GID_RL}

static const char *	RL_doc

static struct argp_option	RL_options []

static const int	RLSTARTRUN = 1

static struct argp	simulation_argp

const char *	simulation_argp_version = "Simulation options parser 0.1"

static const char *	simulation_args_doc = 0

const struct argp_child	simulation_child

static const char *	simulation_doc

static struct argp_option	simulation_options []

static const int	SLACK =2

static struct argp	solutionMethodOptions_argp = { solutionMethodOptions_options, solutionMethodOptions_parse_argument, solutionMethodOptions_args_doc, solutionMethodOptions_doc }

const char *	solutionMethodOptions_argp_version = "Solution method options parser 0.1"

static const char *	solutionMethodOptions_args_doc = 0

const struct argp_child	solutionMethodOptions_child = {&solutionMethodOptions_argp, 0, "Solution method options", GID_SM }

static const char *	solutionMethodOptions_doc

static struct argp_option	solutionMethodOptions_options []

static argp	theArgpStruc = {options_main, parse_main, 0, doc, childVector }

const struct argp_child	toi_child

const struct argp_child	toicentralized_child

static const int	TREEIPVECTORCACHE = 3

Detailed Description

ArgumentHandlers contains functionality for parsing and handling command-line arguments.

Enumeration Type Documentation

enum ArgumentHandlers::MMDP_method

Enumerator
ValueIteration
PolicyIteration
PolicyIterationGPU

Function Documentation

error_t ArgumentHandlers::bgsolver_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References BGIP_SolverType::AM, BGIP_SolverType::BFS, BGIP_SolverType::BFSNonInc, ArgumentHandlers::Arguments::bgsolver, BGIP_SolverType::BnB, BGIP_SolverType::CE, BGIP_SolverType::CGBG_MaxPlus, ArgumentHandlers::Arguments::deadline, BGIP_SolverType::MaxPlus, BGIP_SolverType::NDP, and BGIP_SolverType::Random.

error_t ArgumentHandlers::BnB_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

error_t ArgumentHandlers::BNB_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References BGIP_BnB::BasisTypes, ArgumentHandlers::Arguments::BnB_consistentCompleteInformationHeur, ArgumentHandlers::Arguments::BnB_keepAll, BNB_KEEPALL, BNB_RECOMPUTE, BNB_TYPE, ArgumentHandlers::Arguments::BnBJointTypeOrdering, BGIP_BnB::ConsistentMaxContribution, BGIP_BnB::ConsistentMaxContributionDifference, BGIP_BnB::ConsistentMinContribution, BGIP_BnB::DescendingProbability, BGIP_BnB::IdentityMapping, BGIP_BnB::MaxContribution, BGIP_BnB::MaxContributionDifference, and BGIP_BnB::MinContribution.

error_t ArgumentHandlers::CE_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::CE_alpha, CE_EVALUATION_RUNS, CE_RESTARTS, ArgumentHandlers::Arguments::CE_use_hard_threshold, ArgumentHandlers::Arguments::nrCEEvaluationRuns, ArgumentHandlers::Arguments::nrCEIterations, ArgumentHandlers::Arguments::nrCERestarts, ArgumentHandlers::Arguments::nrCESamples, and ArgumentHandlers::Arguments::nrCESamplesForUpdate.

error_t ArgumentHandlers::eventPomdp_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::falseNegativeObs, ArgumentHandlers::Arguments::marginalizationIndex, and ArgumentHandlers::Arguments::marginalize.

error_t ArgumentHandlers::factoredQheur_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

error_t ArgumentHandlers::globalOptions_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::testMode, and ArgumentHandlers::Arguments::verbose.

error_t ArgumentHandlers::gmaa_cluster_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References BayesianGameWithClusterInfo::ApproxJB, BayesianGameWithClusterInfo::ApproxPjaoh, BayesianGameWithClusterInfo::ApproxPjaohJB, ArgumentHandlers::Arguments::BGClusterAlgorithm, BayesianGameWithClusterInfo::Lossless, ArgumentHandlers::Arguments::thresholdJB, ArgumentHandlers::Arguments::thresholdPjaoh, and ArgumentHandlers::Arguments::useBGclustering.

error_t ArgumentHandlers::gmaa_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::exactBGs, GMAAtype::FSPC, ArgumentHandlers::Arguments::gmaa, ArgumentHandlers::Arguments::GMAAdeadline, ArgumentHandlers::Arguments::k, GMAAtype::kGMAA, GMAAtype::MAAstar, GMAAtype::MAAstarClassic, ArgumentHandlers::Arguments::nrAMRestarts, ArgumentHandlers::Arguments::requireQcache, ArgumentHandlers::Arguments::saveAllBGs, ArgumentHandlers::Arguments::saveTimings, ArgumentHandlers::Arguments::slack, and ArgumentHandlers::Arguments::useQcache.

error_t ArgumentHandlers::JESP_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::jesp, JESP_TYPE, JESPtype::JESPDP, JESPtype::JESPExhaustive, and ArgumentHandlers::Arguments::saveTimings.

error_t ArgumentHandlers::jpolIndex_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::jpolIndex.

error_t ArgumentHandlers::MaxPlus_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References MAXPLUS_DAMP, ArgumentHandlers::Arguments::maxplus_damping, MAXPLUS_ITER, ArgumentHandlers::Arguments::maxplus_maxiter, ArgumentHandlers::Arguments::maxplus_nrRestarts, MAXPLUS_RESTARTS, MAXPLUS_UPDATE, ArgumentHandlers::Arguments::maxplus_updateT, MAXPLUS_VERB, and ArgumentHandlers::Arguments::maxplus_verbose.

error_t ArgumentHandlers::mmdp_method_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::mmdp_method, PolicyIteration, PolicyIterationGPU, and ValueIteration.

error_t ArgumentHandlers::modelOptions_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::cache_flat_models, ArgumentHandlers::Arguments::discount, ArgumentHandlers::Arguments::isTOI, and ArgumentHandlers::Arguments::sparse.

error_t ArgumentHandlers::onlinePOMDP_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::nrNodesExpanded.

error_t ArgumentHandlers::outputFileOptions_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::description, ArgumentHandlers::Arguments::dryrun, ArgumentHandlers::Arguments::noReCompute, and ArgumentHandlers::Arguments::prefix.

static error_t ArgumentHandlers::parse_main	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

static

References size().

error_t ArgumentHandlers::perseus_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::initializeWithImmediateReward, ArgumentHandlers::Arguments::initializeWithZero, ArgumentHandlers::Arguments::marginalizationIndex, ArgumentHandlers::Arguments::marginalize, ArgumentHandlers::Arguments::minimumNrIterations, ArgumentHandlers::Arguments::nrBeliefs, ArgumentHandlers::Arguments::saveIntermediateV, ArgumentHandlers::Arguments::savePOMDP, and ArgumentHandlers::Arguments::saveTimings.

error_t ArgumentHandlers::perseusbackup_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::backup, BG, ArgumentHandlers::Arguments::bgBackup, BGIP_SOLVER_ALTERNATINGMAXIMIZATION, BGIP_SOLVER_ALTERNATINGMAXIMIZATION_100STARTS, BGIP_SOLVER_BRANCH_AND_BOUND, BGIP_SOLVER_EXHAUSTIVE, ArgumentHandlers::Arguments::commModel, ArgumentHandlers::Arguments::computeVectorForEachBelief, EVENT_POMDP, EXHAUSTIVE_ONLYKEEPMAX, EXHAUSTIVE_STOREALL, POMDP, ArgumentHandlers::Arguments::waitPenalty, and ArgumentHandlers::Arguments::weight.

error_t ArgumentHandlers::perseusbelief_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::nrBeliefs, ArgumentHandlers::Arguments::QMDPexploreProb, ArgumentHandlers::Arguments::resetAfter, ArgumentHandlers::Arguments::saveBeliefs, ArgumentHandlers::Arguments::uniqueBeliefs, and ArgumentHandlers::Arguments::useQMDPforSamplingBeliefs.

error_t ArgumentHandlers::problemFile_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

error_t ArgumentHandlers::qheur_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

error_t ArgumentHandlers::RL_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::nrIntermediateEvaluations, ArgumentHandlers::Arguments::nrRLruns, RLSTARTRUN, and ArgumentHandlers::Arguments::startAtRLrun.

error_t ArgumentHandlers::simulation_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::nrRuns, and ArgumentHandlers::Arguments::randomSeed.

template<typename T , unsigned N>

unsigned ArgumentHandlers::size ( T(&) array[N] )

Referenced by AlphaVectorPlanning::BackProject(), MonahanBGPlanner::BackupStage(), TreeIncPruneBGPlanner::ComputeKey(), PlanningUnitMADPDiscrete::CreateActionHistoryTree(), PlanningUnitMADPDiscrete::CreateObservationHistoryTree(), Scope::Equals(), PlanningUnitMADPDiscrete::GetActionHistoryTree(), MADPComponentDiscreteStates::GetInitialStateProbability(), StateDistributionVector::GetNrStates(), PlanningUnitMADPDiscrete::GetObservationHistoryTree(), TwoStageDynamicBayesianNetwork::GetOProbabilitiesExactScopes(), TwoStageDynamicBayesianNetwork::GetOProbability(), TwoStageDynamicBayesianNetwork::GetYOProbability(), TwoStageDynamicBayesianNetwork::GetYProbability(), TwoStageDynamicBayesianNetwork::GetYProbabilityGeneral(), IndividualBeliefJESP::IndividualBeliefJESP(), TwoStageDynamicBayesianNetwork::InitializeIIs(), DPOMDPFormatParsing::ParserDPOMDPFormat_Spirit::IsDimensionOfMatrix(), POMDPFormatParsing::ParserPOMDPFormat_Spirit::IsDimensionOfMatrix(), Scope::IsSubSetOf(), TwoStageDynamicBayesianNetwork::JointToIndividualOiiIndices(), BayesianGameBase::JointToIndividualTypeIndices(), MonahanPOMDPPlanner::MonahanCrossSum(), FSDist_COF::Normalize(), parse_main(), MonahanPlanner::Plan(), POMDPFormatParsing::ParserPOMDPFormat_Spirit::PrintDimensionOfMatrix(), AlphaVectorPlanning::Prune(), BeliefSetNonStationary::Size(), GMAA_MAAstarCluster::SoftPrintClusteringStats(), and GMAA_kGMAACluster::SoftPrintClusteringStats().

error_t ArgumentHandlers::solutionMethodOptions_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

References ArgumentHandlers::Arguments::horizon, ArgumentHandlers::Arguments::infiniteHorizon, Globals::MAXHORIZON, and ArgumentHandlers::Arguments::nrRestarts.

error_t ArgumentHandlers::toi_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

error_t ArgumentHandlers::toicentralized_parse_argument	(	int	key,
		char *	arg,
		struct argp_state *	state
	)

Variable Documentation

const int ArgumentHandlers::ACCELERATEDPRUNINGTHRESHOLD = 4

static

const int ArgumentHandlers::AM_RESTARTS =1

static

const char * ArgumentHandlers::argp_program_bug_address

Initial value:

=

"https://github.com/MADPToolbox/MADP"

struct argp ArgumentHandlers::bgsolver_argp = { bgsolver_options, bgsolver_parse_argument, bgsolver_args_doc, bgsolver_doc }

static

const char* ArgumentHandlers::bgsolver_argp_version = "BGSOLVER options parser 0.1"

const char* ArgumentHandlers::bgsolver_args_doc = 0

static

const struct argp_child ArgumentHandlers::bgsolver_child = {&bgsolver_argp, 0, "BGIP Solver options", GID_PROBLEMFILE}

const char* ArgumentHandlers::bgsolver_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
BGIP_SOLVERTYPE parameter:\n\
BFS\t-\tBrute force search, incremental (for GMAA-ICE))\n\
BFSNonInc\t-\tBrute force search, non-incremental (for plain MAA*)\n\
AM \t-\tAlternating Maximization (see AM options)\n\
CE \t-\tCross-Entropy (see CE options) \n\
MP \t-\tMax-Plus (see MaxPlus options) \n\
BnB \t-\tBranch-and-Bound (see BnB options)\n\
CGBG_MP\t-\tMax-Plus for CGBGs (only for factored Dec-POMDPs) \n\
NDP\t-\tNon-serial Dynamic Programming (only for factored Dec-POMDPs) \n\
Random\t-\tGives random solutions, for testing purposes"

struct argp_option ArgumentHandlers::bgsolver_options[]

static

Initial value:

= {
{"BGIP_Solver", 'B', "BGIP_SOLVERTYPE", 0, "Select which Bayesian game solver to use"},
{"deadline", OPT_DEADLINE, "TIME", 0, "Deadline for solving BGs in s, only implemented for BruteForceSearch"},
{ 0 }
}

struct argp ArgumentHandlers::BnB_argp

static

Initial value:

= { BNB_options, BNB_parse_argument,

BNB_args_doc, BNB_doc }

ArgumentHandlers::BNB_options

static struct argp_option BNB_options[]

Definition: argumentHandlers.cpp:1331

ArgumentHandlers::BNB_args_doc

static const char * BNB_args_doc

Definition: argumentHandlers.cpp:1313

ArgumentHandlers::BNB_doc

static const char * BNB_doc

Definition: argumentHandlers.cpp:1314

ArgumentHandlers::BNB_parse_argument

error_t BNB_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:1338

const char* ArgumentHandlers::BNB_argp_version = "BNB options parser 0.1"

const char* ArgumentHandlers::BNB_args_doc = 0

static

const struct argp_child ArgumentHandlers::BnB_child = {&BnB_argp, 0, "BNB options", GID_BNB}

const char* ArgumentHandlers::BNB_doc

static

Initial value:

= 
"This is the documentation for the BNB options parser.\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
JointTypeOrdering can be\n\
Id       - Identity Mapping\n\
MaxC     - Ordered by maximum contribution\n\
MinC     - Ordered by minimum contribution\n\
MaxDiff  - Ordered by maximum difference\n\
Prob     - Ordered by descending probability\n\
Basis    - Use only the basis types\n\
CMaxC    - Ordered by maximum contribution (updated for consistency)\n\
CMinC    - Ordered by minimum contribution (updated for consistency)\n\
CMaxDiff - Ordered by maximum difference (updated for consistency)\n"

const int ArgumentHandlers::BNB_KEEPALL = 1

Referenced by BNB_parse_argument().

struct argp_option ArgumentHandlers::BNB_options[]

static

Initial value:

= {
{"BnB-keepAll", BNB_KEEPALL, 0, 0, "Generate all joint action extensions"},
{"BnB-ordering", BNB_TYPE, "BNBTYPE", 0, "Choose the ordering of joint types"},
{"BnB-CIheur", BNB_RECOMPUTE, 0, 0, "Use the Complete Information heuristic instead of the Consistent CI one"},
{ 0 }
}

const int ArgumentHandlers::BNB_RECOMPUTE = 3

Referenced by BNB_parse_argument().

const int ArgumentHandlers::BNB_TYPE = 2

Referenced by BNB_parse_argument().

struct argp ArgumentHandlers::CE_argp

static

Initial value:

= { CE_options, CE_parse_argument,

CE_args_doc, CE_doc }

ArgumentHandlers::CE_doc

static const char * CE_doc

Definition: argumentHandlers.cpp:1042

ArgumentHandlers::CE_args_doc

static const char * CE_args_doc

Definition: argumentHandlers.cpp:1041

ArgumentHandlers::CE_parse_argument

error_t CE_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:1066

ArgumentHandlers::CE_options

static struct argp_option CE_options[]

Definition: argumentHandlers.cpp:1055

const char* ArgumentHandlers::CE_argp_version = "CE options parser 0.1"

const char* ArgumentHandlers::CE_args_doc = 0

static

const struct argp_child ArgumentHandlers::CE_child = {&CE_argp, 0, "CE options", GID_CE}

const char* ArgumentHandlers::CE_doc

static

Initial value:

= 
"This is the documentation for the CE (cross entropy) options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
Options for using CE (the cross-entropy method) for optimization include \
the number of restarts (runs), the number of iteration for each runs, \
how much samples are drawn each iteration, and how much of those are \
used to update the probability distribution."

const int ArgumentHandlers::CE_EVALUATION_RUNS = 2

static

Referenced by CE_parse_argument().

struct argp_option ArgumentHandlers::CE_options[]

static

Initial value:

= {
{"CE-restarts", CE_RESTARTS, "CERESTARTS", 0, "Set the number of CE restarts (runs)"},
{"CE-eval-runs", CE_EVALUATION_RUNS, "CEEVALRUNS", 0, "Set the number of policy evaluation runs. More runs will result in more accurate evaluation. (set 0 for exact evaluation)."},
{"iterations", 'i', "ITERATIONS", 0, "Set the number of iterations per run"},
{"samples", 'n', "SAMPLES", 0, "Set the number of samples per iteration"},
{"updateSamples", 'u', "UPDATESAMPPLES", 0, "Set the number of samples used to update the prob. distribution."},
{"not_strictly_improving", 'N', 0, 0, "Do not use a hard threshold: do not require that newly sampled policies are strictly better then before. (this corresponds to the gamma in the CE papers)"},
{"alpha", 'a', "ALPHA", 0, "The learning rate"},
{ 0 }
}

const int ArgumentHandlers::CE_RESTARTS = 1

static

Referenced by CE_parse_argument().

struct argp ArgumentHandlers::eventPomdp_argp

static

Initial value:

= { eventPomdp_options, eventPomdp_parse_argument,

eventPomdp_args_doc, eventPomdp_doc }

ArgumentHandlers::eventPomdp_parse_argument

error_t eventPomdp_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:1400

ArgumentHandlers::eventPomdp_doc

static const char * eventPomdp_doc

Definition: argumentHandlers.cpp:1387

ArgumentHandlers::eventPomdp_options

static struct argp_option eventPomdp_options[]

Definition: argumentHandlers.cpp:1393

ArgumentHandlers::eventPomdp_args_doc

static const char * eventPomdp_args_doc

Definition: argumentHandlers.cpp:1386

const char* ArgumentHandlers::eventPomdp_argp_version = "Event-Driven POMDP options parser 0.1"

const char* ArgumentHandlers::eventPomdp_args_doc = 0

static

const struct argp_child ArgumentHandlers::eventPomdp_child

Initial value:

= {&eventPomdp_argp, 0,

"Event-Driven POMDP options", GID_EVENTPOMDP}

ArgumentHandlers::eventPomdp_argp

static struct argp eventPomdp_argp

Definition: argumentHandlers.cpp:1420

ArgumentHandlers::GID_EVENTPOMDP

static const int GID_EVENTPOMDP

Definition: argumentHandlers.cpp:1384

const char* ArgumentHandlers::eventPomdp_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::eventPomdp_options[]

static

Initial value:

= {
{"marginalize",   'm',"MARGININDEX",  0, "Marginalize a state factor out of the flat transition and observation models. This is useful for problems which you want to describe graphically, but have to solve with a non-factored solver like Perseus. Use only for Event-Driven POMDPs."},
{"falseNegative", 'F',"FALSEINDEX", 0, "Index of a joint observation corresponding to a system-wide false negative detection of an event. This is usually necessary for realistic results in Event-Driven POMDPs."},
{ 0 }
}

const struct argp_child ArgumentHandlers::factoredQheur_child

const int ArgumentHandlers::GID_BGSOLVER =GID_SM

static

const int ArgumentHandlers::GID_BNB =GID_SM

static

const int ArgumentHandlers::GID_CE =GID_SM

static

const int ArgumentHandlers::GID_EVENTPOMDP =GID_SM

static

const int ArgumentHandlers::GID_GLOBALOPTIONS =8

static

const int ArgumentHandlers::GID_GMAA =GID_SM

static

const int ArgumentHandlers::GID_GMAA_CLUSTER =GID_SM

static

const int ArgumentHandlers::GID_INPUTARG =1

static

const int ArgumentHandlers::GID_JESP =GID_SM

static

const int ArgumentHandlers::GID_JPOLINDEX =GID_INPUTARG

static

const int ArgumentHandlers::GID_MaxPlus =GID_SM

static

const int ArgumentHandlers::GID_MMDP_METHOD =88

static

const int ArgumentHandlers::GID_MODELOPTIONS =3

static

const int ArgumentHandlers::GID_onlinePOMDP =GID_SM

static

const int ArgumentHandlers::GID_OUTPUTFILEOPTIONS =6

static

const int ArgumentHandlers::GID_PERSEUS =GID_SM

static

const int ArgumentHandlers::GID_PERSEUSBACKUP =GID_SM

static

const int ArgumentHandlers::GID_PERSEUSBELIEF =GID_SM

static

const int ArgumentHandlers::GID_PROBLEMFILE =GID_INPUTARG

static

const int ArgumentHandlers::GID_QHEUR =GID_SM

static

const int ArgumentHandlers::GID_RL =GID_SM

static

const int ArgumentHandlers::GID_SIMULATION =7

static

const int ArgumentHandlers::GID_SM =2

static

struct argp ArgumentHandlers::globalOptions_argp = { globalOptions_options, globalOptions_parse_argument, globalOptions_args_doc, globalOptions_doc }

static

const char* ArgumentHandlers::globalOptions_argp_version = "global options parser 0.1"

const char* ArgumentHandlers::globalOptions_args_doc = 0

static

const struct argp_child ArgumentHandlers::globalOptions_child = {&globalOptions_argp, 0, "General options", GID_GLOBALOPTIONS}

const char* ArgumentHandlers::globalOptions_doc

static

Initial value:

= 
"This is the documentation for the global options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::globalOptions_options[]

static

Initial value:

= {
{"verbose",  'v', 0,       0, "Produce verbose output. Specifying this option multiple times increases verbosity." },
{"quiet",    'q', 0,       0, "Don't produce any output" },
{"silent",   's', 0,       OPTION_ALIAS },
{"testMode", 't', 0,       0, "Fixed random seed and not printing variable output such as timings" },
{ 0 }
}

struct argp ArgumentHandlers::gmaa_argp

static

Initial value:

= { gmaa_options, gmaa_parse_argument,
                                 gmaa_args_doc, gmaa_doc
}

const char* ArgumentHandlers::gmaa_argp_version = "GMAA options parser 0.1"

const char* ArgumentHandlers::gmaa_args_doc = 0

static

const struct argp_child ArgumentHandlers::gmaa_child = {&gmaa_argp, 0, "GMAA options", GID_GMAA}

struct argp ArgumentHandlers::gmaa_cluster_argp

static

Initial value:

= { gmaa_cluster_options, gmaa_cluster_parse_argument,
                                 gmaa_cluster_args_doc, gmaa_cluster_doc
}

const char* ArgumentHandlers::gmaa_cluster_argp_version = "GMAA Cluster options parser 0.1"

const char* ArgumentHandlers::gmaa_cluster_args_doc = 0

static

const struct argp_child ArgumentHandlers::gmaa_cluster_child = {&gmaa_cluster_argp, 0, "GMAA Cluster options", GID_GMAA_CLUSTER}

const char* ArgumentHandlers::gmaa_cluster_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
CLUSTERALG parameter:\n\
Lossless      -> Lossless clustering (default)\n\
ApproxJB      -> Approximate clustering based on joint belief threshold\n\
ApproxPjaoh   -> Approximate clustering based on Pjaoh threshold\n\
ApproxPjaohJB -> Approximate clustering based on joint belief and Pjaoh threshold\n\
\n"

struct argp_option ArgumentHandlers::gmaa_cluster_options[]

static

Initial value:

= {
{"useBGclustering", 'C', 0, 0, "Use Bayesian Game clustering"},
{"BGClusterAlgorithm", 'A', "CLUSTERALG", 0, "Which clustering algorithm to use (Lossless)"},
{"thresholdJB", 'j', "THRESHOLDJB", 0, "Threshold for considering two joint beliefs equal"},
{"thresholdPjaoh", 'p', "THRESHOLDPJAOH", 0, "Threshold for considering two Pjaoh equal"},
{ 0 }
}

const char* ArgumentHandlers::gmaa_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
GMAA parameter:\n\
MAAstar        -> use GMAA_MAAstar\n\
kGMAA          -> use GMAA_kGMAA (uses K)\n\
FSPC           -> use GMAA_FSPC\n\
MAAstarClassic -> use GMAA_MAAstarClassic (uses built-in BFS solver)"

struct argp_option ArgumentHandlers::gmaa_options[]

static

Initial value:

= {
{"GMAA",    'G', "GMAA", 0, "Select which GMAA variation to use" },
{"k",   'k', "K", 0, "Set k in k-GMAA" },
{"AM-restarts", AM_RESTARTS, "AM_RESTARTS", 0, "nr restarts for solving BGs withFSPC_AM"},
{"saveAllBGs", 'b', 0, 0, "Save all Bayesian Games to disk"},
{"saveTimings", 't', 0, 0, "Save timing results to disk"},
{"useQcache", 'c', 0, 0, "Use cached Q heuristics (compute Q if not cached)"},
{"requireQcache", OPT_REQUIREQCACHE, 0, 0, "Use cached Q heuristics (fail if not cached)"},
{"ApproxInference", 'a', 0, 0, "Use approximate inference for BG construction (by default exact BGs are constructed"},
{"slack",   SLACK, "FLOAT", 0, "Sets slack to avoid pruning in case of inadmissible heuristics or approximate past rewards. (default=0.0)"},
{"GMAAdeadline", OPT_GMAADEADLINE, "TIME", 0, "Deadline for completing GMAA, in s"},
{ 0 }
}

struct argp ArgumentHandlers::JESP_argp

static

Initial value:

= { JESP_options, JESP_parse_argument,

JESP_args_doc, JESP_doc }

ArgumentHandlers::JESP_parse_argument

error_t JESP_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:1195

ArgumentHandlers::JESP_args_doc

static const char * JESP_args_doc

Definition: argumentHandlers.cpp:1173

ArgumentHandlers::JESP_options

static struct argp_option JESP_options[]

Definition: argumentHandlers.cpp:1189

ArgumentHandlers::JESP_doc

static const char * JESP_doc

Definition: argumentHandlers.cpp:1174

const char* ArgumentHandlers::JESP_argp_version = "JESP options parser 0.1"

const char* ArgumentHandlers::JESP_args_doc = 0

static

const struct argp_child ArgumentHandlers::JESP_child = {&JESP_argp, 0, "JESP options", GID_JESP}

const char* ArgumentHandlers::JESP_doc

static

Initial value:

= 
"This is the documentation for the JESP (Joint Equilibrium-based \
Search for Policies) options parser.\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
Options for using  JESP (Joint Equilibrium-based \
Search for Policies) include: \
the type of JESP (exhaustive or Dynamic Programming), which can be:\n\
0 or Exh - exhaustive JESP\n\
1 or DP  - Dynamic programming\n\n\
and the number of restarts (runs)."

struct argp_option ArgumentHandlers::JESP_options[]

static

Initial value:

= {
{"JESP-type", JESP_TYPE, "JESPTYPE", 0, "Set the type of JESP (Exh or [DP])"},
{"saveTimings", 't', 0, 0, "Save timing results to disk"},
{ 0 }
}

const int ArgumentHandlers::JESP_TYPE = 2

static

Referenced by JESP_parse_argument().

struct argp ArgumentHandlers::jpolIndex_argp = { jpolIndex_options, jpolIndex_parse_argument, jpolIndex_args_doc, jpolIndex_doc }

static

const char* ArgumentHandlers::jpolIndex_argp_version = "joint policy index argument parser 0.1"

const char* ArgumentHandlers::jpolIndex_args_doc = "JPOL-INDEX"

static

const struct argp_child ArgumentHandlers::jpolIndex_child = {&jpolIndex_argp, 0, 0, GID_PROBLEMFILE}

const char* ArgumentHandlers::jpolIndex_doc

static

Initial value:

= 
"This is the documentation for the joint policy index argument parser\
This parser should be included as a child argp parser in the \
main argp parser of your application.(and this message will\
not be shown)\
\vJPOL-INDEX is a (long long) integer that is the index of the joint \
policy to be considered."

struct argp_option ArgumentHandlers::jpolIndex_options[]

static

Initial value:

= {
{ 0 }
}

struct argp ArgumentHandlers::MaxPlus_argp

static

Initial value:

= { MaxPlus_options, MaxPlus_parse_argument,

MaxPlus_args_doc, MaxPlus_doc }

ArgumentHandlers::MaxPlus_doc

static const char * MaxPlus_doc

Definition: argumentHandlers.cpp:1109

ArgumentHandlers::MaxPlus_parse_argument

error_t MaxPlus_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:1137

ArgumentHandlers::MaxPlus_args_doc

static const char * MaxPlus_args_doc

Definition: argumentHandlers.cpp:1108

ArgumentHandlers::MaxPlus_options

static struct argp_option MaxPlus_options[]

Definition: argumentHandlers.cpp:1128

const char* ArgumentHandlers::MaxPlus_argp_version = "MaxPlus options parser 0.1"

const char* ArgumentHandlers::MaxPlus_args_doc = 0

static

const struct argp_child ArgumentHandlers::MaxPlus_child = {&MaxPlus_argp, 0, "MaxPlus options", GID_MaxPlus}

const int ArgumentHandlers::MAXPLUS_DAMP = 5

static

Referenced by MaxPlus_parse_argument().

const char* ArgumentHandlers::MaxPlus_doc

static

Initial value:

= 
"This is the documentation for the MaxPlus (cross entropy) options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v\
Options for using MaxPlus for optimization include:\n\
-the number of restarts (only useful for randomized Maxplus versions),\n\
-the number maximum number of of iterations of mesage passing in each run,\n\
-the update scheme,\n\
-the damping factor (may speed up convergence, at extra computational cost per \
iteration)\n\
-the verboseness (a positive number), for debugging."

const int ArgumentHandlers::MAXPLUS_ITER = 3

static

Referenced by MaxPlus_parse_argument().

struct argp_option ArgumentHandlers::MaxPlus_options[]

static

Initial value:

= {
{"MP-restarts", MAXPLUS_RESTARTS, "MaxPlusRESTARTS", 0, "Set the number of MaxPlus restarts (runs)"},
{"MP-update", MAXPLUS_UPDATE, "STRING", 0, "The update scheme: \"PARALL\"(default), \"SEQRND\", or \"SEQMAX\""},
{"MP-iters", MAXPLUS_ITER, "NUMBER", 0, "The maximum number of iterations performed by Max-Plus"},
{"MP-verbose", MAXPLUS_VERB, "0...9", 0, "Set verboseness level of Max-Plus (o by default"},
{"MP-damp", MAXPLUS_DAMP, "REAL", 0, "Set the damping factor (default 0.5)"},
{ 0 }
}

const int ArgumentHandlers::MAXPLUS_RESTARTS = 1

static

Referenced by MaxPlus_parse_argument().

const int ArgumentHandlers::MAXPLUS_UPDATE = 2

static

Referenced by MaxPlus_parse_argument().

const int ArgumentHandlers::MAXPLUS_VERB = 4

static

Referenced by MaxPlus_parse_argument().

struct argp ArgumentHandlers::mmdp_method_argp = { mmdp_method_options, mmdp_method_parse_argument, mmdp_method_args_doc, mmdp_method_doc }

static

const char* ArgumentHandlers::mmdp_method_argp_version = "MMDP_method options parser 0.1"

const char* ArgumentHandlers::mmdp_method_args_doc = 0

static

const struct argp_child ArgumentHandlers::mmdp_method_child = {&mmdp_method_argp, 0, "mmdp_method options", GID_MMDP_METHOD}

const char* ArgumentHandlers::mmdp_method_doc

static

Initial value:

= 
"mmdp_methods: \
ValueIteration : \
PolicyIteration : \
PolicyIterationGPU :\
\v"

struct argp_option ArgumentHandlers::mmdp_method_options[]

static

Initial value:

= {
{"mmdp_method",'t', "MMDP_METHOD",  0, "available: 'ValueIteration' (default), 'PolicyIteration', 'PolicyIterationGPU'"},
{ 0 }
}

struct argp ArgumentHandlers::modelOptions_argp = { modelOptions_options, modelOptions_parse_argument, modelOptions_args_doc, modelOptions_doc }

static

const char* ArgumentHandlers::modelOptions_argp_version = "Model options parser 0.1"

const char* ArgumentHandlers::modelOptions_args_doc = 0

static

const struct argp_child ArgumentHandlers::modelOptions_child = {&modelOptions_argp, 0, "Model options", GID_MODELOPTIONS}

const char* ArgumentHandlers::modelOptions_doc

static

Initial value:

= 
"This is the documentation for the model options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v"

struct argp_option ArgumentHandlers::modelOptions_options[]

static

Initial value:

= {
{"cache-flat-models",   'f',0,  0, "Cache flat models. Indicates that flat transition, observation and reward models should be cached for factored models. (recommended when using exact inference techniques on factored models)"},
{"sparse",              's',0,  0, "Use sparse transition and observation models" },
{"toi",         OPT_TOI,    0,  0, "Indicate that PROBLEM is a transition observation independent Dec-POMDP" },
{"discount",  'g', "GAMMA",     0, "Set the problem's discount parameter (overriding its default)" },
{ 0 }
}

struct argp ArgumentHandlers::onlinePOMDP_argp

static

Initial value:

= { onlinePOMDP_options,
                                        onlinePOMDP_parse_argument,
                                        onlinePOMDP_args_doc, onlinePOMDP_doc }

const char* ArgumentHandlers::onlinePOMDP_argp_version = "onlinePOMDP options parser 0.1"

const char* ArgumentHandlers::onlinePOMDP_args_doc = 0

static

const struct argp_child ArgumentHandlers::onlinePOMDP_child = {&onlinePOMDP_argp, 0, "onlinePOMDP options", GID_onlinePOMDP}

const char* ArgumentHandlers::onlinePOMDP_doc

static

Initial value:

= 
"This is the documentation for the onlinePOMDP options parser.\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v"

struct argp_option ArgumentHandlers::onlinePOMDP_options[]

static

Initial value:

= {
{"nrNodesExpanded",  'n', "NODES", 0, "Set the number of nodes to be expanded at every action choice" },
{ 0 }
}

const int ArgumentHandlers::OPT_DEADLINE =1

static

const int ArgumentHandlers::OPT_EXTINGUISHPROB =8

static

const int ArgumentHandlers::OPT_GMAADEADLINE =3

static

const int ArgumentHandlers::OPT_INF =1

static

const int ArgumentHandlers::OPT_ISLANDCONF =4

static

const int ArgumentHandlers::OPT_MAXBACKLOG =5

static

const int ArgumentHandlers::OPT_NORECOMPUTE =2

static

const int ArgumentHandlers::OPT_NRAGENTS =1

static

const int ArgumentHandlers::OPT_NRFLS =3

static

const int ArgumentHandlers::OPT_NRHOUSES =2

static

const int ArgumentHandlers::OPT_PREFIX =1

static

const int ArgumentHandlers::OPT_REQUIREQCACHE =4

static

const int ArgumentHandlers::OPT_TOI =1

static

const int ArgumentHandlers::OPT_VARIATION =6

static

struct argp_option ArgumentHandlers::options_main[]

static

Initial value:

= {
    { 0 }
}

struct argp ArgumentHandlers::outputFileOptions_argp = { outputFileOptions_options, outputFileOptions_parse_argument, outputFileOptions_args_doc, outputFileOptions_doc }

static

const char* ArgumentHandlers::outputFileOptions_argp_version = "Output file options parser 0.1"

const char* ArgumentHandlers::outputFileOptions_args_doc = 0

static

const struct argp_child ArgumentHandlers::outputFileOptions_child = {&outputFileOptions_argp, 0, "Output file options", GID_OUTPUTFILEOPTIONS}

const char* ArgumentHandlers::outputFileOptions_doc

static

Initial value:

= 
"This is the documentation for the output file options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::outputFileOptions_options[]

static

Initial value:

= {
{"dry-run",  'd', 0,       0, "Do not actually create any output files." },
{"description",  'D', "DESCR",       0, 
"Use DESCR to describe the problem. This will be used \
in the output file's names." },
{"prefix",    OPT_PREFIX, "PREFIX",      0, 
"Use PREFIX as a prefix for the output result files." },
{"dontReCompute",  OPT_NORECOMPUTE, 0,       0, "Check if the output file already exists, if so don't re-compute the result, but exit immediately." },
{ 0 }
}

struct argp ArgumentHandlers::perseus_argp

static

Initial value:

= { perseus_options, perseus_parse_argument,

perseus_args_doc, perseus_doc }

ArgumentHandlers::perseus_args_doc

static const char * perseus_args_doc

Definition: argumentHandlers.cpp:665

ArgumentHandlers::perseus_doc

static const char * perseus_doc

Definition: argumentHandlers.cpp:666

ArgumentHandlers::perseus_options

static struct argp_option perseus_options[]

Definition: argumentHandlers.cpp:672

ArgumentHandlers::perseus_parse_argument

error_t perseus_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:683

const char* ArgumentHandlers::perseus_argp_version = "Perseus options parser 0.1"

const char* ArgumentHandlers::perseus_args_doc = 0

static

const struct argp_child ArgumentHandlers::perseus_child

Initial value:

= {&perseus_argp, 0,

"Perseus general options", GID_PERSEUS}

ArgumentHandlers::perseus_argp

static struct argp perseus_argp

Definition: argumentHandlers.cpp:721

ArgumentHandlers::GID_PERSEUS

static const int GID_PERSEUS

Definition: argumentHandlers.cpp:663

const char* ArgumentHandlers::perseus_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::perseus_options[]

static

Initial value:

= {
{"savePOMDP",  'P', 0, 0, "Save the POMDP to disk" },
{"saveIntermediateV",  'V', 0, 0, "Save intermediate value functions to disk" },
{"saveTimings", 't', 0, 0, "Save timing results to disk"},
{"minNrIterations",   'i', "ITERS", 0, "Make Perseus run at least ITERS iterations" },
{"initReward",  'I', 0, 0, "Initialize the value function with the immediate reward."},
{"initZero",  'z', 0, 0, "Initialize the value function with 0."},
{ 0 }
}

struct argp ArgumentHandlers::perseusbackup_argp

static

Initial value:

= { perseusbackup_options,
                                          perseusbackup_parse_argument,
                                          perseusbackup_args_doc,
                                          perseusbackup_doc }

const char* ArgumentHandlers::perseusbackup_argp_version = "Perseus Backup options parser 0.1"

const char* ArgumentHandlers::perseusbackup_args_doc = 0

static

const struct argp_child ArgumentHandlers::perseusbackup_child

Initial value:

= {&perseusbackup_argp, 0,
                                               "Perseus backup options",
                                               GID_PERSEUSBACKUP}

const char* ArgumentHandlers::perseusbackup_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\vBACKUP parameter:\n\
0  or POMDP   -> use PerseusPOMDP (default)\n\
1  or BG      -> use PerseusBG (BG solver can be specified by BGBACKUP)\n\
2  or EVENT_POMDP -> use PerseusConstrainedPOMDP (only applicable to event-driven models)\n\
\n\
BGBACKUP parameter (details in AlphaVectorBG.{h,cpp}):\n\
0 or EXH_MAX       -> use EXHAUSTIVE_ONLYKEEPMAX backup in PerseusBG\n\
1 or EXH_ALL       -> use EXHAUSTIVE_STOREALL backup in PerseusBG\n\
2 or BGS_EXH       -> use BGIP_SOLVER_EXHAUSTIVE backup in PerseusBG (default)\n\
3 or BGS_ALTMAX    -> use BGIP_SOLVER_ALTERNATINGMAXIMIZATION backup in PerseusBG\n\
4 or BGS_ALTMAX100 -> use BGIP_SOLVER_ALTERNATINGMAXIMIZATION_100STARTS backup\n\
5 or BGS_BNB       -> use BGIP_SOLVER_BRANCH_AND_BOUND backup\n\
"

struct argp_option ArgumentHandlers::perseusbackup_options[]

static

Initial value:

= {
{"backup",  'b', "BACKUP", 0, "Select which backup to use, see below" },
{"vectorEachBelief",   'e', 0, 0, "If specified, don't sample from belief set, but compute vector for each belief" },
{"BGbackup",  'y', "BGBACKUP", 0, "Select which BG backup to use for PerseusBG" },
{"waitPenalty",   'w', "PENALTY", 0, "Set the wait penalty for PerseusImplicitWaiting" },
{"weight",   'W', "WEIGHT", 0, "Set the weight for PerseusWeighted{NS}" },
{"commModel",   'c', "COMM", 0, "Select the communication model for PerseusWeighted" },
{ 0 }
}

struct argp ArgumentHandlers::perseusbelief_argp

static

Initial value:

= { perseusbelief_options, perseusbelief_parse_argument,

perseusbelief_args_doc, perseusbelief_doc }

ArgumentHandlers::perseusbelief_args_doc

static const char * perseusbelief_args_doc

Definition: argumentHandlers.cpp:729

ArgumentHandlers::perseusbelief_options

static struct argp_option perseusbelief_options[]

Definition: argumentHandlers.cpp:736

ArgumentHandlers::perseusbelief_doc

static const char * perseusbelief_doc

Definition: argumentHandlers.cpp:730

ArgumentHandlers::perseusbelief_parse_argument

error_t perseusbelief_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:746

const char* ArgumentHandlers::perseusbelief_argp_version = "Perseus Belief options parser 0.1"

const char* ArgumentHandlers::perseusbelief_args_doc = 0

static

const struct argp_child ArgumentHandlers::perseusbelief_child

Initial value:

= {&perseusbelief_argp, 0,

"Perseus belief set sampling options", GID_PERSEUSBELIEF}

ArgumentHandlers::GID_PERSEUSBELIEF

static const int GID_PERSEUSBELIEF

Definition: argumentHandlers.cpp:727

ArgumentHandlers::perseusbelief_argp

static struct argp perseusbelief_argp

Definition: argumentHandlers.cpp:777

const char* ArgumentHandlers::perseusbelief_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::perseusbelief_options[]

static

Initial value:

= {
{"beliefs",'n', "BELIEFS", 0, "Set the belief set size" },
{"saveBeliefs",  'B', 0, 0, "Save beliefs to disk" },
{"beliefSamplingHorizon",   'H', "HORIZON", 0, "Introduce an artificial horizon when sampling the beliefs (useful in infinite-horizon case)" },
{"uniqueBeliefs",  'u', 0, 0, "Sample unique beliefs (no duplicates)" },
{"useQMDP",  'Q', 0, 0, "Follow the QMDP policy while sampling beliefs instead of acting uniformly at random."},
{"QMDPexploreProb",  'x', "PROB", 0, "Probability with which to take a random action when using QMDP for belief sampling."},
{ 0 }
}

struct argp ArgumentHandlers::problemFile_argp = { problemFile_options, problemFile_parse_argument, problemFile_args_doc, problemFile_doc }

static

const char* ArgumentHandlers::problemFile_argp_version = ".dpomdp file argument parser 0.1"

const char* ArgumentHandlers::problemFile_args_doc = "PROBLEM"

static

const struct argp_child ArgumentHandlers::problemFile_child = {&problemFile_argp, 0, "Problem specification options", GID_PROBLEMFILE}

const char* ArgumentHandlers::problemFile_doc

static

Initial value:

= 
"This is the documentation for the .dpomdp file argument parser\
This parser should be included as a child argp parser in the \
main argp parser of your application.(and this message will\
not be shown)\
\vPROBLEM is either \n\
a) one of the following standard problems: DT, FF, FFF, FFG, Aloha \n\
or \n\
b) or a problem filename (.dpomdp, .toi-dpomdp, .pgmx or .pomdp). \
If it includes an extension, PROBLEM will be attempted to be loaded as is, \
otherwise ~/.madp/problems/PROBLEM.{dpomdp,pgmx,POMDP} will be searched (and .toi-dpomdp if TOI models are requested). \
Some of the standard problems take options."

struct argp_option ArgumentHandlers::problemFile_options[]

static

Initial value:

= {
{"agents",      OPT_NRAGENTS,   "NRAGENTS", 0, "FireFighting: the number of agents (2)" },
{"houses",      OPT_NRHOUSES,   "NRHOUSES", 0, "FireFighting: the number of houses (3)" },
{"firelevels",  OPT_NRFLS,      "NRFLS",    0, "FireFighting: the number of firelevels (3)"},
{"extinguishProb", OPT_EXTINGUISHPROB, "PROB",     0, "FireFighting: set multiple agent extinguish probability (1.0)" },
{"islands",  OPT_ISLANDCONF,      "ISLANDS",  0, "Aloha: the island configuration (TwoIslands), can be TwoIslands, OneIsland, TwoIndependentIslands, ThreeIslandsInLine, ThreeIslandsClustered, SmallBigSmallInLine, FiveIslandsInLine, FourIslandsInLine, FourIslandsInSquare, SixIslandsInLine, SevenIslandsInLine"},
{"variation",  OPT_VARIATION,      "VARIATION",  0, "Aloha: which variation to use (NoNewPacket), can be NoNewPacket, NewPacket, NewPacketSendAll, NewPacketProgressivePenalty"},
{"backlog",  OPT_MAXBACKLOG,      "MAXBL",  0, "Aloha: the maximum backlog per island (2)"},
{ 0 }
}

const int ArgumentHandlers::PRUNEAFTERCROSSSUM = 2

static

const int ArgumentHandlers::PRUNEAFTERUNION = 1

static

struct argp ArgumentHandlers::qheur_argp

static

Initial value:

= { qheur_options, qheur_parse_argument,

qheur_args_doc, qheur_doc }

ArgumentHandlers::qheur_options

static struct argp_option qheur_options[]

Definition: argumentHandlers.cpp:903

ArgumentHandlers::qheur_doc

static const char * qheur_doc

Definition: argumentHandlers.cpp:886

ArgumentHandlers::qheur_parse_argument

error_t qheur_parse_argument(int key, char *arg, struct argp_state *state)

Definition: argumentHandlers.cpp:915

ArgumentHandlers::qheur_args_doc

static const char * qheur_args_doc

Definition: argumentHandlers.cpp:885

const char* ArgumentHandlers::qheur_argp_version = "QHEUR options parser 0.1"

const char* ArgumentHandlers::qheur_args_doc = 0

static

const struct argp_child ArgumentHandlers::qheur_child

Initial value:

= {&qheur_argp, 0, "Q-heuristic options",

GID_QHEUR}

ArgumentHandlers::qheur_argp

static struct argp qheur_argp

Definition: argumentHandlers.cpp:990

ArgumentHandlers::GID_QHEUR

static const int GID_QHEUR

Definition: argumentHandlers.cpp:879

const char* ArgumentHandlers::qheur_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\vQHEUR parameter:\n\
QMDP              (defined on joint beliefs)\n\
QPOMDP            (defined on joint history tree)\n\
QBG               (defined on joint history tree)\n\
QMDPc             (cached for each joint AO history)\n\
QPOMDPav          (uses alpha vectors over joint beliefs)\n\
QBGav             (uses alpha vectors over joint beliefs)\n\
QHybrid           (hybrid between vector and trees, customizable)\n\
QPOMDPhybrid      (QPOMDP hybrid between vector and trees, no options)\n\
QBGhybrid         (QBG hybrid between vector and trees, no options)\n\
QBGTreeIncPrune   (vector-based QBG using tree-based incremental pruning with memoization)\n\
QBGTreeIncPruneBnB(vector-based QBG using tree-based incremental pruning with branch-and-bound)\n"

struct argp_option ArgumentHandlers::qheur_options[]

static

Initial value:

= {
{"Qheuristic",  'Q', "QHEUR", 0, "Select which Q-heuristic to use" },
{"horLastT",  'h', "H", 0, "For QHybrid, the horizon for the last time steps" },
{"firstTSheur",  'f', "QHEUR", 0, "For QHybrid, which heuristic to use for the first time steps (QBG or QPOMDP)" },
{"lastTSheur",  'l', "QHEUR", 0, "For QHybrid, which heuristic to use for the first time steps (QMDP/QPOMDP/QBG)" },
{"pruneAfterUnion",  PRUNEAFTERUNION, "0/1", 0, "For QBGTreeIncPrune, whether to prune after every union" },
{"pruneAfterCrossSum",  PRUNEAFTERCROSSSUM, "0/1", 0, "For QBGTreeIncPrune, whether to prune after every cross sum" },
{"useVectorCache",  TREEIPVECTORCACHE, "0/1", 0, "For QBGTreeIncPrune, whether to cache VectorSets" },
{"acceleratedPruningThreshold",  ACCELERATEDPRUNINGTHRESHOLD, "n", 0, "For pruning alpha vectors, the threshold at which to switch to accelerated pruning (default 200 vectors, set to 0 to disable)" },
{ 0 }
}

struct argp ArgumentHandlers::RL_argp

static

Initial value:

= { RL_options,
                               RL_parse_argument,
                               RL_args_doc, RL_doc }

const char* ArgumentHandlers::RL_argp_version = "RL options parser 0.1"

const char* ArgumentHandlers::RL_args_doc = 0

static

const struct argp_child ArgumentHandlers::RL_child = {&RL_argp, 0, "RL options", GID_RL}

const char* ArgumentHandlers::RL_doc

static

Initial value:

= 
"This is the documentation for the RL options parser.\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)\
\v"

struct argp_option ArgumentHandlers::RL_options[]

static

Initial value:

= {
{"nrRLruns",  'n', "RUNS", 0, "Set the number of learning runs" },
{"nrEvals",  'e', "EVALS", 0, "Set how often intermediate evaluation are run" },
{"startRun", RLSTARTRUN , "START", 0, "Start the RL from a particular run" },
{ 0 }
}

const int ArgumentHandlers::RLSTARTRUN = 1

static

Referenced by RL_parse_argument().

struct argp ArgumentHandlers::simulation_argp

static

Initial value:

= { simulation_options,
                                       simulation_parse_argument,
                                       simulation_args_doc, simulation_doc }

const char* ArgumentHandlers::simulation_argp_version = "Simulation options parser 0.1"

const char* ArgumentHandlers::simulation_args_doc = 0

static

const struct argp_child ArgumentHandlers::simulation_child

Initial value:

= {&simulation_argp, 0,
                                            "Simulation options", 
                                            GID_SIMULATION}

const char* ArgumentHandlers::simulation_doc

static

Initial value:

= 
"This is the documentation for the options options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::simulation_options[]

static

Initial value:

= {
{"runs",  'r', "RUNS", 0, "Set the number of episodes to simulate" },
{"seed",  'S', "SEED", 0, "Set the random seed" },
{ 0 }
}

const int ArgumentHandlers::SLACK =2

static

struct argp ArgumentHandlers::solutionMethodOptions_argp = { solutionMethodOptions_options, solutionMethodOptions_parse_argument, solutionMethodOptions_args_doc, solutionMethodOptions_doc }

static

const char* ArgumentHandlers::solutionMethodOptions_argp_version = "Solution method options parser 0.1"

const char* ArgumentHandlers::solutionMethodOptions_args_doc = 0

static

const struct argp_child ArgumentHandlers::solutionMethodOptions_child = {&solutionMethodOptions_argp, 0, "Solution method options", GID_SM }

const char* ArgumentHandlers::solutionMethodOptions_doc

static

Initial value:

= 
"This is the documentation for the solution method options parser\
This parser should be included as a child argp parser in the \
main argp parser of your application. (and this message will\
not be shown)"

struct argp_option ArgumentHandlers::solutionMethodOptions_options[]

static

Initial value:

= {
{"horizon",'h',"HOR", 0, "Specifies the horizon to be considered" },
{"inf", OPT_INF , 0,       0, "Indicate that horizon is infinite" },
{"restarts", 'r', "RESTARTS", 0, "Set the number of times an algorithm is repeated"},
{ 0 }
}

argp ArgumentHandlers::theArgpStruc = {options_main, parse_main, 0, doc, childVector }

static

const struct argp_child ArgumentHandlers::toi_child

const struct argp_child ArgumentHandlers::toicentralized_child

const int ArgumentHandlers::TREEIPVECTORCACHE = 3

static

Classes

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

Function Documentation

Variable Documentation