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.
	~FMDPFactory ()
	Destructor.
Getter and setters.
FMDP< GUM_SCALAR > *	fmdp () const
	Returns the Factored Markov Decision Process created by this factory.
FMDPfactory_state	state () const
	Returns the current state of the factory.
const DiscreteVariable *	variable (const std::string &name) const
	Returns a constant reference on a variable given it's name.
Variable declaration methods (NONE -> VARIABLE)
void	startVariableDeclaration ()
	Tells the factory that we're in a variable declaration.
void	variableName (const std::string &name)
	Tells the factory the current variable's name.
void	variableDescription (const std::string &desc)
	Tells the factory the current variable's description.
void	addModality (const std::string &name)
	Adds a modality to the current variable.
void	endVariableDeclaration ()
	Tells the factory that we're out of a variable declaration.
Action declaration methods (NONE -> ACTION)
void	startActionDeclaration ()
	Tells the factory that we're in an action declaration.
void	addAction (const std::string &action)
	Tells the factory to add an action to the current fmdp.
void	endActionDeclaration ()
	Tells the factory that we're out of an action declaration.
Transition declaration methods (NONE -> TRANSITION <- ACTION)
void	startTransitionDeclaration ()
	Tells the factory that we're in a transition declaration.
void	addTransition (const std::string &var, const MultiDimAdressable *transition)
	Tells the factory to add a transition table to the current fmdp.
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.
void	endTransitionDeclaration ()
	Tells the factory that we're out of a transition declaration.
Cost declaration methods (NONE -> COST <- ACTION)
void	startCostDeclaration ()
	Tells the factory that we're in a cost declaration.
void	addCost (const MultiDimAdressable *cost)
	Tells the factory to add a cost table to the current fmdp.
void	addCost ()
	Tells the factory to add a cost table to the current fmdp. This cost table will be extracted from incorporated multiDimFunctionGraph.
void	endCostDeclaration ()
	Tells the factory that we're out of a cost declaration.
Reward declaration methods (NONE -> REWARD <- ACTION)
void	startRewardDeclaration ()
	Tells the factory that we're in a reward declaration.
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..
void	addReward (const MultiDimAdressable *reward)
	Tells the factory to add a reward table to the current fmdp.
void	addReward ()
	Tells the factory to add a reward table to the current fmdp. This reward table will be extracted from incorporated multiDimFunctionGraph.
void	endRewardDeclaration ()
	Tells the factory that we're out of a cost declaration.
Discount declaration methods (NONE -> DISCOUNT)
void	startDiscountDeclaration ()
	Tells the factory that we're in a cost declaration.
void	addDiscount (float discount)
	Tells the factory to add a cost table to the current fmdp.
void	endDiscountDeclaration ()
	Tells the factory that we're out of a cost declaration.
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.
NodeId	addTerminalNode (float value)
	Insert in diagram a terminal node.
void	addArc (NodeId from, NodeId to, Idx modality)
	Insert in diagram a non terminal node.
void	setRoot (NodeId rootId)
	add an arc in diagram
verbosity control
void	setVerbose ()
void	resetVerbose ()
bool	isVerbose ()

Private Member Functions
FMDPFactory< GUM_SCALAR > &	operator= (const FMDPFactory< GUM_SCALAR > &source)
	Copy operator is illegal, use only copy constructor.
void	_illegalStateError_ (const std::string &s)
	Raise an OperationNotAllowed with the message "Illegal state.".

Private Attributes
std::vector< FMDPfactory_state >	_states_
	State stack.
FMDP< GUM_SCALAR > *	_fmdp_
	The constructed FMDP.
MultiDimFunctionGraph< GUM_SCALAR > *	_FunctionGraph_
	The FunctionGraph we're building at a given time.
HashTable< std::string, const DiscreteVariable * >	_varNameMap_
	Mapping between a declared variable's name and itself.
Idx	_actionIdcpt_
	Action Id counter.
bool	_verbose_

Current constructed FMDP's parts.
bool	_foo_flag_
	Depending on the context this flag is used for some VERY important reasons.
bool	_bar_flag_
	Depending on the context this flag is used for some VERY important reasons.
std::vector< std::string >	_stringBag_
	Just to keep track of strings between two start/end calls.
std::vector< const MultiDimImplementation< GUM_SCALAR > * >	_ddBag_
	Just to keep track of multidim between two start/end calls.
void	_checkModalityInBag_ (const std::string &mod)
	Used in VARIABLE mode Checks if in stringBag there is no other modality with the same name.
void	_resetParts_ ()
	Reset the different parts used to constructed the FMDP.
void	_initializeFunctionGraph_ ()
	Insert every variables in the function graph.
