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

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 284 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 665 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 420 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 437 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 614 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 649 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 185 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 506 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 522 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 657 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 337 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 360 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:

checkModalityInBag__()

template<typename GUM_SCALAR >

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

private

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

Definition at line 199 of file fmdpFactory_tpl.h.

References gum::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:

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 297 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 455 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 624 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 540 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 382 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 209 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:

finalizeFunctionGraph__()

template<typename GUM_SCALAR >

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

private

Insert every variables in the function graph.

Definition at line 762 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:

fmdp()

template<typename GUM_SCALAR >

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

(

)

const

Returns the Factored Markov Decision Process created by this factory.

Exceptions

OperationNotAllowed

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

Definition at line 87 of file fmdpFactory_tpl.h.

References gum::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:

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 688 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 742 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:

isVerbose()

bool gum::AbstractFMDPFactory::isVerbose ( )

inlineinherited

Definition at line 278 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 783 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:

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

resetVerbose()

void gum::AbstractFMDPFactory::resetVerbose ( )

inlineinherited

Definition at line 276 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 495 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 671 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 274 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 269 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 406 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 601 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 479 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 323 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 136 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 101 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 113 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 170 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 152 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 307 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 271 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 277 of file fmdpFactory.h.

fmdp__

template<typename GUM_SCALAR >

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

private

The constructed FMDP.

Definition at line 298 of file fmdpFactory.h.

foo_flag__

template<typename GUM_SCALAR >

bool gum::FMDPFactory< GUM_SCALAR >::foo_flag__

private

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

Definition at line 267 of file fmdpFactory.h.

FunctionGraph__

template<typename GUM_SCALAR >

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

private

The FunctionGraph we're building at a given time.

Definition at line 301 of file fmdpFactory.h.

states__

template<typename GUM_SCALAR >

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

private

State stack.

Definition at line 295 of file fmdpFactory.h.

stringBag__

template<typename GUM_SCALAR >

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

private

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

Definition at line 274 of file fmdpFactory.h.

varNameMap__

template<typename GUM_SCALAR >

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

private

Mapping between a declared variable's name and itself.

Definition at line 304 of file fmdpFactory.h.

---

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

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