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 60 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 325 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 314 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 144 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 194 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 234 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 220 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 274 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 165 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 183 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 116 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 136 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 94 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 251 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 141 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 101 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 108 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 116 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 293 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 356 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 336 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 208 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 276 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 269 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 279 of file fmdp.h.

_actionSeq_

template<typename GUM_SCALAR>

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

private

Definition at line 263 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 273 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 266 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 284 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 261 of file fmdp.h.

---

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

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