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 57 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 61 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 53 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 68 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 360 of file fmdp_tpl.h.

                                                                       {
    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.");
  }

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 349 of file fmdp_tpl.h.

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

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

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 153 of file fmdp_tpl.h.

Referenced by 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 201 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 257 of file fmdp_tpl.h.

                                                       {
    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;
  }

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 228 of file fmdp.h.

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

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 303 of file fmdp_tpl.h.

                                                         {
    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;
  }

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 171 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 198 of file fmdp_tpl.h.

                                                             {
    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);
  }

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 124 of file fmdp_tpl.h.

                                                                         {
    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);
  }

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 137 of file fmdp.h.

                                                     {
      return actionSeq__.beginSafe();
    }

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 95 of file fmdp.h.

                                                                           {
      return varSeq__.beginSafe();
    }

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 279 of file fmdp_tpl.h.

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

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

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 144 of file fmdp.h.

                                                   {
      return actionSeq__.endSafe();
    }

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 102 of file fmdp.h.

                                                                         {
      return varSeq__.endSafe();
    }

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 109 of file fmdp.h.

                                                                              {
      return main2primed__.second(mainVar);
    }

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 117 of file fmdp.h.

                                      {
      return main2primed__;
    }

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 326 of file fmdp_tpl.h.

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

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

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 394 of file fmdp_tpl.h.

                                             {
    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;
  }

toString()

template<typename GUM_SCALAR >

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

(

)

const

Displays the FMDP in a Dot format.

Definition at line 372 of file fmdp_tpl.h.

                                                      {
    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();
  }

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 227 of file fmdp_tpl.h.

                                                                     {
    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;
  }

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 285 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 277 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 289 of file fmdp.h.

actionSeq__

template<typename GUM_SCALAR>

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

private

Definition at line 271 of file fmdp.h.

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 281 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 274 of file fmdp.h.

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 294 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 269 of file fmdp.h.

---

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

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