gum::FMDPFactory< GUM_SCALAR > Class Template Reference

A factory class to ease Factored Markov Decision Process construction. More...

#include <agrum/FMDP/fmdpFactory.h>

Inheritance diagram for gum::FMDPFactory< GUM_SCALAR >:

Collaboration diagram for gum::FMDPFactory< GUM_SCALAR >:

Public Member Functions
Constructor & destructor.
	FMDPFactory (FMDP< GUM_SCALAR > *fmdp)
	Use this constructor if you want to use an already created factored markov decision process. More...
	~FMDPFactory ()
	Destructor. More...
Getter and setters.
FMDP< GUM_SCALAR > *	fmdp () const
	Returns the Factored Markov Decision Process created by this factory. More...
FMDPfactory_state	state () const
	Returns the current state of the factory. More...
const DiscreteVariable *	variable (const std::string &name) const
	Returns a constant reference on a variable given it's name. More...
Variable declaration methods (NONE -> VARIABLE)
void	startVariableDeclaration ()
	Tells the factory that we're in a variable declaration. More...
void	variableName (const std::string &name)
	Tells the factory the current variable's name. More...
void	variableDescription (const std::string &desc)
	Tells the factory the current variable's description. More...
void	addModality (const std::string &name)
	Adds a modality to the current variable. More...
void	endVariableDeclaration ()
	Tells the factory that we're out of a variable declaration. More...
Action declaration methods (NONE -> ACTION)
void	startActionDeclaration ()
	Tells the factory that we're in an action declaration. More...
void	addAction (const std::string &action)
	Tells the factory to add an action to the current fmdp. More...
void	endActionDeclaration ()
	Tells the factory that we're out of an action declaration. More...
Transition declaration methods (NONE -> TRANSITION <- ACTION)
void	startTransitionDeclaration ()
	Tells the factory that we're in a transition declaration. More...
void	addTransition (const std::string &var, const MultiDimAdressable *transition)
	Tells the factory to add a transition table to the current fmdp. More...
void	addTransition (const std::string &var)
	Tells the factory to add a transition table to the current fmdp. This transition table will be extracted from incorporated multiDimFunctionGraph. More...
void	endTransitionDeclaration ()
	Tells the factory that we're out of a transition declaration. More...
Cost declaration methods (NONE -> COST <- ACTION)
void	startCostDeclaration ()
	Tells the factory that we're in a cost declaration. More...
void	addCost (const MultiDimAdressable *cost)
	Tells the factory to add a cost table to the current fmdp. More...
void	addCost ()
	Tells the factory to add a cost table to the current fmdp. This cost table will be extracted from incorporated multiDimFunctionGraph. More...
void	endCostDeclaration ()
	Tells the factory that we're out of a cost declaration. More...
Reward declaration methods (NONE -> REWARD <- ACTION)
void	startRewardDeclaration ()
	Tells the factory that we're in a reward declaration. More...
void	setOperationModeOn (std::string operationType)
	Tells the factory that we're in a reward declaration mode where the global reward diagram is an operation between simplier decision diagram.. More...
void	addReward (const MultiDimAdressable *reward)
	Tells the factory to add a reward table to the current fmdp. More...
void	addReward ()
	Tells the factory to add a reward table to the current fmdp. This reward table will be extracted from incorporated multiDimFunctionGraph. More...
void	endRewardDeclaration ()
	Tells the factory that we're out of a cost declaration. More...
Discount declaration methods (NONE -> DISCOUNT)
void	startDiscountDeclaration ()
	Tells the factory that we're in a cost declaration. More...
void	addDiscount (float discount)
	Tells the factory to add a cost table to the current fmdp. More...
void	endDiscountDeclaration ()
	Tells the factory that we're out of a cost declaration. More...
FunctionGraph Creation specific methods
methods used by internal FunctionGraphfactory to build up a multidimFunctionGraph
NodeId	addInternalNode (std::string name_of_var)
	Insert in diagram a non terminal node. More...
NodeId	addTerminalNode (float value)
	Insert in diagram a terminal node. More...
void	addArc (NodeId from, NodeId to, Idx modality)
	Insert in diagram a non terminal node. More...
void	setRoot (NodeId rootId)
	add an arc in diagram More...
verbosity control
void	setVerbose ()
void	resetVerbose ()
bool	isVerbose ()

Current constructed FMDP's parts.
bool	__foo_flag
	Depending on the context this flag is used for some VERY important reasons. More...
