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

Private Types
template<typename GUM_SCALAR_O>
using	VarTransitionTable = HashTable< const DiscreteVariable*, const MultiDimImplementation< GUM_SCALAR_O >* >

Private Attributes
Sequence< const DiscreteVariable * >	_varSeq_
	Sequence de variables and its iterator.
Sequence< Idx >	_actionSeq_
Bijection< const DiscreteVariable *, const DiscreteVariable * >	_main2primed_
	Mapping from a main variable to its associated primed version.
Bijection< Idx, const std::string * >	_actionMap_
	Bijection mapping an action name to its id.
HashTable< Idx, VarTransitionTable< GUM_SCALAR > * >	_actionTransitionTable_
	Table which give for each action a table containing variables transition cpt.
HashTable< Idx, const MultiDimImplementation< GUM_SCALAR > * >	_actionCostTable_
	Table which give for each action cost table.
HashTable< Idx, const MultiDimImplementation< GUM_SCALAR > * >	_actionRewardTable_
	Table which give for each action reward table.
bool	_onDestructionDeleteVars_
	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.

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 73 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 75 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 74 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);
  }

References FMDP(), _actionCostTable_, _actionMap_, _actionRewardTable_, _actionTransitionTable_, and _onDestructionDeleteVars_.

Referenced by FMDP(), and cost().

Here is the call graph for this function:

Here is the caller graph for this function:

~FMDP()

template<typename GUM_SCALAR>

gum::FMDP< GUM_SCALAR >::~FMDP

(

)

Default destructor.

Definition at line 89 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 337 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.")
  }

References _actionMap_, and GUM_ERROR.

Referenced by actionName(), addAction(), addCostForAction(), addRewardForAction(), addTransitionForAction(), cost(), reward(), and transition().

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

                                                                           {
    if (!_actionMap_.existsFirst(actionId))
      GUM_ERROR(NotFound, "No action with " << actionId << " as identifiant.")
 
    return *(_actionMap_.second(actionId));
  }

References _actionMap_, actionId(), and GUM_ERROR.

Referenced by addCostForAction(), addRewardForAction(), cost(), reward(), and transition().

Here is the call graph for this function:

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

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

References _actionMap_, actionId(), and GUM_ERROR.

Here is the call 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 209 of file fmdp.h.

                                                                   {
      this->addCostForAction(0, cost);

References addCostForAction(), and cost().

Here is the call graph for this function:

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

References _actionCostTable_, actionId(), actionName(), cost(), and GUM_ERROR.

Referenced by addCost().

Here is the call graph for this function:

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

                                                                       {
      this->addRewardForAction(0, reward);

References addRewardForAction(), and reward().

Here is the call 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 288 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;
  }

References _actionRewardTable_, actionId(), actionName(), GUM_ERROR, and reward().

Referenced by addReward().

Here is the call graph for this function:

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

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

References addTransitionForAction(), and transition().

Here is the call graph for this function:

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

References actionId().

Referenced by addTransition().

Here is the call graph for this function:

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

References _varSeq_, gum::DiscreteVariable::clone(), GUM_ERROR, and gum::Variable::name().

Here is the call 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 151 of file fmdp.h.

References _actionSeq_.

Referenced by gum::IDecisionStrategy::initialize(), size(), and toString().

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

                                                                           {
      return _varSeq_.beginSafe();

References _varSeq_.

Referenced by gum::E_GreedyDecider::initialize(), size(), and toString().

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 266 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];
  }

References FMDP(), _actionCostTable_, actionId(), actionName(), cost(), and GUM_ERROR.

Referenced by addCost(), addCostForAction(), and cost().

Here is the call graph for this function:

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

References _actionSeq_.

Referenced by gum::AdaptiveRMaxPlaner::_clearTables_(), gum::AdaptiveRMaxPlaner::_makeRMaxFunctionGraphs_(), gum::IDecisionStrategy::initialize(), size(), and toString().

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

                                                                         {
      return _varSeq_.endSafe();

References _varSeq_.

Referenced by gum::AdaptiveRMaxPlaner::_makeRMaxFunctionGraphs_(), gum::E_GreedyDecider::initialize(), size(), and toString().

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

                                                                              {
      return _main2primed_.second(mainVar);

References _main2primed_.

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

                                      {
      return _main2primed_;

References _main2primed_.

Referenced by gum::MDDOperatorStrategy< GUM_SCALAR >::regress(), gum::TreeOperatorStrategy< GUM_SCALAR >::regress(), and gum::MDDOperatorStrategy< GUM_SCALAR >::shouldEleminateVar_().

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 306 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];
  }

References _actionRewardTable_, actionId(), actionName(), and GUM_ERROR.

Referenced by addReward(), addRewardForAction(), size(), and toString().

Here is the call graph for this function:

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

References beginActions(), beginVariables(), endActions(), endVariables(), gum::MultiDimImplementation< GUM_SCALAR >::realSize(), and reward().

Here is the call 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 347 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();
  }

References beginActions(), beginVariables(), endActions(), endVariables(), RECAST, and reward().

Here is the call 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 225 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;
  }

References _actionTransitionTable_, actionId(), actionName(), and GUM_ERROR.

Referenced by addTransition(), gum::MDDOperatorStrategy< GUM_SCALAR >::regress(), and gum::TreeOperatorStrategy< GUM_SCALAR >::regress().

Here is the call graph for this function:

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

Referenced by FMDP(), addCostForAction(), and cost().

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

Referenced by FMDP(), actionId(), actionName(), and addAction().

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

Referenced by FMDP(), addRewardForAction(), and reward().

_actionSeq_

template<typename GUM_SCALAR>

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

private

Definition at line 278 of file fmdp.h.

Referenced by beginActions(), and 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 288 of file fmdp.h.

Referenced by FMDP(), and transition().

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

Referenced by main2prime(), and 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 299 of file fmdp.h.

Referenced by FMDP().

_varSeq_

template<typename GUM_SCALAR>

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

private

Sequence de variables and its iterator.

Definition at line 276 of file fmdp.h.

Referenced by addVariable(), beginVariables(), and endVariables().

---

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

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