gum::FMDP< GUM_SCALAR > Class Template Reference

This class is used to implement factored decision process. More...

#include <fmdp.h>

Collaboration diagram for gum::FMDP< GUM_SCALAR >:

Public Member Functions
Constructors, Destructors.
	FMDP (bool onDestructionDeleteVar=false)
	Default constructor. More...
	~FMDP ()
	Default destructor. More...
Variable Handling Methods.
void	addVariable (const DiscreteVariable *var)
	Adds a variable to FMDP description. More...
SequenceIteratorSafe< const DiscreteVariable *>	beginVariables () const
	Returns an iterator reference to he beginning of the list of variables. More...
SequenceIteratorSafe< const DiscreteVariable *>	endVariables () const
	Returns an iterator reference to the end of the list of variables. More...
const DiscreteVariable *	main2prime (const DiscreteVariable *mainVar) const
	Returns the primed variable associate to the given main variable. More...
INLINE const Bijection< const DiscreteVariable *, const DiscreteVariable *> &	mapMainPrime () const
	Returns the map binding main variables and prime variables. More...
Action Handling Methods.
void	addAction (Idx actionId, const std::string &action)
	Adds an action to FMDP description. More...
SequenceIteratorSafe< Idx >	beginActions () const
	Returns an iterator reference to he beginning of the list of actions. More...
SequenceIteratorSafe< Idx >	endActions () const
	Returns an iterator reference to the end of the list of actions. More...
Transition methods.
void	addTransitionForAction (Idx actionId, const DiscreteVariable *var, const MultiDimImplementation< GUM_SCALAR > *transition)
	Adds a variable transition table to specified action. More...
void	addTransition (const DiscreteVariable *var, const MultiDimImplementation< GUM_SCALAR > *transition)
	Adds a default variable transition. More...
const MultiDimImplementation< GUM_SCALAR > *	transition (Idx actionId, const DiscreteVariable *v) const
	Returns transition associated to given in parameter variable and the given action. More...
Cost methods.
void	addCostForAction (Idx actionId, const MultiDimImplementation< GUM_SCALAR > *cost)
	Adds a cost table to specified action. More...
void	addCost (const MultiDimImplementation< GUM_SCALAR > *cost)
	Adds a default variable cost. More...
const MultiDimImplementation< GUM_SCALAR > *	cost (Idx actionId=0) const
	Returns the reward table of mdp. More...
Reward methods.
void	addRewardForAction (Idx actionId, const MultiDimImplementation< GUM_SCALAR > *reward)
	Adds a default variable reward. More...
void	addReward (const MultiDimImplementation< GUM_SCALAR > *reward)
	Adds a default variable reward. More...
const MultiDimImplementation< GUM_SCALAR > *	reward (Idx actionId=0) const
	Returns the reward table of mdp. More...
FMPD miscelleanous methods.
const std::string &	actionName (Idx actionId) const
	Returns name of action given in parameter. More...
Idx	actionId (const std::string &) const
	Returns action id. More...
std::string	toString () const
	Displays the FMDP in a Dot format. More...
Size	size () const
	Returns the map binding main variables and prime variables. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::FMDP< GUM_SCALAR >

This class is used to implement factored decision process.

This class supports a mechanism which allows user to give, for each variable ivolved in the process, a default transition probability table and to describe for specific actions a different table.

Definition at line 54 of file fmdp.h.

Member Typedef Documentation

VarTransitionTable

template<typename GUM_SCALAR>

template<typename GUM_SCALAR_O >

using gum::FMDP< GUM_SCALAR >::VarTransitionTable = HashTable< const DiscreteVariable*, const MultiDimImplementation< GUM_SCALAR_O >* >

private

Definition at line 58 of file fmdp.h.

Constructor & Destructor Documentation

FMDP()

template<typename GUM_SCALAR >

INLINE gum::FMDP< GUM_SCALAR >::FMDP

(

bool

onDestructionDeleteVar = false

)

Default constructor.

