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::Set< Key, Alloc >::emplace().

                                                                        : _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 69 of file fmdpFactory_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                 {
    GUM_DESTRUCTOR(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 195 of file fmdpFactory_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

_initializeFunctionGraph_()

template<typename GUM_SCALAR >

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

private

Insert every variables in the function graph.

Definition at line 723 of file fmdpFactory_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    _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 408 of file fmdpFactory_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::AbstractFMDPFactory::_verbose_.

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

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

resetVerbose()

void gum::AbstractFMDPFactory::resetVerbose ( )

inlineinherited

Definition at line 274 of file IfmdpFactory.h.

References gum::AbstractFMDPFactory::_verbose_.

{ _verbose_ = false; }

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

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

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

References gum::Set< Key, Alloc >::emplace().

                                                              {
    _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.

References gum::AbstractFMDPFactory::_verbose_.

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

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

References gum::Set< Key, Alloc >::emplace().

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

    GUM_ERROR(NotFound, name)

    return nullptr;
  }

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

References gum::Set< Key, Alloc >::emplace().

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

References gum::Set< Key, Alloc >::emplace().

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

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

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

_fmdp_

template<typename GUM_SCALAR >

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

private

The constructed FMDP.

Definition at line 297 of file fmdpFactory.h.

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

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

_states_

template<typename GUM_SCALAR >

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

private

State stack.

Definition at line 294 of file fmdpFactory.h.

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

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

---

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

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