Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
| ►NArgumentHandlers | ArgumentHandlers contains functionality for parsing and handling command-line arguments |
| ►Ncomment_cbonlp | |
| ►NDPOMDPFormatParsing | |
| ►NPOMDPFormatParsing | |
| ►Nstd | STL namespace |
| CAction | Action is a class that represent actions |
| CActionDiscrete | ActionDiscrete represents discrete actions |
| CActionHistory | ActionHistory represents an action history of a single agent |
| CActionHistoryTree | ActionHistoryTree is a wrapper for ActionHistory |
| CActionObservationHistory | ActionObservationHistory represents an action-observation history of an agent |
| CActionObservationHistoryTree | ActionObservationHistoryTree is a wrapper for ActionObservationHistory |
| CAgent | Agent represents an agent |
| CAgentBG | AgentBG represents an agent which uses a BG-based policy |
| CAgentDecPOMDPDiscrete | AgentDecPOMDPDiscrete represents an agent in a discrete DecPOMDP setting |
| CAgentDelayedSharedObservations | AgentDelayedSharedObservations represents an agent that acts on local observations and the shared observation at the previous time step |
| CAgentFullyObservable | AgentFullyObservable represents an agent that receives the true state, the joint observation and also the reward signal |
| CAgentLocalObservations | AgentLocalObservations represents an agent that acts on local observations |
| CAgentMDP | AgentMDP represents an agent which uses a MDP-based policy |
| CAgentOnlinePlanningMDP | AgentOnlinePlanningMDP represents an agent with an online MDP policy |
| CAgentPOMDP | AgentPOMDP represents an agent which POMDP-based policy |
| CAgentQLearner | AgentQLearner applies standard single-agent Q-learning in the joint action and state space |
| CAgentQMDP | AgentQMDP represents an agent which uses a QMDP-based policy |
| CAgentRandom | AgentRandom represents an agent which chooses action uniformly at random |
| CAgentSharedObservations | AgentSharedObservations is represents an agent that benefits from free communication, i.e., it can share all its observations |
| CAgentTOIFullyObservableSynced | AgentTOIFullyObservableSynced represents an agent that receives the true state, the joint observation and also the reward signal |
| CAgentTOIFullyObservableSyncedSpecialReward | AgentTOIFullyObservableSyncedSpecialReward represents an AgentTOIFullyObservableSynced |
| CAlphaVector | AlphaVector represent an alpha vector used in POMDP solving |
| CAlphaVectorBG | AlphaVectorBG implements Bayesian Game specific functionality for alpha-vector based planning |
| CAlphaVectorConstrainedPOMDP | AlphaVectorConstrainedPOMDP implements Constrained POMDP specific functionality for alpha-vector based planning |
| CAlphaVectorPlanning | AlphaVectorPlanning provides base functionality for alpha-vector based POMDP or BG techniques |
| CAlphaVectorPOMDP | AlphaVectorPOMDP implements POMDP specific functionality for alpha-vector based planning |
| CAlphaVectorPruning | AlphaVectorPruning reduces sets of alpha vectors to their parsimonious representation via LP-based pruning |
| CAlphaVectorWeighted | AlphaVectorWeighted implements a weighted BG/POMDP backup |
| CBayesianGame | BayesianGame is a class that represents a general Bayesian game in which each agent has its own utility function |
| CBayesianGameBase | BayesianGameBase is a class that represents a Bayesian game |
| CBayesianGameCollaborativeGraphical | BayesianGameCollaborativeGraphical represents a collaborative graphical Bayesian game |
| CBayesianGameForDecPOMDPStage | BayesianGameForDecPOMDPStage represents a BG for a single stage |
| CBayesianGameForDecPOMDPStageInterface | BayesianGameForDecPOMDPStageInterface is a class that represents the base class for all Bayesian games that are used to represent a stage of a Dec-POMDP (e.g., in GMAA*) |
| CBayesianGameIdenticalPayoff | BayesianGameIdenticalPayoff is a class that represents a Bayesian game with identical payoffs |
| CBayesianGameIdenticalPayoffInterface | BayesianGameIdenticalPayoffInterface provides an interface for Bayesian Games with identical payoffs |
| CBayesianGameIdenticalPayoffSolver | BayesianGameIdenticalPayoffSolver is an interface for solvers for Bayesian games with identical payoff |
| CBayesianGameIdenticalPayoffSolver_T | BayesianGameIdenticalPayoffSolver_T is an interface for solvers for Bayesian games with identical payoff |
| CBayesianGameWithClusterInfo | BayesianGameWithClusterInfo represents an identical-payoff BG that can be clustered |
| CBelief | Belief represents a probability distribution over the state space |
| CBeliefInterface | BeliefInterface is an interface for beliefs, i.e., probability distributions over the state space |
| CBeliefIterator | BeliefIterator is an iterator for dense beliefs |
| CBeliefIteratorGeneric | BeliefIteratorGeneric is an iterator for beliefs |
| CBeliefIteratorInterface | BeliefIteratorInterface is an interface for iterators over beliefs |
| CBeliefIteratorSparse | BeliefIteratorSparse is an iterator for sparse beliefs |
| CBeliefSetNonStationary | BeliefSetNonStationary represents a non-stationary belief set |
| CBeliefSparse | BeliefSparse represents a probability distribution over the state space |
| CBG_FactorGraphCreator | BG_FactorGraphCreator will create a FG from a BG |
| CBGCG_Solver | BGCG_Solver is a base class for collaborative graphical bayesian games |
| CBGCG_SolverCreator | BGCG_SolverCreator is a class that represents an object that can create a BGCG_Solver |
| CBGCG_SolverCreator_FG | BGCG_SolverCreator_FG creates BGCG Solvers with Max Plus |
| CBGCG_SolverCreator_MP | BGCG_SolverCreator_MP creates BGCG Solvers with Max Plus |
| CBGCG_SolverCreator_NDP | BGCG_SolverCreator_NDP creates BGCG Solvers with Non-serial Dynamic Programming |
| CBGCG_SolverCreator_Random | BGCG_SolverCreator_Random creates a BGCG Solver that gives random solutions |
| CBGCG_SolverFG | |
| CBGCG_SolverMaxPlus | BGCG_SolverMaxPlus is a class that performs max plus for BGIPs with agents independence |
| CBGCG_SolverNonserialDynamicProgramming | BGCG_SolverNonserialDynamicProgramming implements non-serial dynamic programming for collaborative graphical Bayesian games |
| CBGCG_SolverRandom | BGCG_SolverRandom is a class that represents a BGCG solver that returns a random joint BG policy |
| CBGforStageCreation | BGforStageCreation is a class that provides some functions to aid the construction of Bayesian games for a stage of a Dec-POMDP |
| CBGIP_BnB_Node | BGIP_BnB_Node represents a node in the search tree of BGIP_SolverBranchAndBound |
| CBGIP_IncrementalSolverCreatorInterface_T | BGIP_IncrementalSolverCreatorInterface_T is an interface for classes that create BGIP solvers |
| CBGIP_IncrementalSolverInterface | BGIP_IncrementalSolverInterface is an interface for BGIP_Solvers that can incrementally return multiple solutions |
| CBGIP_IncrementalSolverInterface_T | BGIP_IncrementalSolverInterface_T is an interface for BGIP_Solvers that can incrementally return multiple solutions |
| CBGIP_SolverAlternatingMaximization | BGIP_SolverAlternatingMaximization implements an approximate solver for identical payoff Bayesian games, based on alternating maximization |
| CBGIP_SolverBFSNonIncremental | BGIP_SolverBFSNonIncremental is a class that performs Brute force search for identical payoff Bayesian Games |
| CBGIP_SolverBranchAndBound | BGIP_SolverBranchAndBound is a class that performs Branch-and-Bound search for identical payoff Bayesian Games |
| CBGIP_SolverBruteForceSearch | BGIP_SolverBruteForceSearch is a class that performs Brute force search for identical payoff Bayesian Games |
| CBGIP_SolverCE | BGIP_SolverCE is a class that performs Cross Entropy optimization for identical payoff Bayesian Games |
| CBGIP_SolverCreator_AM | BGIP_SolverCreator_AM creates BGIP Solvers with Alternating Maximization |
| CBGIP_SolverCreator_BFS | BGIP_SolverCreator_BFS creates BGIP Solvers with Brute Force Search |
| CBGIP_SolverCreator_BFSNonInc | BGIP_SolverCreator_BFSNonInc creates BGIP Solvers with Brute Force Search |
| CBGIP_SolverCreator_BnB | BGIP_SolverCreator_BnB creates BGIP Solvers with Branch-and-Bound search |
| CBGIP_SolverCreator_CE | BGIP_SolverCreator_CE creates BGIP Solvers with Cross Entropy |
| CBGIP_SolverCreator_MP | BGIP_SolverCreatorInterface_T_MP creates BGIP Solvers with Max Plus |
| CBGIP_SolverCreator_Random | BGIP_SolverCreator_Random creates a BGIP Solver that gives random solutions |
| CBGIP_SolverCreatorInterface | BGIP_SolverCreatorInterface is an interface for classes that create BGIP solvers |
| CBGIP_SolverCreatorInterface_T | BGIP_SolverCreatorInterface_T is an interface for classes that create BGIP solvers |
| CBGIP_SolverMaxPlus | BGIP_SolverMaxPlus is a class that performs max plus for BGIPs (without agents independence) |
| CBGIP_SolverRandom | BGIP_SolverRandom creates random solutions to Bayesian games for testing purposes |
| CBGIPSolution | BGIPSolution represents a solution for BayesianGameIdenticalPayoff |
| CBruteForceSearchPlanner | BruteForceSearchPlanner implements an exact solution algorithm |
| CCompareVec | |
| CCPDDiscreteInterface | CPDDiscreteInterface is an abstract base class that represents a conditional probability distribution  |
| CCPDKroneckerDelta | CPDKroneckerDelta implements a Kronecker delta-style CPD |
| CCPT | CPT implements a conditional probability table |
| CDecPOMDP | DecPOMDP is a simple implementation of DecPOMDPInterface |
| CDecPOMDPDiscrete | DecPOMDPDiscrete represent a discrete DEC-POMDP model |
| CDecPOMDPDiscreteInterface | DecPOMDPDiscreteInterface is the interface for a discrete DEC-POMDP model: it defines the set/get reward functions |
| CDecPOMDPInterface | DecPOMDPInterface is an interface for DecPOMDPs |
| CDICEPSPlanner | DICEPSPlanner implements the Direct Cross-Entropy Policy Search method |
| CDiscreteEntity | DiscreteEntity is a general class for tracking discrete entities |
| CE | E is a class that represents a basic exception |
| CEDeadline | EDeadline represents a deadline exceeded expection |
| CEInvalidIndex | EInvalidIndex represents an invalid index exception |
| CENoSubScope | ENoSubScope represents an invalid index exception |
| CENotCached | ENotCached represents an invalid index exception |
| CEOverflow | EOverflow represents an integer overflow exception |
| CEParse | EParse represents a parser exception |
| CEventObservationModelMapping | EventObservationModelMapping implements an ObservationModelDiscrete which depends not only on the resulting state but also on the current state of the system, i.e. P(o(k+1) | s(k), ja(k), s(k+1)) |
| CEventObservationModelMappingSparse | EventObservationModelMappingSparse implements an ObservationModelDiscrete |
| CFactoredDecPOMDPDiscrete | FactoredDecPOMDPDiscrete is implements a factored DecPOMDPDiscrete |
| CFactoredDecPOMDPDiscreteInterface | FactoredDecPOMDPDiscreteInterface is the interface for a Dec-POMDP with factored states |
| CFactoredMMDPDiscrete | |
| CFactoredQFunctionScopeForStage | FactoredQFunctionScopeForStage represents a Scope for one stage of a factored QFunction |
| CFactoredQFunctionStateJAOHInterface | FactoredQFunctionStateJAOHInterface represents Q-value functions for factored discrete Dec-POMDPs |
| CFactoredQLastTimeStepOrElse | FactoredQLastTimeStepOrElse is a class that represents a Q-function that is factored at the last stage, and non factored for earlier stages |
| CFactoredQLastTimeStepOrQBG | FactoredQLastTimeStepOrQBG is a class that represents a Q-Function that is factored for the last stage (i.e., the factored immediate reward function) and the (non-factored) QBG function for the earlier stages |
| CFactoredQLastTimeStepOrQMDP | FactoredQLastTimeStepOrQMDP is a class that represents a Q-Function that is factored for the last stage (i.e., the factored immediate reward function) and the (non-factored) QMDP function for the earlier stages |
| CFactoredQLastTimeStepOrQPOMDP | FactoredQLastTimeStepOrQPOMDP is a class that represents a Q-Function that is factored for the last stage (i.e., the factored immediate reward function) and the (non-factored) QPOMDP function for the earlier stages |
| CFactoredStateAOHDistribution | FactoredStateAOHDistribution is a class that represents a factored probability distribution over both states and action-observation histories |
| CFactoredStateDistribution | FactoredStateDistribution is a class that represents a base class for factored state distributions |
| CFG_Solver | |
| CFG_SolverMaxPlus | FG_SolverMaxPlus optimizes (maximizes) a factor graph using max plus |
| CFG_SolverNDP | FG_SolverNDP optimizes (maximizes) a factor graph using non-serial dynamic programming |
| CFixedCapacityPriorityQueue | FixedCapacityPriorityQueue is a class that represents a priority queue with a fixed size |
| CFSAOHDist_NECOF | FSAOHDist_NECOF is a class that represents a NEarly COmpletely Factored distribution over state factors and action-observation histories |
| CFSDist_COF | FSDist_COF is a class that represents a completely factored state distribution |
| CGeneralizedMAAStarPlanner | GeneralizedMAAStarPlanner is a class that represents the Generalized MAA* planner class |
| CGeneralizedMAAStarPlannerForDecPOMDPDiscrete | GeneralizedMAAStarPlannerForDecPOMDPDiscrete is a class that represents the Generalized MAA* planner |
| CGeneralizedMAAStarPlannerForFactoredDecPOMDPDiscrete | GeneralizedMAAStarPlannerForFactoredDecPOMDPDiscrete is a class that represents the Generalized MAA* planner |
| CGMAA_kGMAA | GMAA_kGMAA is a class that represents a GMAA planner that performs k-GMAA, i.e |
| CGMAA_kGMAACluster | GMAA_kGMAA is a class that represents a GMAA planner that performs k-GMAA, i.e |
| CGMAA_MAA_ELSI | GMAA_MAA_ELSI Generalized MAA* Exploiting Last-Stage Independence |
| CGMAA_MAAstar | GMAA_MAAstar is a class that represents a planner that performs MAA* as described by Szer et al |
| CGMAA_MAAstarClassic | GMAA_MAAstarClassic is a class that represents a planner that performs MAA* as described by Szer et al |
| CGMAA_MAAstarCluster | GMAA_MAAstarCluster is a class that represents a planner that performs MAA* as described by Szer et al |
| CHistory | History is a general class for histories |
| CIndividualBeliefJESP | IndividualBeliefJESP stores individual beliefs for the JESP algorithm |
| CIndividualHistory | IndividualHistory represents a history for a single agent |
| CInterface_ProblemToPolicyDiscrete | Interface_ProblemToPolicyDiscrete is an interface from discrete problems to policies |
| CInterface_ProblemToPolicyDiscretePure | Interface_ProblemToPolicyDiscretePure is an interface from discrete problems to pure policies |
| CJESPDynamicProgrammingPlanner | JESPDynamicProgrammingPlanner plans with the DP JESP algorithm |
| CJESPExhaustivePlanner | JESPExhaustivePlanner plans with the Exhaustive JESP algorithm |
| CJointAction | JointAction represents a joint action |
| CJointActionDiscrete | JointActionDiscrete represents discrete joint actions |
| CJointActionHistory | JointActionHistory represents a joint action history |
| CJointActionHistoryTree | JointActionHistoryTree is a wrapper for JointActionHistory |
| CJointActionObservationHistory | JointActionObservationHistory represents a joint action observation history |
| CJointActionObservationHistoryTree | JointActionObservationHistoryTree is derived from TreeNode, and similar to ObservationHistoryTree: |
| CJointBelief | JointBelief stores a joint belief, represented as a regular (dense) vector of doubles |
| CJointBeliefEventDriven | JointBeliefEventDriven stores a joint belief, represented as a regular (dense) vector of doubles |
| CJointBeliefInterface | JointBeliefInterface represents an interface for joint beliefs |
| CJointBeliefSparse | JointBeliefSparse represents a sparse joint belief |
| CJointHistory | JointHistory represents a joint history, i.e., a history for each agent |
| CJointObservation | JointObservation is represents joint observations |
| CJointObservationDiscrete | JointObservationDiscrete represents discrete joint observations |
| CJointObservationHistory | JointObservationHistory represents a joint observation history |
| CJointObservationHistoryTree | JointObservationHistoryTree is a class that represents a wrapper for the JointObservationHistory class |
| CJointPolicy | JointPolicy is a class that represents a joint policy |
| CJointPolicyDiscrete | JointPolicyDiscrete is a class that represents a discrete joint policy |
| CJointPolicyDiscretePure | JointPolicyDiscretePure is represents a pure joint policy for a discrete MADP |
| CJointPolicyPureVector | JointPolicyPureVector represents a discrete pure joint policy |
| CJointPolicyPureVectorForClusteredBG | JointPolicyPureVectorForClusteredBG represents a joint policy for a clustered CBG |
| CJointPolicyValuePair | JointPolicyValuePair is a wrapper for a partial joint policy and its heuristic value |
| CJPolComponent_VectorImplementation | JPolComponent_VectorImplementation implements functionality common to several joint policy implementations |
| CJPPVIndexValuePair | JPPVIndexValuePair represents a (JointPolicyPureVector,Value) pair |
| CJPPVValuePair | JPPVValuePair represents a (JointPolicyPureVector,Value) pair, which stores the full JointPolicyPureVector |
| CLocalBGValueFunctionBGCGWrapper | LocalBGValueFunctionBGCGWrapper is a class that represents a wrapper for a BayesianGameCollaborativeGraphical such that it implements the LocalBGValueFunctionInterface |
| CLocalBGValueFunctionInterface | LocalBGValueFunctionInterface is a class that represents a local CGBG payoff function |
| CLocalBGValueFunctionVector | LocalBGValueFunctionVector is a vector implementation of LocalBGValueFunctionInterface to represent an  |
| CMADPComponentDiscreteActions | MADPComponentDiscreteActions contains functionality for discrete action spaces |
| CMADPComponentDiscreteObservations | MADPComponentDiscreteObservations contains functionality for discrete observation spaces |
| CMADPComponentDiscreteStates | MADPComponentDiscreteStates is a class that represents a discrete state space |
| CMADPComponentFactoredStates | MADPComponentFactoredStates is a class that represents a factored states space |
| CMADPDiscreteStatistics | MADPDiscreteStatistics is a class that represents an object that can compute some statistics for a MADP Discrete |
| CMADPParser | MADPParser is a general class for parsers in MADP |
| CMaxPlusSolver | MaxPlusSolver is the base class for Max Plus methods, it stores the parameters |
| CMaxPlusSolverForBGs | MaxPlusSolverForBGs solves BG via Max Plus |
| CMDPPolicyIteration | MDPPolicyIteration implements policy iteration for MDPs via GPU |
| CMDPPolicyIterationGPU | MDPPolicyIterationGPU implements policy iteration for MDPs via GPU |
| CMDPSolver | MDPSolver is an interface for MDP solvers |
| CMDPValueIteration | MDPValueIteration implements value iteration for MDPs |
| CMonahanBGPlanner | MonahanBGPlanner is the Bayesian Game version of MonahanPOMDPPlanner |
| CMonahanPlanner | MonahanPlanner provides shared functionality for MonahanPOMDPPlanner and MonahanBGPlanner |
| CMonahanPOMDPPlanner | MonahanPOMDPPlanner implements Monahan's (1982) POMDP algorithm, which basically generates all possible next-step alpha vectors, followed by pruning |
| CMultiAgentDecisionProcess | MultiAgentDecisionProcess is an class that defines the primary properties of a decision process |
| CMultiAgentDecisionProcessDiscrete | MultiAgentDecisionProcessDiscrete is defines the primary properties of a discrete decision process |
| ►CMultiAgentDecisionProcessDiscreteFactoredStates | MultiAgentDecisionProcessDiscreteFactoredStates is a class that represents the dynamics of a MAS with a factored state space |
| CMultiAgentDecisionProcessDiscreteFactoredStatesInterface | MultiAgentDecisionProcessDiscreteFactoredStatesInterface is the interface for factored state problems |
| CMultiAgentDecisionProcessDiscreteInterface | MultiAgentDecisionProcessDiscreteInterface is an abstract base class that defines publicly accessible member functions that a discrete multiagent decision process must implement |
| CMultiAgentDecisionProcessInterface | MultiAgentDecisionProcessInterface is an abstract base class that declares the primary properties of a multiagent decision process |
| CNamedDescribedEntity | NamedDescribedEntity represents named entities |
| CNullPlanner | NullPlanner represents a planner which does nothing, but can be used to instantiate a PlanningUnitDecPOMDPDiscrete |
| CNullPlannerFactored | NullPlannerFactored represents a planner which does nothing, but can be used to instantiate a PlanningUnitDecFactoredPOMDPDiscrete |
| CNullPlannerTOI | NullPlannerTOI represents a planner which does nothing, but can be used to instantiate a PlanningUnitTOIDecPOMDPDiscrete |
| CObservation | Observation represents observations |
| CObservationDiscrete | ObservationDiscrete represents discrete observations |
| CObservationHistory | ObservationHistory represents an action history of a single agent |
| CObservationHistoryTree | ObservationHistoryTree is a wrapper for the ObservationHistory class |
| CObservationModel | ObservationModel represents the observation model in a decision process |
| CObservationModelDiscrete | ObservationModelDiscrete represents a discrete observation model |
| CObservationModelDiscreteInterface | ObservationModelDiscreteInterface represents a discrete observation model |
| CObservationModelMapping | ObservationModelMapping implements an ObservationModelDiscrete |
| CObservationModelMappingSparse | ObservationModelMappingSparse implements an ObservationModelDiscrete |
| COGet | OGet can be used for direct access to the observation model |
| COGet_EventObservationModelMapping | |
| COGet_EventObservationModelMappingSparse | |
| COGet_ObservationModelMapping | OGet_ObservationModelMapping can be used for direct access to a ObservationModelMapping |
| COGet_ObservationModelMappingSparse | OGet_ObservationModelMappingSparse can be used for direct access to a ObservationModelMappingSparse |
| COnlineMDPPlanner | OnlineMDPPlanner provides an abstract base class for online MDP planners |
| COptimalValueDatabase | OptimalValueDatabase provides values of optimal policies for problems, so to be used for verification purposes |
| CParserInterface | ParserInterface is an interface for parsers |
| CParserPOMDPDiscrete | |
| CParserProbModelXML | ParserProbModelXML is a parser for factored Dec-POMDP models written in ProbModelXML |
| CParserTOICompactRewardDecPOMDPDiscrete | ParserTOICompactRewardDecPOMDPDiscrete is a parser for TOICompactRewardDecPOMDPDiscrete |
| CParserTOIDecMDPDiscrete | ParserTOIDecMDPDiscrete is a parser for TOIDecMDPDiscrete |
| CParserTOIDecPOMDPDiscrete | ParserTOIDecPOMDPDiscrete is a parser for TOIDecPOMDPDiscrete |
| CParserTOIFactoredRewardDecPOMDPDiscrete | ParserTOIFactoredRewardDecPOMDPDiscrete is a parser for TransitionObservationIndependentFactoredRewardDecPOMDPDiscrete |
| CPartialJointPolicy | PartialJointPolicy represents a joint policy that is only specified for t time steps instead of for every time step |
| CPartialJointPolicyDiscretePure | PartialJointPolicyDiscretePure is a discrete and pure PartialJointPolicy |
| CPartialJointPolicyPureVector | PartialJointPolicyPureVector implements a PartialJointPolicy using a mapping of history indices to actions |
| CPartialJointPolicyValuePair | PartialJointPolicyValuePair is a wrapper for a partial joint policy and its heuristic value |
| CPartialJPDPValuePair | PartialJPDPValuePair represents a (PartialJointPolicyDiscretePure,Value) pair, which stores the full PartialJointPolicyDiscretePure |
| CPartialJPPVIndexValuePair | PartialJPPVIndexValuePair represents a (PartialJointPolicyPureVector,Value) pair |
| CPartialPolicyPoolInterface | PartialPolicyPoolInterface is an interface for PolicyPools containing Partial Joint Policies |
| CPartialPolicyPoolItemInterface | PartialPolicyPoolItemInterface is a class that gives the interface for a PolicyPoolItem |
| CPDDiscreteInterface | PDDiscreteInterface is an abstract base class that represents a joint probability distribution  |
| CPerseus | Perseus contains basic functionality for the Perseus planner |
| CPerseusBGNSPlanner | PerseusBGNSPlanner implements the Perseus planning algorithm for BGs with non-stationary QFunctions |
| CPerseusBGPlanner | PerseusBGPlanner implements the Perseus planning algorithm for BGs |
| CPerseusBGPOMDPPlanner | PerseusBGPOMDPPlanner implements the Perseus planning algorithm with for mixed BG/POMDP backups |
| CPerseusConstrainedPOMDPPlanner | The PerseusConstrainedPOMDPPlanner is a Perseus variant which skips action selection if the agent receives a "false-negative" observation, which in practice means that the agent cannot react to an event which it failed to detect |
| CPerseusNonStationary | PerseusNonStationary is Perseus for non-stationary policies |
| CPerseusNonStationaryQPlanner | PerseusNonStationaryQPlanner is a Perseus planner that uses non-stationary QFunctions |
| CPerseusPOMDPPlanner | PerseusPOMDPPlanner implements the Perseus planning algorithm for POMDPs |
| CPerseusQFunctionPlanner | PerseusQFunctionPlanner is a Perseus planner that uses QFunctions |
| CPerseusStationary | PerseusStationary is Perseus for stationary policies |
| CPerseusWeightedPlanner | PerseusWeightedPlanner implements the Perseus planning algorithm with a weighted BG/POMDP backup |
| CPlanningUnit | PlanningUnit represents a planning unit, i.e., a planning algorithm |
| CPlanningUnitDecPOMDPDiscrete | PlanningUnitDecPOMDPDiscrete represents a planning unit for discrete Dec-POMDPs |
| CPlanningUnitFactoredDecPOMDPDiscrete | PlanningUnitFactoredDecPOMDPDiscrete is a class that represents a planning unit for factored discrete Dec-POMDPs |
| CPlanningUnitMADPDiscrete | PlanningUnitMADPDiscrete represents a Planning unit for a discrete MADP (discrete actions, observations and states) |
| CPlanningUnitMADPDiscreteParameters | PlanningUnitMADPDiscreteParameters stores parameters of PlanningUnitMADPDiscrete |
| CPlanningUnitTOIDecPOMDPDiscrete | PlanningUnitTOIDecPOMDPDiscrete represents a planning unit for transition observation independent discrete Dec-POMDPs |
| CPolicy | Policy is a class that represents a policy for a single agent |
| CPolicyDiscrete | PolicyDiscrete is a class that represents a discrete policy |
| CPolicyDiscretePure | PolicyDiscretePure is an abstract class that represents a pure policy for a discrete MADP |
| CPolicyPoolInterface | PolicyPoolInterface is an interface for PolicyPools containing fully defined Joint Policies |
| CPolicyPoolItemInterface | PolicyPoolItemInterface is a class that gives the interface for a PolicyPoolItem |
| CPolicyPoolJPolValPair | PolicyPoolJPolValPair is a policy pool with joint policy - value pairs |
| CPolicyPoolPartialJPolValPair | PolicyPoolJPolValPair is a policy pool with partial joint policy - value pairs |
| CPolicyPureVector | PolicyPureVector is a class that represents a pure (=deterministic) policy |
| CPOMDPDiscrete | POMDPDiscrete models discrete POMDPs |
| CPOSG | POSG is a simple implementation of POSGInterface |
| CPOSGDiscrete | POSGDiscrete represent a discrete POSG model |
| CPOSGDiscreteInterface | POSGDiscreteInterface is the interface for a discrete POSG model: it defines the set/get reward functions |
| CPOSGInterface | POSGInterface is an interface for POSGs |
| ►CProblem_CGBG_FF | Problem_CGBG_FF reprents a generalized single-shot fire fighting problem |
| CProblemAloha | |
| CProblemDecTiger | ProblemDecTiger implements the DecTiger problem |
| CProblemDecTigerWithCreaks | ProblemDecTigerWithCreaks implements a variation of the DecTiger problem, in which an agent can hear whether the other agent has tried to open a door |
| CProblemFireFighting | ProblemFireFighting is a class that represents the firefighting problem as described in refGMAA (DOC-references.h) |
| CProblemFireFightingFactored | ProblemFireFightingFactored is a factored implementation of the FireFighting problem introduced in (Oliehoek, Spaan, Vlassis, JAIR 32, 2008) |
| CProblemFireFightingGraph | ProblemFireFightingGraph is an implementation of the FactoredFireFighting problem introduced in (Oliehoek, Spaan, Whiteson, Vlassis, AAMAS 2008) |
| CProblemFOBSFireFightingFactored | This is a template of how to implement a fully-observable problem from scratch (by deriving from FactoredMMDPDiscrete) |
| CProblemFOBSFireFightingGraph | ProblemFOBSFireFightingGraph is an implementation of a fully overservable FireFightingGraph problem |
| CQAlphaVector | QAlphaVector implements a QFunctionJointBelief using an alpha-vector based value function loaded from disk |
| CQAV | QAV implements a QFunctionJointBelief using a planner based on alpha functions, for instance the Perseus planners |
| CQAVParameters | |
| CQBG | QBG is a class that represents the QBG heuristic |
| CQBGPlanner_TreeIncPruneBnB | QBGPlanner_TreeIncPruneBnB computes vector-based QBG functions using tree-based incremental pruning |
| CQFunction | QFunction is an abstract base class containing nothing |
| CQFunctionForDecPOMDP | QFunctionForDecPOMDP is a class that represents a Q function for a Dec-POMDP |
| CQFunctionForDecPOMDPInterface | QFunctionForDecPOMDPInterface is a class that represents a Q function for a Dec-POMDP |
| CQFunctionForFactoredDecPOMDP | QFunctionForFactoredDecPOMDP is a base class for the implementation of a QFunction for a Factored DecPOMDP |
| CQFunctionForFactoredDecPOMDPInterface | QFunctionForFactoredDecPOMDPInterface is a class that represents the interface for a QFunction for a Factored DecPOMDP |
| CQFunctionInterface | QFunctionInterface is an abstract class for all Q-Functions |
| CQFunctionJAOH | QFunctionJAOH represents a Q-function that operates on joint action-observation histories |
| CQFunctionJAOHInterface | QFunctionJAOHInterface is a class that is an interface for heuristics of the shape Q(JointActionObservationHistory, JointAction) |
| CQFunctionJAOHTree | QFunctionJAOHTree is represents QFunctionJAOH which store Qvalues in a tree |
| CQFunctionJointBelief | QFunctionJointBelief represents a Q-function that operates on joint beliefs |
| CQFunctionJointBeliefInterface | QFunctionJointBeliefInterface is an interface for QFunctionJointBelief |
| CQHybrid | QHybrid is a class that represents the QHybrid heuristic |
| CQMDP | QMDP is a class that represents the QMDP heuristic |
| CQMonahanBG | QMonahanBG implements a QFunctionJAOH using MonahanBGPlanner |
| CQMonahanPOMDP | QMonahanPOMDP implements a QFunctionJAOH using MonahanPOMDPPlanner |
| CQPOMDP | QPOMDP is a class that represents the QPOMDP heuristic |
| CQTable | QTable implements QTableInterface using a full matrix |
| CQTableInterface | QTableInterface is the abstract base class for Q(., a) functions |
| CQTreeIncPruneBG | QTreeIncPruneBG implements a QFunctionJAOH using TreeIncPruneBGPlanner |
| CRewardModel | RewardModel represents the reward model in a decision process |
| CRewardModelDiscreteInterface | RewardModelDiscreteInterface is an interface for discrete reward models |
| CRewardModelMapping | RewardModelMapping represents a discrete reward model |
| CRewardModelMappingSparse | RewardModelMappingSparse represents a discrete reward model |
| CRewardModelMappingSparseMapped | RewardModelMappingSparseMapped represents a discrete reward model |
| CRewardModelTOISparse | RewardModelTOISparse represents a discrete reward model based on vectors of states and actions |
| CRGet | RGet can be used for direct access to a reward model |
| CRGet_RewardModelMapping | RGet can be used for direct access to a RewardModelMapping |
| CRGet_RewardModelMappingSparse | RGet can be used for direct access to a RewardModelMappingSparse |
| CScope | |
| CSimulation | Simulation is a class that simulates policies in order to test their control quality |
| CSimulationAgent | SimulationAgent represents an agent in for class Simulation |
| CSimulationDecPOMDPDiscrete | SimulationDecPOMDPDiscrete simulates policies in DecPOMDPDiscrete's |
| CSimulationFactoredDecPOMDPDiscrete | SimulationFactoredDecPOMDPDiscrete simulates policies in FactoredDecPOMDPDiscrete's |
| CSimulationResult | SimulationResult stores the results from simulating a joint policy, the obtained rewards in particular |
| CSimulationTOIDecPOMDPDiscrete | SimulationTOIDecPOMDPDiscrete simulates policies in TOIDecPOMDPDiscrete's |
| CState | State is a class that represent states |
| CStateDiscrete | StateDiscrete represents discrete states |
| CStateDistribution | StateDistribution is an interface for probability distributions over states |
| CStateDistributionVector | StateDistributionVector represents a probability distribution over states as a vector of doubles |
| CStateFactorDiscrete | StateFactorDiscrete is a class that represents a state variable, or factor |
| CSystemOfLinearEquationsSolver | |
| CTGet | TGet can be used for direct access to the transition model |
| CTGet_TransitionModelMapping | TGet_TransitionModelMapping can be used for direct access to a TransitionModelMapping |
| CTGet_TransitionModelMappingSparse | TGet_TransitionModelMappingSparse can be used for direct access to a TransitionModelMappingSparse |
| CTimedAlgorithm | TimedAlgorithm allows for easy timekeeping of parts of an algorithm |
| ►CTiming | Timing provides a simple way of timing code |
| CTOICompactRewardDecPOMDPDiscrete | TOICompactRewardDecPOMDPDiscrete is a class that represents a transition observation independent Dec-POMDP, in which the reward is the sum of each agent's individual reward plus some shared reward |
| CTOIDecMDPDiscrete | TOIDecMDPDiscrete is a class that represents a transition observation indepedent discrete DecMDP |
| CTOIDecPOMDPDiscrete | TOIDecPOMDPDiscrete is a class that represents a transition observation independent discrete DecPOMDP |
| CTOIFactoredRewardDecPOMDPDiscrete | TOIFactoredRewardDecPOMDPDiscrete is a class that represents a transition observation independent Dec-POMDP, in which the reward is the sum of each agent's individual reward plus some shared reward |
| CTransitionModel | TransitionModel represents the transition model in a decision process |
| CTransitionModelDiscrete | TransitionModelDiscrete represents a discrete transition model |
| CTransitionModelDiscreteInterface | TransitionModelDiscreteInterface represents a discrete transition model |
| CTransitionModelMapping | TransitionModelMapping implements a TransitionModelDiscrete |
| CTransitionModelMappingSparse | TransitionModelMappingSparse implements a TransitionModelDiscrete |
| CTransitionObservationIndependentMADPDiscrete | TransitionObservationIndependentMADPDiscrete is an base class that defines the primary properties of a Transition and Observation independent decision process |
| CTreeIncPruneBGPlanner | TreeIncPruneBGPlanner computes vector-based QBG functions using tree-based incremental pruning |
| CTreeNode | TreeNode represents a node in a tree of histories, for instance observation histories |
| CTwoStageDynamicBayesianNetwork | TwoStageDynamicBayesianNetwork (2DBN) is a class that represents the transition and observation model for a factored MADP |
| CType | Type is an abstract class that represents a Type (e.g |
| CType_AOHIndex | Type_AOHIndex is a implementation (extenstion) of Type and represents a type in e.g |
| CType_PointerTuple | Type_PointerTuple is a implementation (extenstion) of Type and represents a type in e.g |
| CTypeCluster | TypeCluster is a class that represents a cluster of Types |
| CValueFunction | ValueFunction is a class that represents a value function of a joint policy |
| CValueFunctionDecPOMDPDiscrete | ValueFunctionDecPOMDPDiscrete represents and calculates the value function of a (pure) joint policy for a discrete Dec-POMDP |
