gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy > Class Template Reference

#include <multiDimFunctionGraph.h>

Inheritance diagram for gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >:

Collaboration diagram for gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >:

Public Member Functions
void	clean ()
	Removes var without nodes in the diagram. More...
Inherited methods
virtual NodeId	addInternalNode (const DiscreteVariable *var, NodeId *sons)
	Inserts a new non terminal node in graph. More...
virtual void	reduce ()
	Ensures that every isomorphic subgraphs are merged together. More...

Protected Member Functions
Redundancy methods.
NodeId	_nodeRedundancyCheck (const DiscreteVariable *var, NodeId *sonsMap)
	Check for redundancy. More...
void	_reduce ()
	Ensures that every isomorphic subgraphs are merged together. More...

Friends
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > *	MultiDimFunctionGraph ()
	This friend methods from is the only way to get an instance of a manager. More...

Nodes manipulation methods.
void	setRootNode (const NodeId &root)
	Sets root node of decision diagram. More...
NodeId	addInternalNode (const DiscreteVariable *var)
	Inserts a new non terminal node in graph. More...
NodeId	addInternalNode (const DiscreteVariable *var, NodeId nid)
	Inserts a new non terminal node in graph. More...
NodeId	addTerminalNode (const GUM_SCALAR &value)
	Adds a value to the MultiDimFunctionGraph. More...
void	eraseNode (NodeId id, NodeId replacingId=0, bool updateParents=true)
	Erases a node from the diagram. More...
NodeId	_addInternalNode (const DiscreteVariable *var, NodeId *sons)
	Adds an internal node. More...

Manipulation methods.
void	setSon (const NodeId &node, const Idx &modality, const NodeId &sonNode)
	Sets nodes son for given modality to designated son node. More...
void	minimizeSize ()
	Performs a sifting in search of a(local) minimal size. More...
void	moveTo (const DiscreteVariable *x, Idx desiredPos)
	Changes var position in variable sequence. More...
void	_migrateNode (const NodeId &x, const NodeId &y)
	Remaps all arcs going to ou going from the first given node to the second node, then delete first node. More...

Constructor and destructor
	MultiDimFunctionGraphTreeManager (MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *master)
	Class constructor. More...
	~MultiDimFunctionGraphTreeManager ()
	Class destructor. More...

Detailed Description

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy>
class gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >

Warning

Doxygen does not like spanning command on multiple line, so we could not configure it with the correct include directive. Use the following code snippet to include this file.

#include <agrum/multidim/implementations/multiDimFunctionGraphManager.h>

Template Parameters

GUM_SCALAR	The type of scalars stored in the multidimensional table.
TerminalNodePolicy	The terminal node policy to use.

Definition at line 58 of file multiDimFunctionGraph.h.

Constructor & Destructor Documentation

MultiDimFunctionGraphTreeManager()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraphTreeManager ( MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *  master )

private

Class constructor.

Definition at line 570 of file multiDimFunctionGraphManager_tpl.h.

References gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraphTreeManager().

Referenced by gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::clean().

                                                                         :
      MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >(master) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphTreeManager);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

~MultiDimFunctionGraphTreeManager()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraphTreeManager

(

)

Class destructor.

Definition at line 578 of file multiDimFunctionGraphManager_tpl.h.

References gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode().