Definition at line 50 of file fmdp_tpl.h.

                                                             {
    GUM_CONSTRUCTOR(FMDP);
    __onDestructionDeleteVars = onDestructionDeleteVar;

    // Default Action initialisation
    __actionMap.insert(0, new std::string("DEFAULT"));
    __actionTransitionTable.insert(0, new VarTransitionTable< GUM_SCALAR >());
    __actionCostTable.insert(0, nullptr);
    __actionRewardTable.insert(0, nullptr);
  }

~FMDP()

template<typename GUM_SCALAR >

gum::FMDP< GUM_SCALAR >::~FMDP

(

)

Default destructor.

Definition at line 65 of file fmdp_tpl.h.

                            {
    // Action Transition Graph deletion
    for (auto iterA = __actionTransitionTable.beginSafe();
         iterA != __actionTransitionTable.endSafe();
         ++iterA) {
      if (iterA.val()) {
        for (auto iterH = (iterA.val())->beginSafe();
             iterH != (iterA.val())->endSafe();
             ++iterH)
          if (iterH.val()) delete iterH.val();
        delete iterA.val();
      }
    }

    // Action cost graph deletion
    for (auto iterA = __actionCostTable.beginSafe();
         iterA != __actionCostTable.endSafe();
         ++iterA)
      if (iterA.val()) delete iterA.val();

    // Action reward graph deletion
    for (auto iterA = __actionRewardTable.beginSafe();
         iterA != __actionRewardTable.endSafe();
         ++iterA)
      if (iterA.val()) delete iterA.val();

    // Action Name deletion
    for (auto iterId = __actionMap.beginSafe(); iterId != __actionMap.endSafe();
         ++iterId)
      delete iterId.second();

    // Primed Variables deletion
    for (auto varIter = __main2primed.beginSafe();
         varIter != __main2primed.endSafe();
         ++varIter) {
      delete varIter.second();
      if (__onDestructionDeleteVars) delete varIter.first();
    }

    GUM_DESTRUCTOR(FMDP);
  }

Member Function Documentation

actionId()

template<typename GUM_SCALAR >

INLINE Idx gum::FMDP< GUM_SCALAR >::actionId

(

const std::string &

action

)

const

Returns action id.

Definition at line 355 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addReward(), and gum::FMDP< double >::mapMainPrime().

                                                                       {
    for (BijectionIterator< Idx, const std::string* > actIter =
            __actionMap.begin();
         actIter != __actionMap.end();
         ++actIter)
      if (*(actIter.second()) == action) { return actIter.first(); }

    GUM_ERROR(NotFound, " Action " << action << " has not been declared before.");
  }

Here is the caller graph for this function:

actionName()

template<typename GUM_SCALAR >

INLINE const std::string & gum::FMDP< GUM_SCALAR >::actionName

(

Idx

actionId

)

const

Returns name of action given in parameter.

Definition at line 344 of file fmdp_tpl.h.