void	_finalizeFunctionGraph_ ()
	Insert every variables in the function graph.

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 87 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 76 of file fmdpFactory_tpl.h.

                                                                        : _fmdp_(fmdp) {
    GUM_CONSTRUCTOR(FMDPFactory);
 
    _states_.push_back(FMDPfactory_state::NONE);
    resetVerbose();
    _actionIdcpt_ = 1;
  }

References FMDPFactory(), _actionIdcpt_, _fmdp_, _states_, fmdp(), gum::NONE, and gum::AbstractFMDPFactory::resetVerbose().

Referenced by FMDPFactory(), ~FMDPFactory(), and operator=().

Here is the call graph for this function:

Here is the caller 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 87 of file fmdpFactory_tpl.h.

                                                 {
    GUM_DESTRUCTOR(FMDPFactory);
  }

References FMDPFactory().

Here is the call graph for this function:

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 202 of file fmdpFactory_tpl.h.

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

References _stringBag_, and GUM_ERROR.

Referenced by addModality().

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 661 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

Referenced by addCost(), addReward(), and addTransition().

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 610 of file fmdpFactory_tpl.h.

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

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

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

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 647 of file fmdpFactory_tpl.h.

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

References _fmdp_, _FunctionGraph_, and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance().

Referenced by startCostDeclaration(), startRewardDeclaration(), and startTransitionDeclaration().

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 639 of file fmdpFactory_tpl.h.

                                                      {
    _foo_flag_ = false;
    _bar_flag_ = false;
    _stringBag_.clear();
    _ddBag_.clear();
  }

References _bar_flag_, _ddBag_, _foo_flag_, and _stringBag_.

Referenced by endActionDeclaration(), endRewardDeclaration(), and endVariableDeclaration().

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 275 of file fmdpFactory_tpl.h.

                                                                          {
    if (state() != FMDPfactory_state::ACTION) _illegalStateError_("addAction");
    else {
      _stringBag_.push_back(action);
      _fmdp_->addAction(_actionIdcpt_++, action);
    }
  }

References _actionIdcpt_, _fmdp_, _illegalStateError_(), _stringBag_, gum::ACTION, and state().

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 589 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