bool	__bar_flag
	Depending on the context this flag is used for some VERY important reasons. More...
std::vector< std::string >	__stringBag
	Just to keep track of strings between two start/end calls. More...
std::vector< const MultiDimImplementation< GUM_SCALAR > *>	__ddBag
	Just to keep track of multidim between two start/end calls. More...
void	__checkModalityInBag (const std::string &mod)
	Used in VARIABLE mode Checks if in __stringBag there is no other modality with the same name. More...
void	__resetParts ()
	Reset the different parts used to constructed the FMDP. More...
void	__initializeFunctionGraph ()
	Insert every variables in the function graph. More...
void	__finalizeFunctionGraph ()
	Insert every variables in the function graph. More...

Detailed Description

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

A factory class to ease Factored Markov Decision Process construction.

A FMDPFactory will never create a Factored Markov Decision Process and works on only one Factored Markov Decision Process.

The only exception of this behaviour is when you create a copy of the factory, it will create a copy of its FMDP. This is useful when you want to create two FMDP sharing a common base. However be very careful because the copy will not delete its FMDP.

Each method will raise an OperationNotAllowed if you call it when the factory is not in a valid state for that call. The error message is "Illegal state.".

Definition at line 71 of file fmdpFactory.h.

Constructor & Destructor Documentation

FMDPFactory()

template<typename GUM_SCALAR >

INLINE gum::FMDPFactory< GUM_SCALAR >::FMDPFactory

(

FMDP< GUM_SCALAR > *

fmdp

)

Use this constructor if you want to use an already created factored markov decision process.

Parameters

fmdp	A pointer over the FMDP filled by this factory.

Definition at line 57 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__actionIdcpt, gum::FMDPFactory< GUM_SCALAR >::__states, gum::NONE, and gum::AbstractFMDPFactory::resetVerbose().

                                                                        :
      __fmdp(fmdp) {
    GUM_CONSTRUCTOR(FMDPFactory);

    __states.push_back(FMDPfactory_state::NONE);
    resetVerbose();
    __actionIdcpt = 1;
  }

Here is the call graph for this function:

~FMDPFactory()

template<typename GUM_SCALAR >

INLINE gum::FMDPFactory< GUM_SCALAR >::~FMDPFactory

(

)

Destructor.

To prevent strange behaviour you should always destroy a FMDPFactory when it's state equals NONE.

Exceptions

FatalError

Raised if the state of the factory prevents it to die peacefully.

Definition at line 70 of file fmdpFactory_tpl.h.

                                                 {
    GUM_DESTRUCTOR(FMDPFactory);
  }

Member Function Documentation

__checkModalityInBag()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::__checkModalityInBag ( const std::string &  mod )

private

Used in VARIABLE mode Checks if in __stringBag there is no other modality with the same name.

Definition at line 199 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__stringBag, and GUM_ERROR.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addModality().

                                                                         {
    for (size_t i = 2; i < __stringBag.size(); ++i)
      if (mod == __stringBag[i])
        GUM_ERROR(DuplicateElement, "Modality" << mod << " already exists.");
  }

Here is the caller graph for this function:

__finalizeFunctionGraph()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph ( )

private

Insert every variables in the function graph.