Referenced by gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraphTreeManager().

                                         {
    GUM_DESTRUCTOR(MultiDimFunctionGraphTreeManager);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

_addInternalNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::_addInternalNode ( const DiscreteVariable *  var, NodeId *  sons  )

protectedinherited

Adds an internal node.

Parameters

var	The node to add.
sons	The node sons.

Returns

Returns the added node id.

Definition at line 87 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::addInternalNode(), and gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode().

                                                                 {
    InternalNode* newNodeStruct = new InternalNode(var, sons);
    NodeId        nid = __functionGraph->__model.addNode();
    __functionGraph->__internalNodeMap.insert(nid, newNodeStruct);
    __functionGraph->__var2NodeIdMap[var]->addLink(nid);
    for (Idx i = 0; i < newNodeStruct->nbSons(); i++)
      if (!__functionGraph->isTerminalNode(sons[i]))
        __functionGraph->__internalNodeMap[sons[i]]->addParent(nid, i);

    return nid;
  }

Here is the caller graph for this function:

_migrateNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::_migrateNode ( const NodeId &  x, const NodeId &  y  )

protectedinherited

Remaps all arcs going to ou going from the first given node to the second node, then delete first node.

Parameters

x	The variable from which all arcs are removed.
y	The variable for which all of x arcs are added.

Definition at line 409 of file multiDimFunctionGraphManager_tpl.h.

                                                         {
    InternalNode* org = __functionGraph->__internalNodeMap[origin];
    // Upating parents after the change
    Link< Parent >* picle = org->parents();
    while (picle != nullptr) {
      setSon(picle->element().parentId, picle->element().modality, destination);
      picle = picle->nextLink();
    }

    // Updating sons after the change
    for (Idx i = 0; i < org->nbSons(); ++i)
      if (__functionGraph->__internalNodeMap.exists(org->son(i)))
        __functionGraph->__internalNodeMap[org->son(i)]->removeParent(origin, i);

    delete org;
    __functionGraph->__internalNodeMap.erase(origin);
    __functionGraph->__model.eraseNode(origin);

    if (__functionGraph->root() == origin) this->setRootNode(destination);
  }

_nodeRedundancyCheck()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::_nodeRedundancyCheck ( const DiscreteVariable *  var, NodeId *  sonsMap  )

protectedinherited

Check for redundancy.

Checks if a similar node does not already exists in the graph or if it has the same child for every variable value. If no node is a match, this node is added to the graph.

Warning

: will free by itslef sonsMap if a match exists.

Parameters

var	The node to add in the graph.
sonsMap	The node sons.

Returns

Returns the nodes id in the graph.

Definition at line 435 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::_migrateNode(), and gum::MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode().

                                                                        {
    NodeId newNode = sonsIds[0];

    if (__isRedundant(var, sonsIds)) {
      SOA_DEALLOCATE(sonsIds, sizeof(NodeId) * var->domainSize());
    } else {
      newNode = __checkIsomorphism(var, sonsIds);
      if (newNode == 0) {
        newNode = _addInternalNode(var, sonsIds);
      } else {
        SOA_DEALLOCATE(sonsIds, sizeof(NodeId) * var->domainSize());
      }
    }

    return newNode;
  }

Here is the caller graph for this function:

_reduce()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::_reduce ( )

protectedinherited

Ensures that every isomorphic subgraphs are merged together.

Definition at line 488 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >::reduce().

                                                                             {
    Link< NodeId >* currentNodeId = nullptr;
    Link< NodeId >* nextNodeId = nullptr;
    InternalNode*   currentNode = nullptr;
    bool            theSame = true;
    Idx             currentInd;

    for (SequenceIterator< const DiscreteVariable* > varIter =
            __functionGraph->variablesSequence().rbegin();
         varIter != __functionGraph->variablesSequence().rend();
         --varIter) {
      currentNodeId = __functionGraph->__var2NodeIdMap[*varIter]->list();

      while (currentNodeId != nullptr) {
        nextNodeId = currentNodeId->nextLink();
        currentNode = __functionGraph->__internalNodeMap[currentNodeId->element()];

        // First isomorphism to handle is the one where all node children are
        // the same
        theSame = true;
        for (currentInd = 1; currentInd < (*varIter)->domainSize(); currentInd++) {
          if (currentNode->son(currentInd) != currentNode->son(0)) {
            theSame = false;
            break;
          }
        }

        if (theSame == true) {
          _migrateNode(currentNodeId->element(), currentNode->son(0));
          __functionGraph->__var2NodeIdMap[*varIter]->searchAndRemoveLink(
             currentNodeId->element());
          currentNodeId = nextNodeId;
          continue;
        }

        // Second isomorphism to handle is the one where two nodes have same
        // variable and same children
        if (nextNodeId) {
          Link< NodeId >* anotherNodeId = currentNodeId->nextLink();
          InternalNode*   anotherNode = nullptr;
          Idx             modality = 0;
          while (anotherNodeId->nextLink() != nullptr) {
            nextNodeId = anotherNodeId->nextLink();
            anotherNode =
               __functionGraph->__internalNodeMap[anotherNodeId->element()];

            // Check on the other sons
            for (modality = 0; modality < (*varIter)->domainSize(); ++modality) {
              if (anotherNode->son(modality) != currentNode->son(modality)) break;
              if (modality == (*varIter)->domainSize() - 1) {
                _migrateNode(anotherNodeId->element(), currentNodeId->element());
                __functionGraph->__var2NodeIdMap[*varIter]->searchAndRemoveLink(
                   anotherNodeId->element());
              }
            }

            anotherNodeId = nextNodeId;
          }
        }
        currentNodeId = currentNodeId->nextLink();
      }
    }
  }

Here is the caller graph for this function:

addInternalNode() [1/3]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode ( const DiscreteVariable *  var )

inherited

Inserts a new non terminal node in graph.

NodeId of this node is generated automatically.

Parameters

var	Associated variable

Returns

The id of the added non terminal node.

Definition at line 76 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::StatesCounter::__incState(), gum::IMDDI< AttributeSelection, isScalar >::__insertLeafInFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertNodeInFunctionGraph(), gum::StatesChecker::__insertState(), gum::ITI< AttributeSelection, isScalar >::__insertTerminalNode(), gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), gum::AdaptiveRMaxPlaner::__visitLearner(), gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::addInternalNode(), gum::FMDPFactory< GUM_SCALAR >::addInternalNode(), gum::MultiDimFunctionGraphGenerator::generate(), and gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::setRootNode().

                                                  {
    InternalNode* newNodeStruct = new InternalNode(var);
    NodeId        nid = __functionGraph->__model.addNode();
    __functionGraph->__internalNodeMap.insert(nid, newNodeStruct);
    __functionGraph->__var2NodeIdMap[var]->addLink(nid);

    return nid;
  }