addCost() [1/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 403 of file fmdpFactory_tpl.h.

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

References _finalizeFunctionGraph_(), _fmdp_, _foo_flag_, _FunctionGraph_, _illegalStateError_(), _stringBag_, gum::COST, and state().

Here is the call graph for this function:

addCost() [2/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 390 of file fmdpFactory_tpl.h.

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

References _fmdp_, _foo_flag_, _illegalStateError_(), _stringBag_, gum::COST, and state().

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 546 of file fmdpFactory_tpl.h.

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

References _illegalStateError_(), gum::DISCOUNT, and state().

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 576 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_, and variable().

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 191 of file fmdpFactory_tpl.h.

                                                                          {
    if (state() != FMDPfactory_state::VARIABLE) _illegalStateError_("addModality");
    else {
      _checkModalityInBag_(name);
      _stringBag_.push_back(name);
    }
  }

References _checkModalityInBag_(), _illegalStateError_(), _stringBag_, state(), and gum::VARIABLE.

Here is the call graph for this function:

addReward() [1/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 473 of file fmdpFactory_tpl.h.

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

References _ddBag_, _finalizeFunctionGraph_(), _fmdp_, _foo_flag_, _FunctionGraph_, _illegalStateError_(), gum::REWARD, and state().

Here is the call graph for this function:

addReward() [2/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 460 of file fmdpFactory_tpl.h.

                                                                                   {
    const MultiDimImplementation< GUM_SCALAR >* r
        = reinterpret_cast< const MultiDimImplementation< GUM_SCALAR >* >(reward);
 
    if (state() != FMDPfactory_state::REWARD) _illegalStateError_("addReward");
    else _fmdp_->addReward(r);
  }

References _fmdp_, _illegalStateError_(), gum::REWARD, and state().

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 583 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

addTransition() [1/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 338 of file fmdpFactory_tpl.h.

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

References _finalizeFunctionGraph_(), _fmdp_, _foo_flag_, _FunctionGraph_, _illegalStateError_(), _stringBag_, _varNameMap_, state(), and gum::TRANSITION.

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, const MultiDimAdressable * transition )

virtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 322 of file fmdpFactory_tpl.h.

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

References _fmdp_, _foo_flag_, _illegalStateError_(), _stringBag_, _varNameMap_, state(), and gum::TRANSITION.

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 286 of file fmdpFactory_tpl.h.

                                                              {
    if (state() != FMDPfactory_state::ACTION) _illegalStateError_("endActionDeclaration");
    else {
      _states_.pop_back();
      _resetParts_();
    }
 
    //       VERBOSITY ( "action OK" );
  }

References _illegalStateError_(), _resetParts_(), _states_, gum::ACTION, and state().

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 417 of file fmdpFactory_tpl.h.

                                                            {
    if (state() != FMDPfactory_state::COST) _illegalStateError_("endCostDeclaration");
    else _states_.pop_back();
 
    //       VERBOSITY ( "Cost OK" );
  }

References _illegalStateError_(), _states_, gum::COST, and state().

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 555 of file fmdpFactory_tpl.h.

                                                                {
    if (state() != FMDPfactory_state::DISCOUNT) _illegalStateError_("endDiscountDeclaration");
    else _states_.pop_back();
 
    //       VERBOSITY ( "discount OK" );
  }

References _illegalStateError_(), _states_, gum::DISCOUNT, and state().

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 487 of file fmdpFactory_tpl.h.

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

References _ddBag_, _fmdp_, _foo_flag_, _illegalStateError_(), _resetParts_(), _states_, _stringBag_, gum::add2MultiDimFunctionGraphs(), gum::divide2MultiDimFunctionGraphs(), gum::multiply2MultiDimFunctionGraphs(), gum::REWARD, state(), and gum::subtract2MultiDimFunctionGraphs().

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 357 of file fmdpFactory_tpl.h.

                                                                  {
    if (state() != FMDPfactory_state::TRANSITION) _illegalStateError_("endTransitionDeclaration");
    else _states_.pop_back();
 
    //       VERBOSITY ( "transition OK" );
  }

References _illegalStateError_(), _states_, state(), and gum::TRANSITION.

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 211 of file fmdpFactory_tpl.h.

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

References _bar_flag_, _fmdp_, _foo_flag_, _illegalStateError_(), _resetParts_(), _states_, _stringBag_, _varNameMap_, gum::LabelizedVariable::addLabel(), GUM_ERROR, gum::Variable::name(), state(), and gum::VARIABLE.

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 104 of file fmdpFactory_tpl.h.

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

References _fmdp_, GUM_ERROR, gum::NONE, and state().

Referenced by FMDPFactory().

Here is the call graph for this function:

Here is the caller graph for this function:

isVerbose()

bool gum::AbstractFMDPFactory::isVerbose ( )

inlineinherited

Definition at line 291 of file IfmdpFactory.h.

{ return _verbose_; }

References _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 683 of file fmdpFactory_tpl.h.

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

References FMDPFactory(), and GUM_ERROR.

Here is the call graph for this function:

resetVerbose()

void gum::AbstractFMDPFactory::resetVerbose ( )

inlineinherited

Definition at line 289 of file IfmdpFactory.h.

{ _verbose_ = false; }

References _verbose_.

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

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 451 of file fmdpFactory_tpl.h.

                                                                                   {
    _foo_flag_ = true;
    std::string ot(operationType);
    _stringBag_.push_back(ot);
  }

References _foo_flag_, and _stringBag_.

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 594 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

setVerbose()

void gum::AbstractFMDPFactory::setVerbose ( )

inlineinherited

Definition at line 287 of file IfmdpFactory.h.

{ _verbose_ = true; }

References _verbose_.

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 262 of file fmdpFactory_tpl.h.

                                                                {
    if (state() != FMDPfactory_state::NONE) _illegalStateError_("startActionDeclaration");
    else {
      _foo_flag_ = true;
      _states_.push_back(FMDPfactory_state::ACTION);
    }
 
    //       VERBOSITY ( "starting action declaration" );
  }

References _foo_flag_, _illegalStateError_(), _states_, gum::ACTION, gum::NONE, and state().

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 378 of file fmdpFactory_tpl.h.

                                                              {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      _illegalStateError_("startTransitionDeclaration");
    else _states_.push_back(FMDPfactory_state::COST);
 
    //       VERBOSITY ( "starting Cost declaration" );
    this->_initializeFunctionGraph_();
  }

References _illegalStateError_(), _initializeFunctionGraph_(), _states_, gum::ACTION, gum::COST, gum::NONE, and state().

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 536 of file fmdpFactory_tpl.h.

                                                                  {
    if (state() != FMDPfactory_state::NONE) _illegalStateError_("startDiscountDeclaration");
    else _states_.push_back(FMDPfactory_state::DISCOUNT);
 
    //       VERBOSITY ( "starting discount declaration" );
  }

References _illegalStateError_(), _states_, gum::DISCOUNT, gum::NONE, and state().

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 438 of file fmdpFactory_tpl.h.

                                                                {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      _illegalStateError_("startRewardDeclaration");
    else _states_.push_back(FMDPfactory_state::REWARD);
 
    //       VERBOSITY ( "starting reward declaration" );
    this->_initializeFunctionGraph_();
  }

References _illegalStateError_(), _initializeFunctionGraph_(), _states_, gum::ACTION, gum::NONE, gum::REWARD, and state().

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 310 of file fmdpFactory_tpl.h.

                                                                    {
    if (state() != FMDPfactory_state::NONE && state() != FMDPfactory_state::ACTION)
      _illegalStateError_("startTransitionDeclaration");
    else _states_.push_back(FMDPfactory_state::TRANSITION);
 
    //       VERBOSITY ( "starting transition declaration" );
    this->_initializeFunctionGraph_();
  }

References _illegalStateError_(), _initializeFunctionGraph_(), _states_, gum::ACTION, gum::NONE, state(), and gum::TRANSITION.

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 150 of file fmdpFactory_tpl.h.

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

References _illegalStateError_(), _states_, _stringBag_, gum::NONE, state(), and gum::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 117 of file fmdpFactory_tpl.h.

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

References _states_.

Referenced by _illegalStateError_(), addAction(), addCost(), addCost(), addDiscount(), addModality(), addReward(), addReward(), addTransition(), addTransition(), endActionDeclaration(), endCostDeclaration(), endDiscountDeclaration(), endRewardDeclaration(), endTransitionDeclaration(), endVariableDeclaration(), fmdp(), startActionDeclaration(), startCostDeclaration(), startDiscountDeclaration(), startRewardDeclaration(), startTransitionDeclaration(), startVariableDeclaration(), variableDescription(), and variableName().

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 128 of file fmdpFactory_tpl.h.

                                                                     {
    for (const auto& elt: _varNameMap_)
      if (elt.first.compare(name) == 0) return elt.second;
 
    GUM_ERROR(NotFound, name)
 
    return nullptr;
  }

References _varNameMap_, and GUM_ERROR.

Referenced by addInternalNode().

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 178 of file fmdpFactory_tpl.h.

                                                                                  {
    if (state() != FMDPfactory_state::VARIABLE) _illegalStateError_("variableDescription");
    else {
      _bar_flag_     = true;
      _stringBag_[1] = desc;
    }
  }

References _bar_flag_, _illegalStateError_(), _stringBag_, state(), and gum::VARIABLE.

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 164 of file fmdpFactory_tpl.h.

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

References _foo_flag_, _illegalStateError_(), _stringBag_, _varNameMap_, GUM_ERROR, state(), and gum::VARIABLE.

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 322 of file fmdpFactory.h.

Referenced by FMDPFactory(), and addAction().

_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 286 of file fmdpFactory.h.

Referenced by _resetParts_(), endVariableDeclaration(), and 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 292 of file fmdpFactory.h.

Referenced by _resetParts_(), addReward(), and endRewardDeclaration().

_fmdp_

template<typename GUM_SCALAR>

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

private

The constructed FMDP.

Definition at line 313 of file fmdpFactory.h.

Referenced by FMDPFactory(), _initializeFunctionGraph_(), addAction(), addCost(), addCost(), addReward(), addReward(), addTransition(), addTransition(), endRewardDeclaration(), endVariableDeclaration(), and 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 282 of file fmdpFactory.h.

Referenced by _resetParts_(), addCost(), addCost(), addReward(), addTransition(), addTransition(), endRewardDeclaration(), endVariableDeclaration(), setOperationModeOn(), startActionDeclaration(), and 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 316 of file fmdpFactory.h.

Referenced by _finalizeFunctionGraph_(), _initializeFunctionGraph_(), addArc(), addCost(), addInternalNode(), addReward(), addTerminalNode(), addTransition(), and setRoot().

_states_

template<typename GUM_SCALAR>

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

private

State stack.

Definition at line 310 of file fmdpFactory.h.

Referenced by FMDPFactory(), endActionDeclaration(), endCostDeclaration(), endDiscountDeclaration(), endRewardDeclaration(), endTransitionDeclaration(), endVariableDeclaration(), startActionDeclaration(), startCostDeclaration(), startDiscountDeclaration(), startRewardDeclaration(), startTransitionDeclaration(), startVariableDeclaration(), and 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 289 of file fmdpFactory.h.

Referenced by _checkModalityInBag_(), _resetParts_(), addAction(), addCost(), addCost(), addModality(), addTransition(), addTransition(), endRewardDeclaration(), endVariableDeclaration(), setOperationModeOn(), startVariableDeclaration(), variableDescription(), and 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 319 of file fmdpFactory.h.

Referenced by addTransition(), addTransition(), endVariableDeclaration(), variable(), and variableName().

_verbose_

bool gum::AbstractFMDPFactory::_verbose_

privateinherited

Definition at line 296 of file IfmdpFactory.h.

Referenced by isVerbose(), resetVerbose(), and setVerbose().

---

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

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