gum::FMDPFactory< GUM_ELEMENT > 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_ELEMENT >:

Collaboration diagram for gum::FMDPFactory< GUM_ELEMENT >:

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

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

Private Attributes
std::vector< FMDPfactory_state >	_states_
	State stack.
FMDP< GUM_ELEMENT > *	_fmdp_
	The constructed FMDP.
MultiDimFunctionGraph< GUM_ELEMENT > *	_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_ELEMENT > * >	_ddBag_
	Just to keep track of multidim between two start/end calls.
void	_checkModalityInBag_ (std::string_view 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_ELEMENT>
class gum::FMDPFactory< GUM_ELEMENT >

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

Constructor & Destructor Documentation

FMDPFactory()

template<typename GUM_ELEMENT>

gum::FMDPFactory< GUM_ELEMENT >::FMDPFactory

(

FMDP< GUM_ELEMENT > *

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_ELEMENT>

gum::FMDPFactory< GUM_ELEMENT >::~FMDPFactory ( )

override

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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::_checkModalityInBag_ ( std::string_view 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.

                                                                          {
    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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::_finalizeFunctionGraph_ ( )

private

Insert every variables in the function graph.

Definition at line 649 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::_illegalStateError_ ( std::string_view s )

private

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

Definition at line 598 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::_initializeFunctionGraph_ ( )

private

Insert every variables in the function graph.

Definition at line 635 of file fmdpFactory_tpl.h.

                                                             {
    this->_FunctionGraph_ = MultiDimFunctionGraph< GUM_ELEMENT >::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_ELEMENT, 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::_resetParts_ ( )

private

Reset the different parts used to constructed the FMDP.

Definition at line 627 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addAction ( std::string_view action )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 265 of file fmdpFactory_tpl.h.

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

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

Here is the call graph for this function:

addArc()

template<typename GUM_ELEMENT>

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

overridevirtual

Insert in diagram a non terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 578 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

addCost() [1/2]

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addCost ( )

overridevirtual

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 392 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_ELEMENT>

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

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 379 of file fmdpFactory_tpl.h.

                                                                         {
    const MultiDimImplementation< GUM_ELEMENT >* c
        = static_cast< const MultiDimImplementation< GUM_ELEMENT >* >(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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addDiscount ( float discount )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 537 of file fmdpFactory_tpl.h.

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

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

Here is the call graph for this function:

addInternalNode()

template<typename GUM_ELEMENT>

NodeId gum::FMDPFactory< GUM_ELEMENT >::addInternalNode ( std::string_view name_of_var )

overridevirtual

Insert in diagram a non terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 565 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addModality ( std::string_view name )

overridevirtual

Adds a modality to the current variable.

Implements gum::AbstractFMDPFactory.

Definition at line 188 of file fmdpFactory_tpl.h.

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

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

Here is the call graph for this function:

addReward() [1/2]

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addReward ( )

overridevirtual

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 460 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_ELEMENT>

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

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 447 of file fmdpFactory_tpl.h.

                                                                             {
    const MultiDimImplementation< GUM_ELEMENT >* r
        = static_cast< const MultiDimImplementation< GUM_ELEMENT >* >(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_ELEMENT>

NodeId gum::FMDPFactory< GUM_ELEMENT >::addTerminalNode ( float value )

overridevirtual

Insert in diagram a terminal node.

Implements gum::AbstractFMDPFactory.

Definition at line 572 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

addTransition() [1/2]

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addTransition ( std::string_view var )

overridevirtual

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 327 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 : " + std::string(var));
        _fmdp_->addTransitionForAction(_fmdp_->actionId(_stringBag_[0]),
                                       variable(var),
                                       this->_FunctionGraph_);
      } else {
        _fmdp_->addTransition(variable(var), this->_FunctionGraph_);
      }
    }
  }

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

Here is the call graph for this function:

addTransition() [2/2]

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::addTransition ( std::string_view var, const MultiDimAdressable * transition )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 311 of file fmdpFactory_tpl.h.

                                                                                       {
    const MultiDimImplementation< GUM_ELEMENT >* t
        = static_cast< const MultiDimImplementation< GUM_ELEMENT >* >(transition);
 
    if (state() != FMDPfactory_state::TRANSITION) _illegalStateError_("addTransition");
    else if (_foo_flag_)
      _fmdp_->addTransitionForAction(_fmdp_->actionId(_stringBag_[0]), variable(var), t);
    else _fmdp_->addTransition(variable(var), t);
  }

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

Here is the call graph for this function:

endActionDeclaration()

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endActionDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 276 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endCostDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 406 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endDiscountDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 545 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endRewardDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 474 of file fmdpFactory_tpl.h.

                                                        {
    if (state() != FMDPfactory_state::REWARD) _illegalStateError_("endRewardDeclaration");
    else {
      if (_foo_flag_) {
        MultiDimImplementation< GUM_ELEMENT >* res = nullptr;
 
        for (const auto elt: _ddBag_) {
          if (res == nullptr) {
            res = const_cast< MultiDimImplementation< GUM_ELEMENT >* >(elt);
            continue;
          }
          MultiDimImplementation< GUM_ELEMENT >* 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;
          delete temp;
        }
 
        if (res != nullptr) {
          static_cast< MultiDimFunctionGraph< GUM_ELEMENT >* >(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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endTransitionDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 347 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::endVariableDeclaration ( )

overridevirtual

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 208 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);
      _fmdp_->setDeleteVariablesOnDestruction(true);
      _varNameMap_.insert(var->name(), var);
      _varNameMap_.insert(_fmdp_->main2prime(var)->name(), _fmdp_->main2prime(var));
 
      _resetParts_();
      _states_.pop_back();
 
      //         VERBOSITY ( "  variable " << var->name() << " OK" );
 
    } else {
      const size_t      nModa   = _stringBag_.size() > 2 ? _stringBag_.size() - 2 : size_t{0};
      const std::string varName = _foo_flag_ ? _stringBag_[0] : "unknown";
 
      _resetParts_();
      _states_.pop_back();
 
      GUM_ERROR(OperationNotAllowed,
                std::format("Not enough modalities ({}) declared for variable {}", nModa, varName))
    }
  }

References gum::LabelizedVariable::LabelizedVariable(), _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_ELEMENT>

FMDP< GUM_ELEMENT > * gum::FMDPFactory< GUM_ELEMENT >::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 103 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()

INLINE bool gum::AbstractFMDPFactory::isVerbose ( )

inherited

Definition at line 52 of file IfmdpFactory_inl.h.

{ return _verbose_; }

References _verbose_.

Referenced by setRoot().

Here is the caller graph for this function:

operator=()

template<typename GUM_ELEMENT>

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

private

Copy operator is illegal, use only copy constructor.

Definition at line 671 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()

INLINE void gum::AbstractFMDPFactory::resetVerbose ( )

inherited

Definition at line 50 of file IfmdpFactory_inl.h.

{ _verbose_ = false; }

References _verbose_.

Referenced by gum::FMDPFactory< GUM_ELEMENT >::FMDPFactory(), and setRoot().

Here is the caller graph for this function:

setOperationModeOn()

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::setOperationModeOn ( std::string_view operationType )

overridevirtual

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

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

References _foo_flag_, and _stringBag_.

setRoot()

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::setRoot ( NodeId rootId )

overridevirtual

add an arc in diagram

Implements gum::AbstractFMDPFactory.

Definition at line 583 of file fmdpFactory_tpl.h.

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

References _FunctionGraph_.

setVerbose()

INLINE void gum::AbstractFMDPFactory::setVerbose ( )

inherited

Definition at line 48 of file IfmdpFactory_inl.h.

{ _verbose_ = true; }

References _verbose_.

Referenced by setRoot().

Here is the caller graph for this function:

startActionDeclaration()

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startActionDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 252 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startCostDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 367 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startDiscountDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 527 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startRewardDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 426 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startTransitionDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 299 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::startVariableDeclaration ( )

overridevirtual

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

Implements gum::AbstractFMDPFactory.

Definition at line 147 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_ELEMENT>

FMDPfactory_state gum::FMDPFactory< GUM_ELEMENT >::state ( ) const

overridevirtual

Returns the current state of the factory.

Implements gum::AbstractFMDPFactory.

Definition at line 116 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_ELEMENT>

const DiscreteVariable * gum::FMDPFactory< GUM_ELEMENT >::variable ( std::string_view name ) const

overridevirtual

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 126 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(), addTransition(), and addTransition().

Here is the caller graph for this function:

variableDescription()

template<typename GUM_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::variableDescription ( std::string_view desc )

overridevirtual

Tells the factory the current variable's description.

Implements gum::AbstractFMDPFactory.

Definition at line 175 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_ELEMENT>

void gum::FMDPFactory< GUM_ELEMENT >::variableName ( std::string_view name )

overridevirtual

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 161 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_ELEMENT>

Idx gum::FMDPFactory< GUM_ELEMENT >::_actionIdcpt_

private

Action Id counter.

Definition at line 324 of file fmdpFactory.h.

Referenced by FMDPFactory(), and addAction().

_bar_flag_

template<typename GUM_ELEMENT>

bool gum::FMDPFactory< GUM_ELEMENT >::_bar_flag_

private

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

Definition at line 288 of file fmdpFactory.h.

Referenced by _resetParts_(), endVariableDeclaration(), and variableDescription().

_ddBag_

template<typename GUM_ELEMENT>

std::vector< const MultiDimImplementation< GUM_ELEMENT >* > gum::FMDPFactory< GUM_ELEMENT >::_ddBag_

private

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

Definition at line 294 of file fmdpFactory.h.

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

_fmdp_

template<typename GUM_ELEMENT>

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

private

The constructed FMDP.

Definition at line 315 of file fmdpFactory.h.

Referenced by FMDPFactory(), _initializeFunctionGraph_(), addAction(), addCost(), addCost(), addDiscount(), addReward(), addReward(), addTransition(), addTransition(), endRewardDeclaration(), endVariableDeclaration(), and fmdp().

_foo_flag_

template<typename GUM_ELEMENT>

bool gum::FMDPFactory< GUM_ELEMENT >::_foo_flag_

private

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

Definition at line 284 of file fmdpFactory.h.

Referenced by _resetParts_(), addCost(), addCost(), addReward(), addTransition(), addTransition(), endRewardDeclaration(), endVariableDeclaration(), setOperationModeOn(), startActionDeclaration(), and variableName().

_FunctionGraph_

template<typename GUM_ELEMENT>

MultiDimFunctionGraph< GUM_ELEMENT >* gum::FMDPFactory< GUM_ELEMENT >::_FunctionGraph_

private

The FunctionGraph we're building at a given time.

Definition at line 318 of file fmdpFactory.h.

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

_states_

template<typename GUM_ELEMENT>

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

private

State stack.

Definition at line 312 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_ELEMENT>

std::vector< std::string > gum::FMDPFactory< GUM_ELEMENT >::_stringBag_

private

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

Definition at line 291 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_ELEMENT>

HashTable< std::string, const DiscreteVariable* > gum::FMDPFactory< GUM_ELEMENT >::_varNameMap_

private

Mapping between a declared variable's name and itself.

Definition at line 321 of file fmdpFactory.h.

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

_verbose_

bool gum::AbstractFMDPFactory::_verbose_

privateinherited

Definition at line 298 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