Here is the caller graph for this function:

addInternalNode() [2/3]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode ( const DiscreteVariable *  var, NodeId  nid  )

inherited

Inserts a new non terminal node in graph.

NodeId of this node is generated automatically.

Parameters

var	The ssociated variable.
nid	The desired id for that node.

Returns

Returns the id of the added non terminal node.

Exceptions

OperationNotAllowed

Raised if MultiDimFunctionGraph has no variable yet.

Definition at line 64 of file multiDimFunctionGraphManager_tpl.h.

                                                              {
    InternalNode* newNodeStruct = new InternalNode(var);

    __functionGraph->__internalNodeMap.insert(nid, newNodeStruct);

    __functionGraph->__var2NodeIdMap[var]->addLink(nid);

    return nid;
  }

addInternalNode() [3/3]

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

NodeId gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode ( const DiscreteVariable *  var, NodeId *  sons  )

virtual

Inserts a new non terminal node in graph.

NodeId of this node is generated automatically.

Parameters

var	The associated variable.
sons	A table of size var->domainSize() containing nodeid of sons nodes.

Returns

Returns the id of the added non terminal node.

Exceptions

OperationNotAllowed

Raised if MultiDimFunctionGraph has no variable yet.

Implements gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >.

Definition at line 584 of file multiDimFunctionGraphManager_tpl.h.

References gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::_addInternalNode().

