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

Class implementingting a function graph manager. More...

#include <multiDimFunctionGraph.h>

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

Public Member Functions
void	clean ()
	Removes var without nodes in the diagram. More...

Constructors / Destructors
MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy > *	MultiDimFunctionGraph ()
	This friend methods from is the only way to get an instance of a manager. More...
	MultiDimFunctionGraphManager (MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *master)
	Default constructor. More...
virtual	~MultiDimFunctionGraphManager ()
	Class destructor. More...

Nodes manipulation methods.
NodeId	addInternalNode_ (const DiscreteVariable *var, NodeId *sons)
	Adds an internal node. More...
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...
virtual NodeId	addInternalNode (const DiscreteVariable *var, NodeId *sons)=0
	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...

Manipulation methods.
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...
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	adjacentSwap__ (const DiscreteVariable *x, const DiscreteVariable *y)
	Swap two adjacent variable. More...

Redundancy methods.
NodeId	nodeRedundancyCheck_ (const DiscreteVariable *var, NodeId *sonsMap)
	Check for redundancy. More...
void	reduce_ ()
	Ensures that every isomorphic subgraphs are merged together. More...
virtual void	reduce ()=0
	Ensures that every isomorphic subgraphs are merged together. More...
NodeId	checkIsomorphism__ (const DiscreteVariable *var, NodeId *sons)
	Checks if a similar node does not already exists in the graph. More...
bool	isRedundant__ (const DiscreteVariable *var, NodeId *sons)
	Checks if node has the same child for every variable value. More...

Detailed Description

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

Class implementingting a function graph manager.

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/tools/multidim/implementations/multiDimFunctionGraphManager.h>

This class provides methods to edit a Function Graph. Any modification on a MultiDimFunctionGraph graph must be done via this class.

This class is a singleton and its unique instance ca be accessed using the MultiDimFunctionGraph::getManager() method.

To do so :

// You can also use getTreeInstance()
auto * func_graph =
   MultiDimFunctionGraph<double>::getReducedAndOrderedInstance();
auto manager = dg->manager();

Template Parameters

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

Definition at line 52 of file multiDimFunctionGraph.h.

Constructor & Destructor Documentation

MultiDimFunctionGraphManager()

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

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

explicitprotected

Default constructor.

You have to call MultiDimFunctionGraph::getManager() to get the instance of MultiDimFunctionGraphManager bound to your function graph.

Definition at line 40 of file multiDimFunctionGraphManager_tpl.h.

                                                                       {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphManager);
    functionGraph__ = mddg;
  }

~MultiDimFunctionGraphManager()

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

INLINE gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::~MultiDimFunctionGraphManager ( )

virtual

Class destructor.

Definition at line 49 of file multiDimFunctionGraphManager_tpl.h.

                                     {
    GUM_DESTRUCTOR(MultiDimFunctionGraphManager);
  }

Member Function Documentation

addInternalNode() [1/3]

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

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode

(

const DiscreteVariable *

var

)

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.

                                                  {
    InternalNode* newNodeStruct = new InternalNode(var);
    NodeId        nid           = functionGraph__->model__.addNode();
    functionGraph__->internalNodeMap__.insert(nid, newNodeStruct);
    functionGraph__->var2NodeIdMap__[var]->addLink(nid);

    return nid;
  }

addInternalNode() [2/3]

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

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

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

Implemented in gum::MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >, and gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >.

addInternalNode() [3/3]

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

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

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_()

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

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

protected

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.

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

addTerminalNode()

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

INLINE NodeId gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addTerminalNode

(

const GUM_SCALAR &

value

)

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.

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

    NodeId node = functionGraph__->model__.addNode();
    functionGraph__->addTerminalNode(node, value);
    return node;
  }

adjacentSwap__()

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

void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::adjacentSwap__ ( const DiscreteVariable *  x, const DiscreteVariable *  y  )

private

Swap two adjacent variable.

Order is important here. X must precede Y before the swap (at the end Y will then precede X). Not respecting this constraint leads to unattended behaviour.

