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

#include <multiDimFunctionGraph.h>

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

Collaboration diagram for gum::MultiDimFunctionGraphROManager< 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
	MultiDimFunctionGraphROManager (MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *master)
	~MultiDimFunctionGraphROManager ()

Detailed Description

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

Definition at line 55 of file multiDimFunctionGraph.h.

Constructor & Destructor Documentation

MultiDimFunctionGraphROManager()

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

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

private

Definition at line 607 of file multiDimFunctionGraphManager_tpl.h.

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

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

Here is the call graph for this function:

~MultiDimFunctionGraphROManager()

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

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

(

)

Definition at line 615 of file multiDimFunctionGraphManager_tpl.h.

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

                                       {
    GUM_DESTRUCTOR(MultiDimFunctionGraphROManager);
  }

Here is the call graph for this function:

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 )

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.

                                                  {
    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< 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::MultiDimFunctionGraphROManager< 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 621 of file multiDimFunctionGraphManager_tpl.h.

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

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

Here is the call graph for this function:

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.

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

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.

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

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

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

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

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

inherited

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  )

inherited

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  )

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 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< class > class TerminalNodePolicy>

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

virtual

Ensures that every isomorphic subgraphs are merged together.

Implements gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >.

Definition at line 626 of file multiDimFunctionGraphManager_tpl.h.

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

                                                                                {
    this->reduce_();
  }

Here is the call 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 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 )

inherited

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  )

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

---

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