Referenced by gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraphTreeManager().

                                                                {
    return this->_addInternalNode(var, sons);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

addTerminalNode()

template<typename GUM_SCALAR, template< class > class TerminalNodePolicy>

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addTerminalNode ( const GUM_SCALAR &  value )

inherited

Adds a value to the MultiDimFunctionGraph.

This will create a terminal node, which of id is returned. If a terminal node with such value already exists, its id will be return instead.

Parameters

value

The value added by copy.

Returns

Returns he id of the terminal node hence created.

Definition at line 102 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::StatesCounter::__incState(), gum::IMDDI< AttributeSelection, isScalar >::__insertLeafInFunctionGraph(), gum::ITI< AttributeSelection, isScalar >::__insertTerminalNode(), gum::AdaptiveRMaxPlaner::__visitLearner(), gum::MultiDimFunctionGraphManager< bool, ExactTerminalNodePolicy >::_addInternalNode(), gum::AdaptiveRMaxPlaner::_initVFunction(), gum::FMDPFactory< GUM_SCALAR >::addTerminalNode(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::reset(), and gum::StatesChecker::reset().

                                              {
    if (__functionGraph->existsTerminalNodeWithValue(value))
      return __functionGraph->terminalNodeId(value);

    NodeId node = __functionGraph->__model.addNode();
    __functionGraph->addTerminalNode(node, value);
    return node;
  }

Here is the caller graph for this function:

clean()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::clean ( )

inherited

Removes var without nodes in the diagram.

Definition at line 554 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::FMDPFactory< GUM_SCALAR >::__finalizeFunctionGraph(), gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), and gum::MultiDimFunctionGraphGenerator::generate().

                                                                           {
    Sequence< const DiscreteVariable* > oldSequence(
       __functionGraph->variablesSequence());
    for (SequenceIterator< const DiscreteVariable* > varIter = oldSequence.begin();
         varIter != oldSequence.end();
         ++varIter)
      if (!__functionGraph->varNodeListe(*varIter)->list())
        __functionGraph->erase(**varIter);
  }

Here is the caller graph for this function:

eraseNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::eraseNode ( NodeId  id, NodeId  replacingId = 0, bool  updateParents = true  )

inherited

Erases a node from the diagram.

Parameters

id	The id of the variable to erase.
replacingId	Offers the possibility to reroute any parent to the given node.
updateParents	Indicates if such remapping has to be done.

Exceptions

NotFound

Raised if node isn't in diagram.

Definition at line 113 of file multiDimFunctionGraphManager_tpl.h.

                                                             {
    if (!__functionGraph->__model.exists(eraseId))
      GUM_ERROR(NotFound, "Node : " << eraseId << " doesn't exists in the graph")

    if (__functionGraph->isTerminalNode(eraseId)) {
      for (auto iterVar = __functionGraph->variablesSequence().begin();
           iterVar != __functionGraph->variablesSequence().end();
           ++iterVar) {
        Link< NodeId >* nodeIter =
           __functionGraph->__var2NodeIdMap[*iterVar]->list();
        while (nodeIter != nullptr) {
          for (Idx modality = 0; modality < (*iterVar)->domainSize(); ++modality)
            if (__functionGraph->node(nodeIter->element())->son(modality)
                == eraseId)
              setSon(nodeIter->element(), modality, replacingId);

          nodeIter = nodeIter->nextLink();
        }
      }
      __functionGraph->eraseTerminalNode(eraseId);

    } else {
      InternalNode* eraseNode = __functionGraph->__internalNodeMap[eraseId];

      if (updateParents) {
        Link< Parent >* picle = eraseNode->parents();
        while (picle != nullptr) {
          setSon(
             picle->element().parentId, picle->element().modality, replacingId);
          picle = picle->nextLink();
        }
      }

      __functionGraph
         ->__var2NodeIdMap[__functionGraph->__internalNodeMap[eraseId]->nodeVar()]
         ->searchAndRemoveLink(eraseId);

      delete __functionGraph->__internalNodeMap[eraseId];
      __functionGraph->__internalNodeMap.erase(eraseId);
    }

    __functionGraph->__model.eraseNode(eraseId);

    if (__functionGraph->__root == eraseId) __functionGraph->__root = replacingId;
  }

minimizeSize()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::minimizeSize ( )

inherited

Performs a sifting in search of a(local) minimal size.

Definition at line 211 of file multiDimFunctionGraphManager_tpl.h.

                                                                        {
    // Ordering variables by number of nodes asssociated to them
    Sequence< const DiscreteVariable* >       siftingSeq;
    HashTable< const DiscreteVariable*, Idx > varLvlSize;
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter =
            __functionGraph->variablesSequence().beginSafe();
         varIter != __functionGraph->variablesSequence().endSafe();
         ++varIter) {
      const Link< NodeId >* curElem =
         __functionGraph->__var2NodeIdMap[*varIter]->list();
      Idx nbElem = 0;
      for (; curElem != nullptr; nbElem++, curElem = curElem->nextLink())
        ;
      varLvlSize.insert(*varIter, nbElem);
      siftingSeq.insert(*varIter);
      Idx pos = siftingSeq.pos(*varIter);
      while (pos > 0 && varLvlSize[siftingSeq.atPos(pos - 1)] > nbElem) {
        siftingSeq.swap(pos - 1, pos);
        pos--;
      }
    }

    // Sifting var par var
    for (SequenceIteratorSafe< const DiscreteVariable* > sifIter =
            siftingSeq.beginSafe();
         sifIter != siftingSeq.endSafe();
         ++sifIter) {
      // Initialization
      Idx currentPos = __functionGraph->variablesSequence().pos(*sifIter);
      Idx bestSize = __functionGraph->realSize();
      Idx bestPos = currentPos;


      // Sifting towards upper places
      while (currentPos > 0) {
        moveTo(*sifIter, currentPos - 1);
        currentPos = __functionGraph->variablesSequence().pos(*sifIter);
        if (__functionGraph->realSize() < bestSize) {
          bestPos = currentPos;
          bestSize = __functionGraph->realSize();
        }
      }

      // Sifting towards lower places
      while (currentPos < __functionGraph->variablesSequence().size() - 1) {
        moveTo(*sifIter, currentPos + 1);
        currentPos = __functionGraph->variablesSequence().pos(*sifIter);
        if (__functionGraph->realSize() < bestSize) {
          bestPos = currentPos;
          bestSize = __functionGraph->realSize();
        }
      }

      moveTo(*sifIter, bestPos);
    }
  }

