Namespace sdm

Class List > sdm

Namespace grouping all tools required for sequential decision making. More...

Namespaces

Type	Name
namespace	algo Namespace grouping functions to manipulate algorithms.
namespace	ast Namespace that is used by the parser.
namespace	common Namespace grouping all common functions to the whole project.
namespace	config Namespace grouping a set of configurations.
namespace	exception Namespace grouping all exceptions.
namespace	iterator Namespace grouping all SDMS iterators.
namespace	nn Namespace grouping all neural networks definitions.
namespace	parser Namespace grouping all functions for parsing files.
namespace	tools Namespace grouping different kind of tools.
namespace	world Namespace grouping functions to manipulate problems.

Classes

Type	Name
class	ActionVFBase
class	ActionVFInterface
class	ActionVFMaxplan
class	ActionVFMaxplanLP
class	ActionVFMaxplanLPSerial
class	ActionVFMaxplanSerial
class	ActionVFMaxplanWCSP
class	ActionVFSawtoothLP
class	ActionVFSawtoothLPSerial
class	ActionVFSawtoothWCSP
class	ActionVFTabulaire
class	Algorithm The public interface common to all algorithms in SDM'Studio .
class	AlphaStar The class for the algorithm A* (opens new window) .
class	BackupBase <TData>
class	BackupInterface <TData>
class	BackupInterfaceForValueFunction
class	BackwardInduction The algorithm Backward Induction (opens new window) .
class	BaseAction <typename TAction> A base class inheriting from the Action interface.
class	BaseBeliefMDP <TBelief> This class provides a way to transform a POMDP into beliefMDP formalism.
struct	BaseItem <class TItem> A base class inheriting from the Item interface.
class	BaseLogger This class provide a common interface for all loggers.
class	BaseObservation <typename TObservation> A base class inheriting from the Observation interface.
class	BaseOccupancyMDP <class TOccupancyState> This class provides a way to transform a Dec-POMDP into an occupancy MDP formalism.
class	BasePointSetValueFunction <Hash, KeyEqual>
class	BaseRelaxedValueFunction
class	BaseSerialInterface
class	BaseState <TState> A base class inheriting from the State interface.
class	BaseTabularValueFunction <Hash, KeyEqual>
class	BaseValueFunction <TInput> This class is the abstract class of all kind of value functions. All {state,action,q}-value function must derived this class.
class	Belief
class	Belief2OccupancyValueFunction
class	BeliefDefault
class	BeliefInterface A common interface for objects that represent a belief.
class	BinaryFunction <TInput1, TInput2, TOutput>
class	BlindInitializer This initializer calculates the initial lower bound ${V}\_0$ using the blind policy method [Hauskrecht, 1997]. Trey Smith and Reid Simmons used this initialization procedure in https://arxiv.org/pdf/1207.4166.pdf (opens new window) .
class	BoostSerializable <SerializableClass>
class	BoundInitializer This initializer initializes a value function to the estimation of the value if we get a constant reward at every timestep.
class	CSVLogger The CSV logger will print logs/data in a file with csv format. This logger can be used to save training data.
class	CompressibleOccupancyStateInterface
class	DecentralizedLP
class	DecisionProcessInterface The class for Discrete Markov Decision Processes.
class	DecisionRule A public interface for decision rules. Contains all the methods that must be implemented to well define a decision rule in SDMS.
class	DeterministicDecisionRule This class provide a way to manipulate data relative to a deterministic decision rule.
class	DiscreteDistribution <T>
class	DiscreteSpace The discrete space class give a way to keep all possible values of a finite space.
class	Distribution <T>
class	EpsGreedy
class	ExperienceMemory
class	ExperienceMemoryInterface
class	Exploration
class	FileLogger The file logger will print logs/data in a file.
class	Function <TInput, TOutput>
class	FunctionReward This class provides getters and setters for the reward model.
class	FunctionSpace <typename TFunction> The class for function spaces. This is helpfull in case we need to enumerate all possible functions (only usable when input space and output space are DiscreteSpace ).
class	Graph <TNode, TEdge> A structure to manipulate graphs.
class	GraphNode <typename TNode, typename TEdge> Node of graphs.
class	GymInterface
class	HSVI Heuristic Search Value Iteration (HSVI) (opens new window) and its extensions (FB-HSVI, one-sidedHSVI ).
class	HierarchicalMPOMDP The Hierarchical MPOMDP is a transformation of a standardMPOMDP assuming there exists a hierarchy among agents.
class	HierarchicalOccupancyMDP
class	HistoryInterface A common interface for objects that represent a history.
class	HistoryTree History class that use a representation by tree.
class	HyperplanValueFunction
class	IncrementalValueFunction <typename TState, typename TAction, typename TValueFunction>
class	Initializer Abstract class for initializer.
class	InitializerFactory The InitializerFactor class facilitates users to interact and instanciate value function initializers. Some of the available initializers are : MinInitializer ,MaxInitializer ,BlindInitializer ,ZeroInitializer . For a complete list of initializer, you can use : std::cout <<InitializerFactory::available() << std::endl;.
class	InteractiveWorld
class	Item A public interface for actions, states and observations.
class	ItemPair <TItem_1, TItem_2, SuperClass>
class	Iterator <typename TItem> Common interface to all SDMS Iterators.
class	Joint <T> This class is used for joint objects. It can be a JointHistoryTree , a JointObservation, a JointAction, etc.
class	JointDeterministicDecisionRule This class provide a way to manipulate a function that maps joint histories to joint actions.
class	JointHistoryInterface A common interface for objects that represent a joint history.
class	JointHistoryTree Joint history class that use a representation by tree.
class	LPBase
class	LPInterface
class	Logger The main logger. This logger will print logs with a given format on the output stream.
class	MDP The class for Discrete Markov Decision Processes.
class	MDPInitializer The MDP initializer enables to initialize the upper bound inHSVI with the underlyingMDP optimal value function. This is a common usage inHSVI to use the solution of a relaxation of the problem in order to get a accurate upper bound (see also the classPOMDPInitializer ).
class	MDPInterface The class for Discrete Markov Decision Processes.
class	MMDP The class for Discrete Markov Decision Processes.
class	MMDPInterface The class for Discrete Markov Decision Processes.
class	MPOMDP The class for Discrete Partially Observable Markov Decision Processes.
class	MPOMDPInterface The class for Discrete Markov Decision Processes.
class	MappedMatrix <TLig, TCol, TValue> Mapped matrices are matrices that use map to store values. Can be view as a sparse matrix with templated indexes.
class	MappedVector <TIndex, T, Hash, KeyEqual> Mapped vectors are vectors with specific type of indexes. They are represented by a map.
class	MatrixInterface <typename TCol, typename TLig, typename TValue> The Matrix interface. To be considered as a matrix in SDM'Studio, a class must implement all the following functions.
class	MaxInitializer This initializer initializes a value function to the best value. This is an optimistic initialization.
class	MaxPlanBackup
class	MinInitializer This initializer initializes a value function to the worst value. This is a pessimistic initialization.
class	MultiDiscreteSpace This class provide a way to instantiate multi discrete space (i.e. list of discrete spaces). Typically it is used to store a set of spaces, one by agent (i.e. action_spaces in POSG). This can be view as a set of discrete spaces or as a discrete space of joint items.
class	MultiLogger The multi logger will print logs in several loggers.
class	MultiSpace A multi-space is a set a spaces.
class	NetworkedDistributedPOMDP
class	NetworkedDistributedPOMDPInterface
class	Observation A public interface for observations.
class	ObservationDynamicsInterface This class provides a common interface for every models of observation dynamics.
class	OccupancyState An occupancy state refers to the complete knowledge the central planner have access to take decisions.
class	OccupancyStateInterface A common interface for objects that represent an occupancy state.
class	POMDP The class for Discrete Partially Observable Markov Decision Processes.
class	POMDPInitializer The POMDP initializer enables to initialize the upper bound inHSVI with the underlyingPOMDP optimal value function.
class	POMDPInterface The class for Discrete Markov Decision Processes.
class	PrivateHierarchicalOccupancyMDP
class	PrivateHierarchicalOccupancyMDPWithHistory
class	PrivateOccupancyState A private occupancy state is an occupancy state (i.e. $p(s\_t, \theta^{-i}\_{t} \mid \iota\_t, \theta\_t^i)$ ).
class	QInitializer <class TInput> Abstract class for initializer.
class	QLearning <class TInput> Q-Learning and its extensions (DQN, etc).
class	QValueBackupInterface
class	QValueFunction <TInput> This class is the abstract class of value function. All value function must derived this class.
class	QValueFunctionConditioning <TCondition, TState>
class	RecursiveMap <class T0, class T1, Ts> The recursive map class (i.e. map<T0, map<T1, ..... , map<TN-1, TN>)
class	RecursiveMap< T0, T1 > <class T0, class T1> RecursiveMap specialization when it is simple map.
class	RecursiveMap< T0, T1, T2, Ts... > <class T0, class T1, class T2, Ts>
class	RelaxedValueFunction
class	ReplayMemory
class	RewardInterface This class provides a common interface for every models of reward.
class	SerialInterface A common interface for objects that are serialized.
class	SerialMMDPInterface The class for Discrete Markov Decision Processes.
class	SerialMPOMDPInterface The class for Discrete Markov Decision Processes.
class	SerialOccupancyInterface
class	SerialOccupancyMDP
class	SerialOccupancyState
class	SerialProblemInterface
class	SerializedMMDP
class	SerializedMPOMDP
class	SerializedState
struct	Set <class T>
class	SolvableByDP Public interface that must be implemented by all transformed problems that can be solved using HSVI (i.e. beliefMDP, occupancyMDP, occupancyGame, etc).
class	SolvableByHSVI Public interface for problems that can be solved using HSVI (i.e. beliefMDP, occupancyMDP, occupancyGame, etc).HSVI can be used to solve the problem that implement this interface.
class	SolvableByMDP The class for Markov Decision Processes.
class	Space This class is an abstract interface that all spaces should inherite.
class	State A public interface for states.
class	State2OccupancyValueFunction
class	StateDynamicsInterface This class provides a common interface for every models of state dynamics.
class	StateGraph A graph that keep all beliefs.
class	StdLogger The standard logger will print logs on the standard output stream.
class	StochasticDecisionRule The stochastic decision rule class. This class is a function that maps generic states distribution over generic actions.
class	TabularBackup
class	TabularObservationDynamics Tabular observation dynamics.
class	TabularObservationDynamicsAS _Tabular representation for the observation dynamics p(o'
class	TabularObservationDynamicsS _Tabular representation for the observation dynamics p(o'
class	TabularObservationDynamicsSAS _Tabular representation for the observation dynamics p(o'
class	TabularQValueBackup
class	TabularQValueFunction <TInput>
class	TabularQValueFunctionConditioning <class TCondition, class TState>
class	TabularReward This class provide a way to represent the reward model with a tabular representation.
class	TabularStateDynamics Tabular representation for the state dynamics.
class	TemporalFunction <typename TFunction>
class	TensorImpl <I> The vector interface. To be considered as a vector in SDM'Studio, a class must implement all the following functions.
class	TransformedMPOMDP
class	Tree <T> Generic Tree class.
class	ValueFunction This class is the abstract class of value function. All value function must derived this class.
class	ValueFunctionFactory <typename TState, typename TAction> The ValueFunctionFactory class facilitates users to interact and instanciate value functions.
class	ValueInitializer <class TInput> This initializer initializes a value function to a constant value.
class	ValueIteration Value Iteration (opens new window) forMDP .
class	VarNaming
class	Variations <typename TFunction> Iterator ofVariations .
class	VectorInterface <I, T> The vector interface. To be considered as a vector in SDM'Studio, a class must implement all the functions of the interface.
class	World
class	ZeroInitializer <class TInput> This initializer initializes a value function to zero.
struct	equal_container <class T>
struct	equal_from_ptr <typename T>
struct	hash_container <class T>
struct	hash_from_ptr <typename T>
class	sdmsMatrix <TLig, TCol, TValue, TBaseMatrix, TBaseVector>
class	sdmsVector <class I, class T, class TBaseVector> Create a SDMS Vector. A SMDS Vector is used to optimize the calculation, however, you have to be careful when using it because it's not possible to add element after the initialization.

Public Types

Type	Name
enum	@0
typedef ItemPair< TAction_1, TAction_2, Action >	ActionPair
typedef BaseBeliefMDP< Belief >	BeliefMDP
typedef BaseObservation< double >	ContinuousObservation BaseObservation class with typedouble __
typedef BaseState< double >	ContinuousState BaseState class with typedouble __
enum	Criterion
typedef MPOMDP	DecPOMDP
typedef sdmsMatrix< TLig, TCol, TValue, boost::numeric::ublas::matrix< TValue >, DenseVector< TCol, TValue > >	DenseMatrix Dense matrix are plain matrix.
typedef sdmsVector< I, T, boost::numeric::ublas::vector< T > >	DenseVector Dense vector are standard vector.
typedef BaseAction< number >	DiscreteAction BaseAction class with typenumber __
typedef BaseObservation< number >	DiscreteObservation BaseObservation class with typenumber __
typedef BaseObservation< std::string >	DiscreteObservationString BaseObservation class with typestd::string __
typedef BaseState< number >	DiscreteState BaseState class with typenumber __
typedef BaseState< std::string >	DiscreteStateString BaseState class with typestd::string __
typedef Iterator< std::shared_ptr< Item > >	ItemIterator
typedef BaseAction< Joint< std::shared_ptr< Action > >>	JointAction BaseAction class with typeJoint <std::shared_ptr<Action>> .
typedef StatePair< std::shared_ptr< JointHistoryInterface >, std::shared_ptr< BeliefInterface > >	JointHistoryBeliefPair
typedef StatePair< std::shared_ptr< JointHistoryInterface >, std::shared_ptr< Action > >	JointHistoryJointActionPair
typedef StatePair< std::shared_ptr< JointHistoryInterface >, std::shared_ptr< State > >	JointHistoryStatePair
enum	Metric
typedef BaseItem< number >	NumberItem
typedef BaseOccupancyMDP< OccupancyState >	OccupancyMDP
typedef std::pair< T, U >	Pair sdm::Pair is an alias tostd::pair (opens new window) class with added functionnalities.
typedef BasePointSetValueFunction< std::hash< std::shared_ptr< State > >, std::equal_to< std::shared_ptr< State > >>	PointSetValueFunction
typedef BasePointSetValueFunction< sdm::hash_from_ptr< State >, sdm::equal_from_ptr< State > >	PointSetValueFunction2
typedef StatePair< std::shared_ptr< OccupancyStateInterface >, std::shared_ptr< JointHistoryInterface > >	PrivateHierarchicalOccupancyStateJointHistoryPair
typedef BaseValueFunction< Pair< std::shared_ptr< State >, std::shared_ptr< Action > >>	QValueFunctionBase
typedef typename RecursiveMap< T0, T1, Ts... >::type	RecursiveMap_t
typedef sdmsMatrix< TLig, TCol, TValue, boost::numeric::ublas::mapped_matrix< TValue >, SparseVector< TCol, TValue > >	SparseMatrix Sparse matrix are matrix that store only non-zero values.
typedef sdmsVector< I, T, boost::numeric::ublas::mapped_vector< T > >	SparseVector Sparse vector are vectors that store only non-zero values.
typedef ItemPair< TState_1, TState_2, State >	StatePair
enum	Statistic
typedef BaseItem< std::string >	StringItem
enum	TState_t
typedef BaseTabularValueFunction< std::hash< std::shared_ptr< State > >, std::equal_to< std::shared_ptr< State > >>	TabularValueFunction
typedef BaseTabularValueFunction< sdm::hash_from_ptr< State >, sdm::equal_from_ptr< State > >	TabularValueFunction2
typedef std::tuple< T... >	Tuple sdm::Tuple is an alias tostd::tuple (opens new window) class with added functionnalities. It is a generalization ofsdm::Pair .
enum	TypeAction
enum	TypeOfMaxPlanPrunning
enum	TypeOfResolution
enum	TypeOfSawtoothPrunning
enum	TypeSawtoothLinearProgram
enum	TypeSoftmax
enum	TypeState
typedef BaseValueFunction< std::shared_ptr< State > >	ValueFunctionBase
typedef boost::bimaps::bimap< std::string, sdm::size_t >	bimap
typedef boost::bimaps::bimap< TItem, sdm::size_t >	bimap_item_index
typedef bimap::value_type	name2index
typedef unsigned short	number
typedef std::tuple< state, action, double, state >	sars_transition Transition of state, action, reward, next_state.
typedef std::size_t	size_t
typedef typename RecursiveMap< T0, T1, Ts... >::value_type	value_t

Public Attributes

Type	Name
const size_t	ERROR_IN_COMMAND_LINE = = 1
const size_t	ERROR_UNHANDLED_EXCEPTION = = 2
const std::shared_ptr< Observation >	NO_OBSERVATION Default observation.
const size_t	SUCCESS = = 0

Public Functions

Type	Name
std::shared_ptr< T >	cast (const std::shared_ptr< I > & item)
std::shared_ptr< Initializer >	createInstance (std::shared_ptr< SolvableByHSVI > world)
std::shared_ptr< ValueFunction< TState, TAction > >	createInstance ()
std::shared_ptr< Initializer >	createInstanceAlgoInit (std::shared_ptr< SolvableByHSVI > world, std::string algo_name, double error, int trials)
std::shared_ptr< Initializer >	createInstanceMDPValueIterationInit (std::shared_ptr< SolvableByHSVI > world)
std::shared_ptr< Initializer >	createInstanceTabMDPInit (std::shared_ptr< SolvableByHSVI > world)
std::shared_ptr< Initializer >	createInstanceTabPOMDPInit (std::shared_ptr< SolvableByHSVI > world)
virtual TypeAction	getTypeAction () const
void	hash_combine (std::size_t & seed, T const & v)
void	hash_combine (std::size_t & seed, double const & v)
std::shared_ptr< Initializer >	makeInitializer (std::string init_name, std::shared_ptr< SolvableByHSVI > world)
std::shared_ptr< Initializer< TState, TAction > >	makeValueFunction (std::string init_name)
std::ostream &	operator<< (std::ostream & os, const sdm::Pair< T, U > & pair)
std::ostream &	operator<< (std::ostream & os, sdm::Tuple< T... > const & tuple)
std::ostream &	operator<< (std::ostream & os, const std::vector< T > & v)
virtual std::string	str () const = 0
void	test (std::vector< std::string > all_formalism={"mdp"}, std::vector< std::string > all_problem={"mabc"}, std::vector< int > all_horizon={2}, std::vector< double > all_discount={1}, std::vector< std::string > upper_bound_name={""}, std::vector< std::string > lower_bound_name={""}, std::vector< std::string > all_lower__init_name={"MinInitializer"}, std::vector< std::string > all_upper_init_name={"MaxInitializer"}, std::vector< int > all_truncation={2}, std::vector< std::string > all_sawtooth_current_type_of_resolution={"BigM"}, std::vector< number > all_sawtooth_BigM={1000}, std::vector< std::string > all_sawtooth_type_of_linear_program={"Full"}, std::vector< TypeOfMaxPlanPrunning > all_type_of_maxplan_prunning={TypeOfMaxPlanPrunning::PAIRWISE}, std::vector< int > all_freq_prunning_lower_bound={-1}, std::vector< TypeOfSawtoothPrunning > all_type_of_sawtooth_pruning={TypeOfSawtoothPrunning::NONE}, std::vector< int > all_freq_prunning_upper_bound={-1}, int mean=2, std::string filepath="../data/world/dpomdp/", std::string save_path="../../run/Resultat/resultat.csv") This function is utilized to do precise large scale experimentation.
virtual std::shared_ptr< DecisionRule >	toDecisionRule () A public interface for actions.
virtual std::shared_ptr< JointDeterministicDecisionRule >	toJointDeterministicDecisionRule () Cast the action into a joint decision rule.

Detailed Description

Namespace grouping all tools required for sequential decision making.

Public Types Documentation

enum @0

enum sdm::@0 {
    STANDARD,
    XML,
    JSON
};

typedef ActionPair

using sdm::ActionPair = typedef ItemPair<TAction_1, TAction_2, Action>;

typedef BeliefMDP

using sdm::BeliefMDP = typedef BaseBeliefMDP<Belief>;

typedef ContinuousObservation

using sdm::ContinuousObservation = typedef BaseObservation<double>;

typedef ContinuousState

using sdm::ContinuousState = typedef BaseState<double>;

enum Criterion

enum sdm::Criterion {
    COST_MIN,
    REW_MAX
};

typedef DecPOMDP

using sdm::DecPOMDP = typedef MPOMDP;

typedef DenseMatrix

using sdm::DenseMatrix = typedef sdmsMatrix<TLig, TCol, TValue, boost::numeric::ublas::matrix<TValue>, DenseVector<TCol, TValue> >;

Template parameters:

• TLig Type of lines
• TCol Type of columns

typedef DenseVector

using sdm::DenseVector = typedef sdmsVector<I, T, boost::numeric::ublas::vector<T> >;

Template parameters:

• I Type of index
• T Type of value

typedef DiscreteAction

using sdm::DiscreteAction = typedef BaseAction<number>;

typedef DiscreteObservation

using sdm::DiscreteObservation = typedef BaseObservation<number>;

typedef DiscreteObservationString

using sdm::DiscreteObservationString = typedef BaseObservation<std::string>;

typedef DiscreteState

using sdm::DiscreteState = typedef BaseState<number>;

typedef DiscreteStateString

using sdm::DiscreteStateString = typedef BaseState<std::string>;

typedef ItemIterator

using sdm::ItemIterator = typedef Iterator<std::shared_ptr<Item> >;

typedef JointAction

using sdm::JointAction = typedef BaseAction<Joint<std::shared_ptr<Action> >>;

typedef JointHistoryBeliefPair

using sdm::JointHistoryBeliefPair = typedef StatePair<std::shared_ptr<JointHistoryInterface>, std::shared_ptr<BeliefInterface> >;

typedef JointHistoryJointActionPair

using sdm::JointHistoryJointActionPair = typedef StatePair<std::shared_ptr<JointHistoryInterface>, std::shared_ptr<Action> >;

typedef JointHistoryStatePair

using sdm::JointHistoryStatePair = typedef StatePair<std::shared_ptr<JointHistoryInterface>, std::shared_ptr<State> >;

enum Metric

enum sdm::Metric {
    CUMULATIVE_REWARD_PER_STEP,
    CUMULATIVE_REWARD_PER_EPISODE,
    AVERAGE_EPISODE_REWARD,
    AVERAGE_EPISODE_VALUE,
    MEDIAN_EPISODE_REWARD,
    CUMULATIVE_STEPS_PER_EPISODE,
    STEPS_PER_EPISODE
};

Enumerator for the types of statistics that can be plotted.

typedef NumberItem

using sdm::NumberItem = typedef BaseItem<number>;

typedef OccupancyMDP

using sdm::OccupancyMDP = typedef BaseOccupancyMDP<OccupancyState>;

typedef Pair

using sdm::Pair = typedef std::pair<T, U>;

Template parameters:

• T the type of the first element that the pair stores.
• U the type of the second element that the pair stores.

typedef PointSetValueFunction

using sdm::PointSetValueFunction = typedef BasePointSetValueFunction<std::hash<std::shared_ptr<State> >, std::equal_to<std::shared_ptr<State> >>;

typedef PointSetValueFunction2

using sdm::PointSetValueFunction2 = typedef BasePointSetValueFunction<sdm::hash_from_ptr<State>, sdm::equal_from_ptr<State> >;

typedef PrivateHierarchicalOccupancyStateJointHistoryPair

using sdm::PrivateHierarchicalOccupancyStateJointHistoryPair = typedef StatePair<std::shared_ptr<OccupancyStateInterface>, std::shared_ptr<JointHistoryInterface> >;

typedef QValueFunctionBase

using sdm::QValueFunctionBase = typedef BaseValueFunction<Pair<std::shared_ptr<State>,std::shared_ptr<Action> >>;

typedef RecursiveMap_t

using sdm::RecursiveMap_t = typedef typename RecursiveMap<T0, T1, Ts...>::type;

typedef SparseMatrix

using sdm::SparseMatrix = typedef sdmsMatrix<TLig, TCol, TValue, boost::numeric::ublas::mapped_matrix<TValue>, SparseVector<TCol, TValue> >;

Template parameters:

• TLig Type of lines
• TCol Type of columns

typedef SparseVector

using sdm::SparseVector = typedef sdmsVector<I, T, boost::numeric::ublas::mapped_vector<T> >;

Template parameters:

• I Type of index
• T Type of value

typedef StatePair

using sdm::StatePair = typedef ItemPair<TState_1, TState_2, State>;

enum Statistic

enum sdm::Statistic {
    MIN,
    MAX,
    MEAN,
    RANGE,
    VARIANCE,
    STANDARD_DEVIATION
};

Enumerator for the types of statistics that can be recorded.

typedef StringItem

using sdm::StringItem = typedef BaseItem<std::string>;

enum TState_t

enum sdm::TState_t {
    COMPRESSED,
    ONE_STEP_UNCOMPRESSED,
    FULLY_UNCOMPRESSED
};

typedef TabularValueFunction

using sdm::TabularValueFunction = typedef BaseTabularValueFunction<std::hash<std::shared_ptr<State> >, std::equal_to<std::shared_ptr<State> >>;

typedef TabularValueFunction2

using sdm::TabularValueFunction2 = typedef BaseTabularValueFunction<sdm::hash_from_ptr<State>, sdm::equal_from_ptr<State> >;

typedef Tuple

using sdm::Tuple = typedef std::tuple<T...>;

Template parameters:

• T... the types of the elements that the tuple stores. Empty list is supported.

enum TypeAction

enum sdm::TypeAction {
    ACTION,
    DECISION_RULE
};

enum TypeOfMaxPlanPrunning

enum sdm::TypeOfMaxPlanPrunning {
    PAIRWISE,
    BOUNDED
};

enum TypeOfResolution

enum sdm::TypeOfResolution {
    BigM,
    IloIfThenResolution
};

enum TypeOfSawtoothPrunning

enum sdm::TypeOfSawtoothPrunning {
    ITERATIVE,
    GLOBAL,
    BOTH,
    NONE
};

enum TypeSawtoothLinearProgram

enum sdm::TypeSawtoothLinearProgram {
    PLAIN_SAWTOOTH_LINER_PROGRAMMING,
    RELAXED_SAWTOOTH_LINER_PROGRAMMING,
    RELAXED_V2_SAWTOOTH_LINER_PROGRAMMING
};

enum TypeSoftmax

enum sdm::TypeSoftmax {
    BELIEF,
    BEHAVIOR,
    OCCUPANCY
};

enum TypeState

enum sdm::TypeState {
    STATE,
    BELIEF_STATE,
    OCCUPANCY_STATE,
    SERIAL_OCCUPANCY_STATE,
    SERIAL_STATE,
    UNKNOWN
};

typedef ValueFunctionBase

using sdm::ValueFunctionBase = typedef BaseValueFunction<std::shared_ptr<State> >;

typedef bimap

typedef boost::bimaps::bimap<std::string, sdm::size_t> sdm::bimap;

typedef bimap_item_index

using sdm::bimap_item_index = typedef boost::bimaps::bimap<TItem, sdm::size_t>;

typedef name2index

typedef bimap::value_type sdm::name2index;

typedef number

typedef unsigned short sdm::number;

typedef sars_transition

typedef std::tuple<state, action, double, state> sdm::sars_transition;

typedef size_t

typedef std::size_t sdm::size_t;

typedef value_t

using sdm::value_t = typedef typename RecursiveMap<T0, T1, Ts...>::value_type;

Public Attributes Documentation

variable ERROR_IN_COMMAND_LINE

const size_t sdm::ERROR_IN_COMMAND_LINE;

variable ERROR_UNHANDLED_EXCEPTION

const size_t sdm::ERROR_UNHANDLED_EXCEPTION;

variable NO_OBSERVATION

const std::shared_ptr<Observation> sdm::NO_OBSERVATION;

variable SUCCESS

const size_t sdm::SUCCESS;

Public Functions Documentation

function cast

template<class I class I, class T class T>
std::shared_ptr< T > sdm::cast (
    const std::shared_ptr< I > & item
) 

function createInstance

template<class TInit class TInit>
std::shared_ptr< Initializer > sdm::createInstance (
    std::shared_ptr< SolvableByHSVI > world
) 

function createInstance

template<typename TState typename TState, typename TAction typename TAction, template< typename TS, typename TA > class TValueFunction>
std::shared_ptr< ValueFunction < TState, TAction > > sdm::createInstance () 

function createInstanceAlgoInit

template<class TInit class TInit>
std::shared_ptr< Initializer > sdm::createInstanceAlgoInit (
    std::shared_ptr< SolvableByHSVI > world,
    std::string algo_name,
    double error,
    int trials
) 

function createInstanceMDPValueIterationInit

std::shared_ptr< Initializer > sdm::createInstanceMDPValueIterationInit (
    std::shared_ptr< SolvableByHSVI > world
) 

function createInstanceTabMDPInit

std::shared_ptr< Initializer > sdm::createInstanceTabMDPInit (
    std::shared_ptr< SolvableByHSVI > world
) 

function createInstanceTabPOMDPInit

std::shared_ptr< Initializer > sdm::createInstanceTabPOMDPInit (
    std::shared_ptr< SolvableByHSVI > world
) 

function getTypeAction

virtual TypeAction sdm::getTypeAction () const

function hash_combine

template<class T class T>
inline void sdm::hash_combine (
    std::size_t & seed,
    T const & v
) 

function hash_combine

template<>
inline void sdm::hash_combine (
    std::size_t & seed,
    double const & v
) 

function makeInitializer

std::shared_ptr< Initializer > sdm::makeInitializer (
    std::string init_name,
    std::shared_ptr< SolvableByHSVI > world
) 

function makeValueFunction

template<typename TState typename TState, typename TAction typename TAction>
std::shared_ptr< Initializer < TState, TAction > > sdm::makeValueFunction (
    std::string init_name
) 

function operator<<

template<typename T typename T, typename U typename U>
std::ostream & sdm::operator<< (
    std::ostream & os,
    const sdm::Pair < T, U > & pair
) 

function operator<<

template<class... T>
std::ostream & sdm::operator<< (
    std::ostream & os,
    sdm::Tuple < T... > const & tuple
) 

function operator<<

template<typename T typename T>
std::ostream & sdm::operator<< (
    std::ostream & os,
    const std::vector< T > & v
) 

function str

virtual std::string sdm::str () const = 0

function test

void sdm::test (
    std::vector< std::string > all_formalism={"mdp"},
    std::vector< std::string > all_problem={"mabc"},
    std::vector< int > all_horizon={2},
    std::vector< double > all_discount={1},
    std::vector< std::string > upper_bound_name={""},
    std::vector< std::string > lower_bound_name={""},
    std::vector< std::string > all_lower__init_name={"MinInitializer"},
    std::vector< std::string > all_upper_init_name={"MaxInitializer"},
    std::vector< int > all_truncation={2},
    std::vector< std::string > all_sawtooth_current_type_of_resolution={"BigM"},
    std::vector< number > all_sawtooth_BigM={1000},
    std::vector< std::string > all_sawtooth_type_of_linear_program={"Full"},
    std::vector< TypeOfMaxPlanPrunning > all_type_of_maxplan_prunning={TypeOfMaxPlanPrunning::PAIRWISE},
    std::vector< int > all_freq_prunning_lower_bound={-1},
    std::vector< TypeOfSawtoothPrunning > all_type_of_sawtooth_pruning={TypeOfSawtoothPrunning::NONE},
    std::vector< int > all_freq_prunning_upper_bound={-1},
    int mean=2,
    std::string filepath="../data/world/dpomdp/",
    std::string save_path="../../run/Resultat/resultat.csv"
) 

Parameters:

• filepath
• all_formalism a vector of all formalism to use (mdp/pomdp/...)
• all_problem a vector of all problem to be solved ( tiger/mabc/...)
• all_horizon a vector of all planning horizon
• all_discount a vector of all discount factor
• all_lower_bound a vector of all lower_bound
• all_upper_bound a vector of all upper bound
• mean the number of repetition
• sauvegarde_path the path to save all the data

function toDecisionRule

virtual std::shared_ptr< DecisionRule > sdm::toDecisionRule () 

Any class inheriting from this interface will be considered as generic action for algorithms. Consider sections Theoritical Background (opens new window) and Algorithms (opens new window) for more information.

/ class Action : public Item { public: virtual ~Action() {}

/**Cast the action into a decision rule.

function toJointDeterministicDecisionRule

virtual std::shared_ptr< JointDeterministicDecisionRule > sdm::toJointDeterministicDecisionRule () 

---

The documentation for this class was generated from the following file src/sdm/algorithms/alpha_star.hpp