Parameters

x	The first variable to swap.
y	The second variable to swap.

Definition at line 307 of file multiDimFunctionGraphManager_tpl.h.

                                                                          {
    LinkedList< NodeId >* oldxNodes     = functionGraph__->var2NodeIdMap__[x];
    functionGraph__->var2NodeIdMap__[x] = new LinkedList< NodeId >();
    LinkedList< NodeId >* oldyNodes     = functionGraph__->var2NodeIdMap__[y];
    functionGraph__->var2NodeIdMap__[y] = new LinkedList< NodeId >();


    InternalNode* currentOldXNode     = nullptr;
    NodeId*       currentNewXNodeSons = nullptr;
    Idx           indx                = 0;

    NodeId* currentNewYNodeSons = nullptr;
    NodeId  currentNewYNodeId   = 0;
    Idx     indy                = 0;

    while (oldxNodes->list()) {
      // Recuperating a node associated to variables x
      currentOldXNode
         = functionGraph__->internalNodeMap__[oldxNodes->list()->element()];

      // Creating a new node associated to variable y
      currentNewYNodeSons = InternalNode::allocateNodeSons(y);

      // Now the graph needs to be remap by inserting nodes bound to x
      // for each values assumed by y
      for (indy = 0; indy < y->domainSize(); ++indy) {
        // Creating a new node bound to x that will be the son of the node
        // tied to y for the current value assumed by y
        currentNewXNodeSons = InternalNode::allocateNodeSons(x);

        // Iterating on the different values taht x can assumed to do the remap
        for (indx = 0; indx < x->domainSize(); ++indx) {
          currentNewXNodeSons[indx] = currentOldXNode->son(indx);
          if (!functionGraph__->isTerminalNode(currentOldXNode->son(indx))
              && functionGraph__->node(currentOldXNode->son(indx))->nodeVar() == y)
            currentNewXNodeSons[indx]
               = functionGraph__->node(currentOldXNode->son(indx))->son(indy);
        }

        // Inserting the new node bound to x
        currentNewYNodeSons[indy] = nodeRedundancyCheck_(x, currentNewXNodeSons);
      }

      // Replacing old node x by new node y
      currentNewYNodeId = currentNewYNodeSons[0];
      if (isRedundant__(y, currentNewYNodeSons)) {
        migrateNode_(oldxNodes->list()->element(), currentNewYNodeId);
        SOA_DEALLOCATE(currentNewYNodeSons, y->domainSize() * sizeof(NodeId));
      } else {
        currentNewYNodeId = checkIsomorphism__(y, currentNewYNodeSons);
        if (currentNewYNodeId != 0) {
          migrateNode_(oldxNodes->list()->element(), currentNewYNodeId);
          SOA_DEALLOCATE(currentNewYNodeSons, y->domainSize() * sizeof(NodeId));
        } else {
          // Updating the sons (they must not consider old x as their parent)
          for (Idx i = 0; i < currentOldXNode->nodeVar()->domainSize(); ++i) {
            if (functionGraph__->internalNodeMap__.exists(
                   currentOldXNode->son(i))) {
              functionGraph__->internalNodeMap__[currentOldXNode->son(i)]
                 ->removeParent(oldxNodes->list()->element(), i);
            }
          }
          // Reaffecting old node x internal attributes to correct new one
          currentOldXNode->setNode(y, currentNewYNodeSons);
          // Updating new sons (they must consider the node as a parent)
          for (Idx i = 0; i < currentOldXNode->nodeVar()->domainSize(); ++i) {
            if (functionGraph__->internalNodeMap__.exists(
                   currentNewYNodeSons[i])) {
              functionGraph__->internalNodeMap__[currentNewYNodeSons[i]]
                 ->addParent(oldxNodes->list()->element(), i);
            }
          }

          functionGraph__->var2NodeIdMap__[y]->addLink(
             oldxNodes->list()->element());
        }
      }

      oldxNodes->searchAndRemoveLink(oldxNodes->list()->element());
    }
    delete oldxNodes;

    while (oldyNodes->list()) {
      NodeId curId = oldyNodes->list()->element();
      if (functionGraph__->internalNodeMap__[curId]->parents() == nullptr) {
        for (Idx i = 0;
             i
             < functionGraph__->internalNodeMap__[curId]->nodeVar()->domainSize();
             ++i)
          if (functionGraph__->internalNodeMap__.exists(
                 functionGraph__->internalNodeMap__[curId]->son(i)))
            functionGraph__
               ->internalNodeMap__[functionGraph__->internalNodeMap__[curId]->son(
                  i)]
               ->removeParent(curId, i);
        delete functionGraph__->internalNodeMap__[curId];
        functionGraph__->internalNodeMap__.erase(curId);
        functionGraph__->model__.eraseNode(curId);
      } else {
        functionGraph__->var2NodeIdMap__[y]->addLink(curId);
      }
      oldyNodes->searchAndRemoveLink(curId);
    }
    delete oldyNodes;
  }