moveTo()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::moveTo ( const DiscreteVariable *  x, Idx  desiredPos  )

inherited

Changes var position in variable sequence.

Parameters

x	The varaible to change.
desiredPos	The new posiition.

Definition at line 270 of file multiDimFunctionGraphManager_tpl.h.

                                                       {
    // First we determine the position of both variable
    // We also determine which one precede the other
    if (__functionGraph->variablesSequence().pos(movedVar) > desiredPos)
      for (Idx currentPos = __functionGraph->variablesSequence().pos(movedVar);
           currentPos != desiredPos;
           currentPos--) {
        const DiscreteVariable* preVar =
           __functionGraph->variablesSequence().atPos(currentPos - 1);
        if (__functionGraph->__var2NodeIdMap[preVar]->list()
            && __functionGraph->__var2NodeIdMap[movedVar]->list())
          __adjacentSwap(preVar, movedVar);
        __functionGraph->_invert(currentPos - 1, currentPos);
      }
    else
      for (Idx currentPos = __functionGraph->variablesSequence().pos(movedVar);
           currentPos != desiredPos;
           currentPos++) {
        const DiscreteVariable* suiVar =
           __functionGraph->variablesSequence().atPos(currentPos + 1);
        if (__functionGraph->__var2NodeIdMap[suiVar]->list()
            && __functionGraph->__var2NodeIdMap[movedVar]->list())
          __adjacentSwap(movedVar, suiVar);
        __functionGraph->_invert(currentPos, currentPos + 1);
      }
  }

reduce()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

void gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >::reduce ( )

virtual

Ensures that every isomorphic subgraphs are merged together.

Implements gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >.

Definition at line 590 of file multiDimFunctionGraphManager_tpl.h.

References gum::MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >::MultiDimFunctionGraphROManager().

                                                                                {
  }

Here is the call graph for this function:

setRootNode()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setRootNode ( const NodeId &  root )

inherited

Sets root node of decision diagram.