Definition at line 739 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::clean(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager(), gum::FMDPFactory< GUM_SCALAR >::operator=(), and gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::reduce().

Referenced by gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addReward(), and gum::FMDPFactory< GUM_SCALAR >::addTransition().

                                                                 {
    this->__FunctionGraph->manager()->reduce();
    this->__FunctionGraph->manager()->clean();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__illegalStateError()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::__illegalStateError ( const std::string &  s )

private

Raise an OperationNotAllowed with the message "Illegal state.".

Definition at line 674 of file fmdpFactory_tpl.h.

References gum::ACTION, gum::COST, gum::DISCOUNT, GUM_ERROR, gum::NONE, gum::REWARD, gum::FMDPFactory< GUM_SCALAR >::state(), gum::TRANSITION, and gum::VARIABLE.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addAction(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addDiscount(), gum::FMDPFactory< GUM_SCALAR >::addModality(), gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::variableDescription(), and gum::FMDPFactory< GUM_SCALAR >::variableName().

                                                                      {
    std::string msg = "Illegal state call (";
    msg += s;
    msg += ") in state ";

    switch (state()) {
      case FMDPfactory_state::NONE: msg += "FMDPfactory_state::NONE"; break;

      case FMDPfactory_state::VARIABLE:
        msg += "FMDPfactory_state::VARIABLE";
        break;

      case FMDPfactory_state::ACTION: msg += "FMDPfactory_state::ACTION"; break;

      case FMDPfactory_state::TRANSITION:
        msg += "FMDPfactory_state::TRANSITION";
        break;

      case FMDPfactory_state::COST: msg += "FMDPfactory_state::COST"; break;

      case FMDPfactory_state::REWARD: msg += "FMDPfactory_state::REWARD"; break;

      case FMDPfactory_state::DISCOUNT:
        msg += "FMDPfactory_state::DISCOUNT";
        break;

      default: msg += "Unknown state";
    }

    GUM_ERROR(OperationNotAllowed, msg);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__initializeFunctionGraph()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph ( )

private

Insert every variables in the function graph.

Definition at line 719 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::add(), and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance().

Referenced by gum::FMDPFactory< GUM_SCALAR >::startCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startRewardDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::startTransitionDeclaration().

                                                                   {
    this->__FunctionGraph =
       MultiDimFunctionGraph< GUM_SCALAR >::getReducedAndOrderedInstance();
    // Recopie des variables principales dans le graphe de décision
    for (auto varIter = __fmdp->beginVariables();
         varIter != __fmdp->endVariables();
         ++varIter) {
      __FunctionGraph->add(**varIter);
    }

    // Recopie des version primes des variables dans le graphe de décision
    for (auto varIter = __fmdp->beginVariables();
         varIter != __fmdp->endVariables();
         ++varIter) {
      __FunctionGraph->add(*(__fmdp->main2prime(*varIter)));
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__resetParts()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::__resetParts ( )

private

Reset the different parts used to constructed the FMDP.

Definition at line 710 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__bar_flag, gum::FMDPFactory< GUM_SCALAR >::__ddBag, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, and gum::FMDPFactory< GUM_SCALAR >::__stringBag.

Referenced by gum::FMDPFactory< GUM_SCALAR >::endActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration().

                                                      {
    __foo_flag = false;
    __bar_flag = false;
    __stringBag.clear();
    __ddBag.clear();
  }

Here is the caller graph for this function:

addAction()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addAction ( const std::string &  action )

virtual

Tells the factory to add an action to the current fmdp.

Implements gum::AbstractFMDPFactory.

Definition at line 282 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__actionIdcpt, gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::ACTION, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                          {
    if (state() != FMDPfactory_state::ACTION)
      __illegalStateError("addAction");
    else {
      __stringBag.push_back(action);
      __fmdp->addAction(__actionIdcpt++, action);
    }
  }

Here is the call graph for this function:

addArc()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addArc ( NodeId  from, NodeId  to, Idx  modality  )

virtual

Insert in diagram a non terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 651 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager(), and gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setSon().

                                                                           {
    __FunctionGraph->manager()->setSon(from, modality, to);
  }

Here is the call graph for this function:

addCost() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addCost ( const MultiDimAdressable *  cost )

virtual

Tells the factory to add a cost table to the current fmdp.

Implements gum::AbstractFMDPFactory.

Definition at line 415 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::COST, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                               {
    const MultiDimImplementation< GUM_SCALAR >* c =
       reinterpret_cast< const MultiDimImplementation< GUM_SCALAR >* >(cost);

    if (state() != FMDPfactory_state::COST)
      __illegalStateError("addCost");
    else if (__foo_flag)
      __fmdp->addCostForAction(__fmdp->actionId(__stringBag[0]), c);
    else
      __fmdp->addCost(c);
  }

Here is the call graph for this function:

addCost() [2/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addCost ( )

virtual

Tells the factory to add a cost table to the current fmdp. This cost table will be extracted from incorporated multiDimFunctionGraph.

Implements gum::AbstractFMDPFactory.

Definition at line 432 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::COST, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                 {
    if (state() != FMDPfactory_state::COST)
      __illegalStateError("addCost");
    else {
      this->__finalizeFunctionGraph();

      if (__foo_flag)
        __fmdp->addCostForAction(__fmdp->actionId(__stringBag[0]),
                                 this->__FunctionGraph);
      else
        __fmdp->addCost(this->__FunctionGraph);
    }
  }

Here is the call graph for this function:

addDiscount()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addDiscount ( float  discount )

virtual

Tells the factory to add a cost table to the current fmdp.

Implements gum::AbstractFMDPFactory.

Definition at line 600 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::DISCOUNT, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                   {
    if (state() != FMDPfactory_state::DISCOUNT) __illegalStateError("addDiscount");
    //    else
    //      __fmdp->setDiscount ( ( GUM_SCALAR ) discount );
  }

Here is the call graph for this function:

addInternalNode()

template<typename GUM_SCALAR >

INLINE NodeId gum::FMDPFactory< GUM_SCALAR >::addInternalNode ( std::string  name_of_var )

virtual

Insert in diagram a non terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 635 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager(), and gum::FMDPFactory< GUM_SCALAR >::variable().

                                                                         {
    return __FunctionGraph->manager()->addInternalNode(variable(name_of_var));
  }

Here is the call graph for this function:

addModality()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addModality ( const std::string &  name )

virtual

Adds a modality to the current variable.

Implements gum::AbstractFMDPFactory.

Definition at line 185 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__checkModalityInBag(), gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::VARIABLE.

                                                                          {
    if (state() != FMDPfactory_state::VARIABLE)
      __illegalStateError("addModality");
    else {
      __checkModalityInBag(name);
      __stringBag.push_back(name);
    }
  }

Here is the call graph for this function:

addReward() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addReward ( const MultiDimAdressable *  reward )

virtual

Tells the factory to add a reward table to the current fmdp.

Implements gum::AbstractFMDPFactory.

Definition at line 501 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::REWARD, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                          {
    const MultiDimImplementation< GUM_SCALAR >* r =
       reinterpret_cast< const MultiDimImplementation< GUM_SCALAR >* >(reward);

    if (state() != FMDPfactory_state::REWARD)
      __illegalStateError("addReward");
    else
      __fmdp->addReward(r);
  }

Here is the call graph for this function:

addReward() [2/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addReward ( )

virtual

Tells the factory to add a reward table to the current fmdp. This reward table will be extracted from incorporated multiDimFunctionGraph.

Implements gum::AbstractFMDPFactory.

Definition at line 517 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__ddBag, gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::REWARD, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setTableName(), and gum::FMDPFactory< GUM_SCALAR >::state().

                                                   {
    if (state() != FMDPfactory_state::REWARD)
      __illegalStateError("addReward");
    else {
      this->__finalizeFunctionGraph();
      __FunctionGraph->setTableName("Reward");

      if (__foo_flag)
        __ddBag.push_back(this->__FunctionGraph);
      else
        __fmdp->addReward(this->__FunctionGraph);
    }
  }

Here is the call graph for this function:

addTerminalNode()

template<typename GUM_SCALAR >

INLINE NodeId gum::FMDPFactory< GUM_SCALAR >::addTerminalNode ( float  value )

virtual

Insert in diagram a terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 643 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addTerminalNode(), and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager().

                                                                      {
    return __FunctionGraph->manager()->addTerminalNode((GUM_SCALAR)value);
  }

Here is the call graph for this function:

addTransition() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addTransition ( const std::string &  var, const MultiDimAdressable *  transition  )

virtual

Tells the factory to add a transition table to the current fmdp.

Implements gum::AbstractFMDPFactory.

Definition at line 335 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::__varNameMap, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::TRANSITION.

                                                                 {
    const MultiDimImplementation< GUM_SCALAR >* t =
       reinterpret_cast< const MultiDimImplementation< GUM_SCALAR >* >(transition);

    if (state() != FMDPfactory_state::TRANSITION)
      __illegalStateError("addTransition");
    else if (__foo_flag)
      __fmdp->addTransitionForAction(
         __fmdp->actionId(__stringBag[0]), __varNameMap[var], t);
    else
      __fmdp->addTransition(__varNameMap[var], t);
  }

Here is the call graph for this function:

addTransition() [2/2]

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::addTransition ( const std::string &  var )

virtual

Tells the factory to add a transition table to the current fmdp. This transition table will be extracted from incorporated multiDimFunctionGraph.

Implements gum::AbstractFMDPFactory.

Definition at line 355 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::__varNameMap, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::setTableName(), gum::FMDPFactory< GUM_SCALAR >::state(), and gum::TRANSITION.

                                                                           {
    if (state() != FMDPfactory_state::TRANSITION)
      __illegalStateError("addTransition");
    else {
      this->__finalizeFunctionGraph();

      if (__foo_flag) {
        this->__FunctionGraph->setTableName("ACTION :" + __stringBag[0]
                                            + " - VARIABLE : " + var);
        __fmdp->addTransitionForAction(__fmdp->actionId(__stringBag[0]),
                                       __varNameMap[var],
                                       this->__FunctionGraph);
      } else {
        __fmdp->addTransition(__varNameMap[var], this->__FunctionGraph);
      }
    }
  }

Here is the call graph for this function:

endActionDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endActionDeclaration ( )

virtual

Tells the factory that we're out of an action declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 295 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::ACTION, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                              {
    if (state() != FMDPfactory_state::ACTION)
      __illegalStateError("endActionDeclaration");
    else {
      __states.pop_back();
      __resetParts();
    }

    //       VERBOSITY ( "action OK" );
  }

Here is the call graph for this function:

endCostDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endCostDeclaration ( )

virtual

Tells the factory that we're out of a cost declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 450 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::COST, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                            {
    if (state() != FMDPfactory_state::COST)
      __illegalStateError("endCostDeclaration");
    else
      __states.pop_back();

    //       VERBOSITY ( "Cost OK" );
  }

Here is the call graph for this function:

endDiscountDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endDiscountDeclaration ( )

virtual

Tells the factory that we're out of a cost declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 610 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::DISCOUNT, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                {
    if (state() != FMDPfactory_state::DISCOUNT)
      __illegalStateError("endDiscountDeclaration");
    else
      __states.pop_back();

    //       VERBOSITY ( "discount OK" );
  }

Here is the call graph for this function:

endRewardDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration ( )

virtual

Tells the factory that we're out of a cost declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 535 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__ddBag, gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::add2MultiDimFunctionGraphs(), gum::divide2MultiDimFunctionGraphs(), gum::multiply2MultiDimFunctionGraphs(), gum::REWARD, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::subtract2MultiDimFunctionGraphs().

                                                              {
    if (state() != FMDPfactory_state::REWARD)
      __illegalStateError("endRewardDeclaration");
    else {
      if (__foo_flag) {
        MultiDimImplementation< GUM_SCALAR >* res = nullptr;
        MultiDimImplementation< GUM_SCALAR >* temp;

        for (const auto elt : __ddBag) {
          temp = res;

          switch (__stringBag[0][0]) {
            case '+': res = add2MultiDimFunctionGraphs(res, elt); break;

            case '-': res = subtract2MultiDimFunctionGraphs(res, elt); break;

            case '*': res = multiply2MultiDimFunctionGraphs(res, elt); break;

            case '/': res = divide2MultiDimFunctionGraphs(res, elt); break;

            default: break;
          }

          delete elt;

          if (temp != nullptr) delete temp;
        }
        reinterpret_cast< MultiDimFunctionGraph< GUM_SCALAR >* >(res)
           ->setTableName("Reward");
        __fmdp->addReward(res);
      }

      __resetParts();
      __states.pop_back();
    }
    //       VERBOSITY ( "reward OK" );
  }

Here is the call graph for this function:

endTransitionDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endTransitionDeclaration ( )

virtual

Tells the factory that we're out of a transition declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 377 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::TRANSITION.

                                                                  {
    if (state() != FMDPfactory_state::TRANSITION)
      __illegalStateError("endTransitionDeclaration");
    else
      __states.pop_back();

    //       VERBOSITY ( "transition OK" );
  }

Here is the call graph for this function:

endVariableDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration ( )

virtual

Tells the factory that we're out of a variable declaration.

Exceptions

UndefinedElement

Raised if the variable isn't defined (or not enough defined).

Implements gum::AbstractFMDPFactory.

Definition at line 209 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__bar_flag, gum::FMDPFactory< GUM_SCALAR >::__fmdp, gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::__varNameMap, gum::LabelizedVariable::addLabel(), GUM_ERROR, gum::Variable::name(), gum::FMDPFactory< GUM_SCALAR >::state(), and gum::VARIABLE.

                                                                {
    if (state() != FMDPfactory_state::VARIABLE)
      __illegalStateError("endVariableDeclaration");
    else if (__foo_flag && (__stringBag.size() > 3)) {
      LabelizedVariable* var = new LabelizedVariable(
         __stringBag[0], (__bar_flag) ? __stringBag[1] : "", 0);

      for (size_t i = 2; i < __stringBag.size(); ++i) {
        var->addLabel(__stringBag[i]);
      }

      __fmdp->addVariable(var);
      __varNameMap.insert(var->name(), var);
      __varNameMap.insert(__fmdp->main2prime(var)->name(),
                          __fmdp->main2prime(var));

      __resetParts();
      __states.pop_back();

      //         VERBOSITY ( "  variable " << var->name() << " OK" );

    } else {
      std::stringstream msg;
      msg << "Not enough modalities (";

      if (__stringBag.size() > 2)
        msg << __stringBag.size() - 2;
      else
        msg << 0;

      msg << ") declared for variable ";

      if (__foo_flag)
        msg << __stringBag[0];
      else
        msg << "unknown";

      __resetParts();
      __states.pop_back();

      GUM_ERROR(OperationNotAllowed, msg.str());
    }
  }

Here is the call graph for this function:

fmdp()

template<typename GUM_SCALAR >

INLINE FMDP< GUM_SCALAR > * gum::FMDPFactory< GUM_SCALAR >::fmdp

(

)

const

Returns the Factored Markov Decision Process created by this factory.

Exceptions

OperationNotAllowed

Raise if the state of the factory is different than NONE.

Definition at line 87 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__fmdp, GUM_ERROR, gum::NONE, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                   {
    if (state() != FMDPfactory_state::NONE)
      GUM_ERROR(OperationNotAllowed,
                "Illegal state to return the factored "
                "markov decision process: it is not yet "
                "finished.");

    return __fmdp;
  }

Here is the call graph for this function:

isVerbose()

bool gum::AbstractFMDPFactory::isVerbose ( )

inlineinherited

Definition at line 276 of file IfmdpFactory.h.

{ return __verbose; }

operator=()

template<typename GUM_SCALAR >

INLINE FMDPFactory< GUM_SCALAR > & gum::FMDPFactory< GUM_SCALAR >::operator= ( const FMDPFactory< GUM_SCALAR > &  source )

private

Copy operator is illegal, use only copy constructor.

Definition at line 761 of file fmdpFactory_tpl.h.

References GUM_ERROR.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph().

                                                                                       {
    GUM_ERROR(FatalError, "Illegal!");
    // For noisy compilers
    return *this;
  }

Here is the caller graph for this function:

resetVerbose()

void gum::AbstractFMDPFactory::resetVerbose ( )

inlineinherited

Definition at line 274 of file IfmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::FMDPFactory().

{ __verbose = false; }

Here is the caller graph for this function:

setOperationModeOn()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::setOperationModeOn ( std::string  operationType )

virtual

Tells the factory that we're in a reward declaration mode where the global reward diagram is an operation between simplier decision diagram..

Implements gum::AbstractFMDPFactory.

Definition at line 490 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__foo_flag, and gum::FMDPFactory< GUM_SCALAR >::__stringBag.

                                                                          {
    __foo_flag = true;
    std::string ot(operationType);
    __stringBag.push_back(ot);
  }

setRoot()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::setRoot ( NodeId  rootId )

virtual

add an arc in diagram

Implements gum::AbstractFMDPFactory.

Definition at line 657 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager(), and gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setRootNode().

                                                              {
    __FunctionGraph->manager()->setRootNode(rootId);
  }

Here is the call graph for this function:

setVerbose()

void gum::AbstractFMDPFactory::setVerbose ( )

inlineinherited

Definition at line 272 of file IfmdpFactory.h.

{ __verbose = true; }

startActionDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startActionDeclaration ( )

virtual

Tells the factory that we're in an action declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 267 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::ACTION, gum::NONE, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                {
    if (state() != FMDPfactory_state::NONE)
      __illegalStateError("startActionDeclaration");
    else {
      __foo_flag = true;
      __states.push_back(FMDPfactory_state::ACTION);
    }

    //       VERBOSITY ( "starting action declaration" );
  }

Here is the call graph for this function:

startCostDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startCostDeclaration ( )

virtual

Tells the factory that we're in a cost declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 401 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::ACTION, gum::COST, gum::NONE, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                              {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      __illegalStateError("startTransitionDeclaration");
    else
      __states.push_back(FMDPfactory_state::COST);

    //       VERBOSITY ( "starting Cost declaration" );
    this->__initializeFunctionGraph();
  }

Here is the call graph for this function:

startDiscountDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startDiscountDeclaration ( )

virtual

Tells the factory that we're in a cost declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 587 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::DISCOUNT, gum::NONE, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                  {
    if (state() != FMDPfactory_state::NONE)
      __illegalStateError("startDiscountDeclaration");
    else
      __states.push_back(FMDPfactory_state::DISCOUNT);

    //       VERBOSITY ( "starting discount declaration" );
  }

Here is the call graph for this function:

startRewardDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startRewardDeclaration ( )

virtual

Tells the factory that we're in a reward declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 474 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::ACTION, gum::NONE, gum::REWARD, and gum::FMDPFactory< GUM_SCALAR >::state().

                                                                {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      __illegalStateError("startRewardDeclaration");
    else
      __states.push_back(FMDPfactory_state::REWARD);

    //       VERBOSITY ( "starting reward declaration" );
    this->__initializeFunctionGraph();
  }

Here is the call graph for this function:

startTransitionDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startTransitionDeclaration ( )

virtual

Tells the factory that we're in a transition declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 321 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::ACTION, gum::NONE, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::TRANSITION.

                                                                    {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      __illegalStateError("startTransitionDeclaration");
    else
      __states.push_back(FMDPfactory_state::TRANSITION);

    //       VERBOSITY ( "starting transition declaration" );
    this->__initializeFunctionGraph();
  }

Here is the call graph for this function:

startVariableDeclaration()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::startVariableDeclaration ( )

virtual

Tells the factory that we're in a variable declaration.

Implements gum::AbstractFMDPFactory.

Definition at line 136 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__states, gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::NONE, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::VARIABLE.

                                                                  {
    if (state() != FMDPfactory_state::NONE)
      __illegalStateError("startVariableDeclaration");
    else {
      __states.push_back(FMDPfactory_state::VARIABLE);
      __stringBag.push_back("name");
      __stringBag.push_back("desc");
    }

    //       VERBOSITY ( "  starting variable" );
  }

Here is the call graph for this function:

state()

template<typename GUM_SCALAR >

INLINE FMDPfactory_state gum::FMDPFactory< GUM_SCALAR >::state ( ) const

virtual

Returns the current state of the factory.

Implements gum::AbstractFMDPFactory.

Definition at line 101 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__states.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::addAction(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addDiscount(), gum::FMDPFactory< GUM_SCALAR >::addModality(), gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::fmdp(), gum::FMDPFactory< GUM_SCALAR >::startActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::variableDescription(), and gum::FMDPFactory< GUM_SCALAR >::variableName().

                                                                  {
    // This is ok because there is alway at least the state
    // FMDPfactory_state::NONE in the stack.
    return __states.back();
  }

Here is the caller graph for this function:

variable()

template<typename GUM_SCALAR >

INLINE const DiscreteVariable * gum::FMDPFactory< GUM_SCALAR >::variable ( const std::string &  name ) const

virtual

Returns a constant reference on a variable given it's name.

Exceptions

NotFound

Raised if no variable matches the name.

Implements gum::AbstractFMDPFactory.

Definition at line 113 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__varNameMap, and GUM_ERROR.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addInternalNode().

                                                                              {
    for (const auto& elt : __varNameMap)
      if (elt.first.compare(name) == 0) return elt.second;

    GUM_ERROR(NotFound, name);

    return nullptr;
  }

Here is the caller graph for this function:

variableDescription()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::variableDescription ( const std::string &  desc )

virtual

Tells the factory the current variable's description.

Implements gum::AbstractFMDPFactory.

Definition at line 170 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__bar_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::VARIABLE.

                                                                         {
    if (state() != FMDPfactory_state::VARIABLE)
      __illegalStateError("variableDescription");
    else {
      __bar_flag = true;
      __stringBag[1] = desc;
    }
  }

Here is the call graph for this function:

variableName()

template<typename GUM_SCALAR >

INLINE void gum::FMDPFactory< GUM_SCALAR >::variableName ( const std::string &  name )

virtual

Tells the factory the current variable's name.

Exceptions

DuplicateElement

Raised if a variable with the same name already exist.

Implements gum::AbstractFMDPFactory.

Definition at line 152 of file fmdpFactory_tpl.h.

References gum::FMDPFactory< GUM_SCALAR >::__foo_flag, gum::FMDPFactory< GUM_SCALAR >::__illegalStateError(), gum::FMDPFactory< GUM_SCALAR >::__stringBag, gum::FMDPFactory< GUM_SCALAR >::__varNameMap, GUM_ERROR, gum::FMDPFactory< GUM_SCALAR >::state(), and gum::VARIABLE.

                                                                           {
    if (state() != FMDPfactory_state::VARIABLE)
      __illegalStateError("variableName");
    else {
      if (__varNameMap.exists(name))
        GUM_ERROR(DuplicateElement, "Name already used: " + name);

      __foo_flag = true;
      __stringBag[0] = name;
      //         VERBOSITY ( "  -- variable " << name );
    }
  }

Here is the call graph for this function:

Member Data Documentation

__actionIdcpt

template<typename GUM_SCALAR>

Idx gum::FMDPFactory< GUM_SCALAR >::__actionIdcpt

private

Action Id counter.

Definition at line 307 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addAction(), and gum::FMDPFactory< GUM_SCALAR >::FMDPFactory().

__bar_flag

template<typename GUM_SCALAR>

bool gum::FMDPFactory< GUM_SCALAR >::__bar_flag

private

Depending on the context this flag is used for some VERY important reasons.

Definition at line 271 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::variableDescription().

__ddBag

template<typename GUM_SCALAR>

std::vector< const MultiDimImplementation< GUM_SCALAR >* > gum::FMDPFactory< GUM_SCALAR >::__ddBag

private

Just to keep track of multidim between two start/end calls.

Definition at line 277 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::addReward(), and gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration().

__fmdp

template<typename GUM_SCALAR>

FMDP< GUM_SCALAR >* gum::FMDPFactory< GUM_SCALAR >::__fmdp

private

The constructed FMDP.

Definition at line 298 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::addAction(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::fmdp().

__foo_flag

template<typename GUM_SCALAR>

bool gum::FMDPFactory< GUM_SCALAR >::__foo_flag

private

Depending on the context this flag is used for some VERY important reasons.

Definition at line 267 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::setOperationModeOn(), gum::FMDPFactory< GUM_SCALAR >::startActionDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::variableName().

__FunctionGraph

template<typename GUM_SCALAR>

MultiDimFunctionGraph< GUM_SCALAR >* gum::FMDPFactory< GUM_SCALAR >::__FunctionGraph

private

The FunctionGraph we're building at a given time.

Definition at line 301 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::__initializeFunctionGraph(), gum::FMDPFactory< GUM_SCALAR >::addArc(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addInternalNode(), gum::FMDPFactory< GUM_SCALAR >::addReward(), gum::FMDPFactory< GUM_SCALAR >::addTerminalNode(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), and gum::FMDPFactory< GUM_SCALAR >::setRoot().

__states

template<typename GUM_SCALAR>

std::vector< FMDPfactory_state > gum::FMDPFactory< GUM_SCALAR >::__states

private

State stack.

Definition at line 295 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::endActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::FMDPFactory(), gum::FMDPFactory< GUM_SCALAR >::startActionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startCostDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startDiscountDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startTransitionDeclaration(), gum::FMDPFactory< GUM_SCALAR >::startVariableDeclaration(), and gum::FMDPFactory< GUM_SCALAR >::state().

__stringBag

template<typename GUM_SCALAR>

std::vector< std::string > gum::FMDPFactory< GUM_SCALAR >::__stringBag

private

Just to keep track of strings between two start/end calls.

Definition at line 274 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__checkModalityInBag(), gum::FMDPFactory< GUM_SCALAR >::__resetParts(), gum::FMDPFactory< GUM_SCALAR >::addAction(), gum::FMDPFactory< GUM_SCALAR >::addCost(), gum::FMDPFactory< GUM_SCALAR >::addModality(), gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endRewardDeclaration(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::setOperationModeOn(), gum::FMDPFactory< GUM_SCALAR >::startVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::variableDescription(), and gum::FMDPFactory< GUM_SCALAR >::variableName().

__varNameMap

template<typename GUM_SCALAR>

HashTable< std::string, const DiscreteVariable* > gum::FMDPFactory< GUM_SCALAR >::__varNameMap

private

Mapping between a declared variable's name and itself.

Definition at line 304 of file fmdpFactory.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::addTransition(), gum::FMDPFactory< GUM_SCALAR >::endVariableDeclaration(), gum::FMDPFactory< GUM_SCALAR >::variable(), and gum::FMDPFactory< GUM_SCALAR >::variableName().

---

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

• agrum/FMDP/fmdpFactory.h
• agrum/FMDP/fmdpFactory_tpl.h