checkIsomorphism__()

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

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

private

Checks if a similar node does not already exists in the graph.

Tow nodes are similar if for every value assumed by the associated variable, these two nodes have the same children.

Warning

This will not free sons.

Parameters

var	The node to check for.
sons	The node sons.

Returns

Returns the node id if found, 0 otherwhise.

Definition at line 462 of file multiDimFunctionGraphManager_tpl.h.

                                                                   {
    const InternalNode* nody = nullptr;
    Idx                 i    = 0;

    // Check abscence of identical node
    Link< NodeId >* currentElem = functionGraph__->var2NodeIdMap__[var]->list();
    while (currentElem != nullptr) {
      nody = functionGraph__->internalNodeMap__[currentElem->element()];

      // Check on the other sons
      i = 0;
      while (i < var->domainSize() && sons[i] == nody->son(i))
        ++i;
      if (i == var->domainSize()) return currentElem->element();

      currentElem = currentElem->nextLink();
    }
    return 0;
  }

clean()

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

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

(

)

Removes var without nodes in the diagram.

Definition at line 562 of file multiDimFunctionGraphManager_tpl.h.

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

eraseNode()

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

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

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

isRedundant__()

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

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

private

Checks if node has the same child for every variable value.

Warning

WON'T deallocate sons

Parameters

var	The node to check for.
sons	The node sons.

Returns

Returns true if the node is redundant.

Definition at line 485 of file multiDimFunctionGraphManager_tpl.h.

                                      {
    for (Idx m = 1; m < var->domainSize(); m++)
      if (sons[m] != sons[0]) return false;
    return true;
  }

migrateNode_()

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

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

protected

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

minimizeSize()

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

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

(

)

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

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

Changes var position in variable sequence.

Parameters

x	The varaible to change.
desiredPos	The new posiition.

Definition at line 275 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);
      }
  }

nodeRedundancyCheck_()

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

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

protected

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

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

reduce()

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

virtual void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::reduce ( )

pure virtual

Ensures that every isomorphic subgraphs are merged together.

Implemented in gum::MultiDimFunctionGraphROManager< GUM_SCALAR, TerminalNodePolicy >, and gum::MultiDimFunctionGraphTreeManager< GUM_SCALAR, TerminalNodePolicy >.

reduce_()

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

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

protected

Ensures that every isomorphic subgraphs are merged together.

Definition at line 496 of file multiDimFunctionGraphManager_tpl.h.

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

setRootNode()

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

INLINE void gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setRootNode

(

const NodeId &

root

)

Sets root node of decision diagram.

Parameters

root	The node to set as root.

Definition at line 56 of file multiDimFunctionGraphManager_tpl.h.

                            {
    functionGraph__->root__ = root;
  }

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
	)

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 166 of file multiDimFunctionGraphManager_tpl.h.

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

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.

See class description for more info.

Member Data Documentation

functionGraph__

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

MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::functionGraph__

private

The multidimdecisiongraph supposed to be edited.

Definition at line 313 of file multiDimFunctionGraphManager.h.

---

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

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