Parameters

root	The node to set as root.

Definition at line 56 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::StatesCounter::__incState(), gum::StatesChecker::__insertState(), gum::AdaptiveRMaxPlaner::__makeRMaxFunctionGraphs(), gum::IMDDI< AttributeSelection, isScalar >::__rebuildFunctionGraph(), gum::AdaptiveRMaxPlaner::_initVFunction(), gum::StructuredPlaner< double >::_makeArgMax(), gum::MultiDimFunctionGraphGenerator::generate(), gum::StatesCounter::reset(), gum::FMDPFactory< GUM_SCALAR >::setRoot(), and gum::ITI< AttributeSelection, isScalar >::updateFunctionGraph().

                            {
    __functionGraph->__root = root;
  }

Here is the caller graph for this function:

setSon()

template<typename GUM_SCALAR , template< class > class TerminalNodePolicy>

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setSon ( const NodeId &  node, const Idx &  modality, const NodeId &  sonNode  )

inherited

Sets nodes son for given modality to designated son node.

Parameters

node	The node to which a node is added.
modality	The modality for which sonNode is added to node.
sonNode	The node to add as a son to node.

Definition at line 163 of file multiDimFunctionGraphManager_tpl.h.

Referenced by gum::StatesCounter::__incState(), gum::ITI< AttributeSelection, isScalar >::__insertNodeInFunctionGraph(), gum::StatesChecker::__insertState(), gum::FMDPFactory< GUM_SCALAR >::addArc(), and gum::MultiDimFunctionGraphGenerator::generate().

                                                                        {
    // Ensuring that both nodes exists in the graph
    if (!__functionGraph->__model.exists(node))
      GUM_ERROR(NotFound, "Node : " << node << " doesn't exists in the graph")
    if (!__functionGraph->__model.exists(sonNode))
      GUM_ERROR(NotFound, "Node : " << sonNode << " doesn't exists in the graph")

    // Check if starting node is not terminal
    if (__functionGraph->isTerminalNode(node))
      GUM_ERROR(InvalidNode,
                "You cannot insert an arc from terminal node : " << node)

    // Check if associated modality is lower than node bound variable domain
    // size
    if (__functionGraph->isInternalNode(node)
        && modality
              > __functionGraph->__internalNodeMap[node]->nodeVar()->domainSize()
                   - 1)
      GUM_ERROR(
         InvalidArgument,
         "Modality "
            << modality << "is higher than domain size "
            << __functionGraph->__internalNodeMap[node]->nodeVar()->domainSize()
            << "minus 1 of variable "
            << __functionGraph->__internalNodeMap[node]->nodeVar()->name())

    // Check if variable order is respected
    if (__functionGraph->isInternalNode(sonNode)
        && __functionGraph->variablesSequence().pos(
              __functionGraph->__internalNodeMap[node]->nodeVar())
              >= __functionGraph->variablesSequence().pos(
                 __functionGraph->__internalNodeMap[sonNode]->nodeVar()))
      GUM_ERROR(
         OperationNotAllowed,
         "Variable " << __functionGraph->__internalNodeMap[node]->nodeVar()
                     << " is after variable "
                     << __functionGraph->__internalNodeMap[sonNode]->nodeVar()
                     << "in Function Graph order.")

    __functionGraph->__internalNodeMap[node]->setSon(modality, sonNode);
    if (sonNode && !__functionGraph->isTerminalNode(sonNode))
      __functionGraph->__internalNodeMap[sonNode]->addParent(node, modality);
  }

Here is the caller graph for this function:

Friends And Related Function Documentation

MultiDimFunctionGraph

template<typename GUM_SCALAR, template< typename > class TerminalNodePolicy>

MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >* MultiDimFunctionGraph ( )

friend

This friend methods from is the only way to get an instance of a manager.

---

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

• agrum/multidim/implementations/multiDimFunctionGraph.h
• agrum/multidim/implementations/multiDimFunctionGraphManager.h
• agrum/multidim/implementations/multiDimFunctionGraphManager_tpl.h