Referenced by gum::FMDPSimulator::actionName(), gum::FMDP< double >::addReward(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize().

                                                                           {
    if (!__actionMap.existsFirst(actionId))
      GUM_ERROR(NotFound, "No action with " << actionId << " as identifiant.");

    return *(__actionMap.second(actionId));
  }

Here is the caller graph for this function:

addAction()

template<typename GUM_SCALAR >

INLINE void gum::FMDP< GUM_SCALAR >::addAction	(	Idx	actionId,
		const std::string &	action
	)

Adds an action to FMDP description.

Exceptions

DuplicateElement

if an action with same name already exists

Definition at line 150 of file fmdp_tpl.h.

Referenced by gum::SDYNA::addAction(), and gum::FMDP< double >::mapMainPrime().

                                                                     {
    if (actionId == 0) GUM_ERROR(DuplicateElement, " Action Id 0 is reserved.");

    for (BijectionIteratorSafe< Idx, const std::string* > actIter =
            __actionMap.beginSafe();
         actIter != __actionMap.endSafe();
         ++actIter)
      if (*(actIter.second()) == action)
        GUM_ERROR(DuplicateElement,
                  " Action "
                     << action
                     << " has already been inserted in FMDP with this name.");

    if (__actionMap.existsFirst(actionId))
      GUM_ERROR(DuplicateElement,
                " An action with same id (" << actionId
                                            << ") has already been inserted.");

    __actionMap.insert(actionId, new std::string(action));

    __actionTransitionTable.insert(actionId,
                                   new VarTransitionTable< GUM_SCALAR >());
    __actionCostTable.insert(actionId, nullptr);
    __actionRewardTable.insert(actionId, nullptr);

    __actionSeq.insert(actionId);
  }

Here is the caller graph for this function:

addCost()

template<typename GUM_SCALAR>

void gum::FMDP< GUM_SCALAR >::addCost ( const MultiDimImplementation< GUM_SCALAR > *  cost )

inline

Adds a default variable cost.

Exceptions

DuplicateElement

if a default cost exists already

Definition at line 198 of file fmdp.h.

                                                                   {
      this->addCostForAction(0, cost);
    }

addCostForAction()

template<typename GUM_SCALAR>

INLINE void gum::FMDP< GUM_SCALAR >::addCostForAction	(	Idx	actionId,
		const MultiDimImplementation< GUM_SCALAR > *	cost
	)

Adds a cost table to specified action.

Exceptions

NotFound

if action does not exists

Definition at line 254 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addCost(), and gum::FMDP< double >::addTransition().

                                                                     {
    if (!__actionCostTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionCostTable[actionId] != nullptr)
      GUM_ERROR(DuplicateElement,
                " Action " << actionName(actionId) << " already has a cost table");

    __actionCostTable[actionId] = cost;
  }

Here is the caller graph for this function:

addReward()

template<typename GUM_SCALAR>

void gum::FMDP< GUM_SCALAR >::addReward ( const MultiDimImplementation< GUM_SCALAR > *  reward )

inline

Adds a default variable reward.

Exceptions

DuplicateElement

if a default reward exists already

Definition at line 225 of file fmdp.h.

Referenced by gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize().

                                                                       {
      this->addRewardForAction(0, reward);
    }

Here is the caller graph for this function:

addRewardForAction()

template<typename GUM_SCALAR>

INLINE void gum::FMDP< GUM_SCALAR >::addRewardForAction	(	Idx	actionId,
		const MultiDimImplementation< GUM_SCALAR > *	reward
	)

Adds a default variable reward.

Exceptions

DuplicateElement

if a default reward exists already

Definition at line 299 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addCost(), gum::FMDP< double >::addReward(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize().

                                                                       {
    if (!__actionRewardTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionRewardTable[actionId] != nullptr)
      GUM_ERROR(DuplicateElement,
                " Action " << actionName(actionId)
                           << " already has a reward table");

    __actionRewardTable[actionId] = reward;
  }

Here is the caller graph for this function:

addTransition()

template<typename GUM_SCALAR>

void gum::FMDP< GUM_SCALAR >::addTransition ( const DiscreteVariable *  var, const MultiDimImplementation< GUM_SCALAR > *  transition  )

inline

Adds a default variable transition.

Exceptions

NotFound	if var does not exists
DuplicateElement	if variable already has a default transition

Definition at line 168 of file fmdp.h.

                                                                               {
      this->addTransitionForAction(0, var, transition);
    }

addTransitionForAction()

template<typename GUM_SCALAR>

INLINE void gum::FMDP< GUM_SCALAR >::addTransitionForAction	(	Idx	actionId,
		const DiscreteVariable *	var,
		const MultiDimImplementation< GUM_SCALAR > *	transition
	)

Adds a variable transition table to specified action.

Exceptions

NotFound	if action or var does not exists
DuplicateElement	if variable already has a transition for this action

Definition at line 195 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addTransition(), gum::FMDP< double >::endActions(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize().

                                                             {
    if (!__varSeq.exists(var))
      GUM_ERROR(NotFound,
                " Variable " << var->name() << " has not been declared before.");

    if (!__actionTransitionTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionTransitionTable[actionId]->exists(var))
      GUM_ERROR(DuplicateElement,
                " Variable " << var->name()
                             << " already has a transition table in " << actionId
                             << " table.");

    __actionTransitionTable[actionId]->insert(var, transition);
  }

Here is the caller graph for this function:

addVariable()

template<typename GUM_SCALAR >

INLINE void gum::FMDP< GUM_SCALAR >::addVariable

(

const DiscreteVariable *

var

)

Adds a variable to FMDP description.

Exceptions

DuplicateElement

if a similar variable already exists

Definition at line 121 of file fmdp_tpl.h.

Referenced by gum::SDYNA::addVariable().

                                                                         {
    if (__varSeq.exists(var))
      GUM_ERROR(DuplicateElement,
                " Variable " << var->name()
                             << " has already been inserted in FMDP.");


    __varSeq.insert(var);

    // Prime version creation
    DiscreteVariable* primeVar = var->clone();
    primeVar->setName(var->name() + "'");
    __main2primed.insert(var, primeVar);
  }

Here is the caller graph for this function:

beginActions()

template<typename GUM_SCALAR>

SequenceIteratorSafe< Idx > gum::FMDP< GUM_SCALAR >::beginActions ( ) const

inline

Returns an iterator reference to he beginning of the list of actions.

Definition at line 134 of file fmdp.h.

Referenced by gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::AdaptiveRMaxPlaner::_evalPolicy(), gum::AdaptiveRMaxPlaner::_initVFunction(), gum::AdaptiveRMaxPlaner::_valueIteration(), gum::FMDPSimulator::beginActions(), gum::IDecisionStrategy::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), gum::AdaptiveRMaxPlaner::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::size(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::updateFMDP().

                                                     {
      return __actionSeq.beginSafe();
    }

Here is the caller graph for this function:

beginVariables()

template<typename GUM_SCALAR>

SequenceIteratorSafe< const DiscreteVariable* > gum::FMDP< GUM_SCALAR >::beginVariables ( ) const

inline

Returns an iterator reference to he beginning of the list of variables.

Definition at line 92 of file fmdp.h.

Referenced by gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::addObservation(), gum::FMDPSimulator::beginVariables(), gum::E_GreedyDecider::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::size(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::updateFMDP().

                                                                           {
      return __varSeq.beginSafe();
    }

Here is the caller graph for this function:

cost()

template<typename GUM_SCALAR >

INLINE const MultiDimImplementation< GUM_SCALAR > * gum::FMDP< GUM_SCALAR >::cost

(

Idx

actionId = 0

)

const

Returns the reward table of mdp.

Definition at line 275 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addCost(), and gum::FMDP< double >::addTransition().

                                                          {
    if (!__actionCostTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionCostTable[actionId]) return __actionCostTable[actionId];
    return __actionCostTable[0];
  }

Here is the caller graph for this function:

endActions()

template<typename GUM_SCALAR>

SequenceIteratorSafe< Idx > gum::FMDP< GUM_SCALAR >::endActions ( ) const

inline

Returns an iterator reference to the end of the list of actions.

Definition at line 141 of file fmdp.h.

Referenced by gum::AdaptiveRMaxPlaner::__clearTables(), gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::AdaptiveRMaxPlaner::_evalPolicy(), gum::AdaptiveRMaxPlaner::_initVFunction(), gum::AdaptiveRMaxPlaner::_valueIteration(), gum::FMDPSimulator::endActions(), gum::IDecisionStrategy::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), gum::AdaptiveRMaxPlaner::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::size(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::updateFMDP().

                                                   {
      return __actionSeq.endSafe();
    }

Here is the caller graph for this function:

endVariables()

template<typename GUM_SCALAR>

SequenceIteratorSafe< const DiscreteVariable* > gum::FMDP< GUM_SCALAR >::endVariables ( ) const

inline

Returns an iterator reference to the end of the list of variables.

Definition at line 99 of file fmdp.h.

Referenced by gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::addObservation(), gum::FMDPSimulator::endVariables(), gum::E_GreedyDecider::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::size(), and gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::updateFMDP().

                                                                         {
      return __varSeq.endSafe();
    }

Here is the caller graph for this function:

main2prime()

template<typename GUM_SCALAR>

const DiscreteVariable* gum::FMDP< GUM_SCALAR >::main2prime ( const DiscreteVariable *  mainVar ) const

inline

Returns the primed variable associate to the given main variable.

Definition at line 106 of file fmdp.h.

Referenced by gum::SDYNA::feedback(), gum::FMDPLearner< VariableAttributeSelection, RewardAttributeSelection, LearnerSelection >::initialize(), gum::StructuredPlaner< double >::initialize(), and gum::FMDPSimulator::primeVar().

                                                                              {
      return __main2primed.second(mainVar);
    }

Here is the caller graph for this function:

mapMainPrime()

template<typename GUM_SCALAR>

INLINE const Bijection< const DiscreteVariable*, const DiscreteVariable* >& gum::FMDP< GUM_SCALAR >::mapMainPrime ( ) const

inline

Returns the map binding main variables and prime variables.

Definition at line 114 of file fmdp.h.

Referenced by gum::AdaptiveRMaxPlaner::_evalPolicy(), gum::MDDOperatorStrategy< GUM_SCALAR >::_shouldEleminateVar(), gum::AdaptiveRMaxPlaner::_valueIteration(), gum::TreeOperatorStrategy< GUM_SCALAR >::regress(), and gum::MDDOperatorStrategy< GUM_SCALAR >::regress().

                                      {
      return __main2primed;
    }

Here is the caller graph for this function:

reward()

template<typename GUM_SCALAR >

INLINE const MultiDimImplementation< GUM_SCALAR > * gum::FMDP< GUM_SCALAR >::reward

(

Idx

actionId = 0

)

const

Returns the reward table of mdp.

Definition at line 321 of file fmdp_tpl.h.

Referenced by gum::AdaptiveRMaxPlaner::_initVFunction(), gum::FMDP< double >::addCost(), gum::FMDP< double >::addReward(), and gum::FMDPSimulator::reward().

                                                            {
    if (!__actionRewardTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionRewardTable[actionId]) return __actionRewardTable[actionId];
    return __actionRewardTable[0];
  }

Here is the caller graph for this function:

size()

template<typename GUM_SCALAR >

INLINE Size gum::FMDP< GUM_SCALAR >::size

(

)

const

Returns the map binding main variables and prime variables.

Definition at line 389 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addReward(), and gum::SDYNA::modelSize().

                                             {
    Size s = 0;
    for (auto actionIter = beginActions(); actionIter != endActions();
         ++actionIter) {
      for (auto varIter = beginVariables(); varIter != endVariables(); ++varIter)
        if (this->transition(*actionIter, *varIter))
          s += this->transition(*actionIter, *varIter)->realSize();
      if (this->reward(*actionIter)) s += this->reward(*actionIter)->realSize();
    }

    for (auto varIter = beginVariables(); varIter != endVariables(); ++varIter)
      if (this->transition(0, *varIter))
        s += this->transition(0, *varIter)->realSize();
    if (this->reward()) s += this->reward()->realSize();
    return s;
  }

Here is the caller graph for this function:

toString()

template<typename GUM_SCALAR >

INLINE std::string gum::FMDP< GUM_SCALAR >::toString

(

)

const

Displays the FMDP in a Dot format.

Definition at line 367 of file fmdp_tpl.h.

Referenced by gum::FMDP< double >::addReward(), and gum::SDYNA::toString().

                                                      {
    std::stringstream fmdpCore;

    for (auto actionIter = beginActions(); actionIter != endActions();
         ++actionIter) {
      for (auto varIter = beginVariables(); varIter != endVariables(); ++varIter)
        if (this->transition(*actionIter, *varIter))
          fmdpCore << RECAST(this->transition(*actionIter, *varIter))->toDot()
                   << std::endl;
      if (this->reward(*actionIter))
        fmdpCore << RECAST(this->reward(*actionIter))->toDot() << std::endl;
    }

    for (auto varIter = beginVariables(); varIter != endVariables(); ++varIter)
      if (this->transition(0, *varIter))
        fmdpCore << RECAST(this->transition(0, *varIter))->toDot() << std::endl;
    if (this->reward()) fmdpCore << RECAST(this->reward())->toDot() << std::endl;
    return fmdpCore.str();
  }

Here is the caller graph for this function:

transition()

template<typename GUM_SCALAR >

INLINE const MultiDimImplementation< GUM_SCALAR > * gum::FMDP< GUM_SCALAR >::transition	(	Idx	actionId,
		const DiscreteVariable *	v
	)		const

Returns transition associated to given in parameter variable and the given action.

Definition at line 224 of file fmdp_tpl.h.

Referenced by gum::FMDPSimulator::_transitionProbability(), gum::FMDP< double >::addTransition(), gum::FMDP< double >::endActions(), gum::TreeOperatorStrategy< GUM_SCALAR >::regress(), and gum::MDDOperatorStrategy< GUM_SCALAR >::regress().

                                                                     {
    if (!__actionTransitionTable.exists(actionId))
      GUM_ERROR(NotFound,
                " Action " << actionName(actionId)
                           << " has not been declared before.");

    if (__actionTransitionTable[actionId]->exists(v))
      return (*__actionTransitionTable[actionId])[v];
    else
      return (*__actionTransitionTable[0]).exists(v)
                ? (*__actionTransitionTable[0])[v]
                : nullptr;
  }

Here is the caller graph for this function:

Member Data Documentation

__actionCostTable

template<typename GUM_SCALAR>

HashTable< Idx, const MultiDimImplementation< GUM_SCALAR >* > gum::FMDP< GUM_SCALAR >::__actionCostTable

private

Table which give for each action cost table.

Definition at line 282 of file fmdp.h.

__actionMap

template<typename GUM_SCALAR>

Bijection< Idx, const std::string* > gum::FMDP< GUM_SCALAR >::__actionMap

private

Bijection mapping an action name to its id.

Definition at line 274 of file fmdp.h.

__actionRewardTable

template<typename GUM_SCALAR>

HashTable< Idx, const MultiDimImplementation< GUM_SCALAR >* > gum::FMDP< GUM_SCALAR >::__actionRewardTable

private

Table which give for each action reward table.

Definition at line 286 of file fmdp.h.

__actionSeq

template<typename GUM_SCALAR>

Sequence< Idx > gum::FMDP< GUM_SCALAR >::__actionSeq

private

Definition at line 268 of file fmdp.h.

Referenced by gum::FMDP< double >::beginActions(), and gum::FMDP< double >::endActions().

__actionTransitionTable

template<typename GUM_SCALAR>

HashTable< Idx, VarTransitionTable< GUM_SCALAR >* > gum::FMDP< GUM_SCALAR >::__actionTransitionTable

private

Table which give for each action a table containing variables transition cpt.

Definition at line 278 of file fmdp.h.

__main2primed

template<typename GUM_SCALAR>

Bijection< const DiscreteVariable*, const DiscreteVariable* > gum::FMDP< GUM_SCALAR >::__main2primed

private

Mapping from a main variable to its associated primed version.

Definition at line 271 of file fmdp.h.

Referenced by gum::FMDP< double >::main2prime(), and gum::FMDP< double >::mapMainPrime().

__onDestructionDeleteVars

template<typename GUM_SCALAR>

bool gum::FMDP< GUM_SCALAR >::__onDestructionDeleteVars

private

Boolean indicates whether or not main variables should be deleted on destruction of this instance Usually the case when fmdp has been initialized with the factory.

Definition at line 291 of file fmdp.h.

__varSeq

template<typename GUM_SCALAR>

Sequence< const DiscreteVariable* > gum::FMDP< GUM_SCALAR >::__varSeq

private

Sequence de variables and its iterator.

Definition at line 266 of file fmdp.h.

Referenced by gum::FMDP< double >::beginVariables(), and gum::FMDP< double >::endVariables().

---

The documentation for this class was generated from the following files:

• agrum/FMDP/fmdp.h
• agrum/FMDP/fmdp_tpl.h