Class used to perform Function Graph projections. More...

#include <agrum/tools/multidim/patterns/multiDimFunctionGraphProjector.h>

Collaboration diagram for gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >:

Public Member Functions
Constructors / Destructors
	MultiDimFunctionGraphProjector (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > src, const Set< const DiscreteVariable > &delVars, const GUM_SCALAR neutral)
	Default constructor. More...

	~MultiDimFunctionGraphProjector ()
	Default destructor. More...

Main Method
MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	project ()
	Computes and builds the Function Graph that is the result of the Projection. More...

Detailed Description

template<typename GUM_SCALAR, template< typename > class FUNCTOR, template< typename > class TerminalNodePolicy = ExactTerminalNodePolicy>
class gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >

Class used to perform Function Graph projections.

Definition at line 55 of file multiDimFunctionGraphProjector.h.

Constructor & Destructor Documentation

◆ MultiDimFunctionGraphProjector()

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

gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::MultiDimFunctionGraphProjector	(	const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	src,
		const Set< const DiscreteVariable * > &	delVars,
		const GUM_SCALAR	neutral
	)

Default constructor.

Definition at line 44 of file multiDimFunctionGraphProjector_tpl.h.

                                                                                 :
       src__(src),
       delVars__(delVars), function__(), neutral__(neutral) {
     GUM_CONSTRUCTOR(MultiDimFunctionGraphProjector);
     rd__ = MultiDimFunctionGraph< GUM_SCALAR >::getReducedAndOrderedInstance();
   }

◆ ~MultiDimFunctionGraphProjector()

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

gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::~MultiDimFunctionGraphProjector ( )

Default destructor.

Definition at line 62 of file multiDimFunctionGraphProjector_tpl.h.

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

                                        {
     GUM_DESTRUCTOR(MultiDimFunctionGraphProjector);
   }

Here is the call graph for this function:

Member Function Documentation

◆ project()

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

MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraphProjector< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::project ( )

Computes and builds the Function Graph that is the result of the Projection.

Definition at line 76 of file multiDimFunctionGraphProjector_tpl.h.

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

                   {
     rd__->copy(*src__);
 
     for (SetIteratorSafe< const DiscreteVariable* > varIter
          = delVars__.beginSafe();
          varIter != delVars__.endSafe();
          ++varIter) {
       const DiscreteVariable* curVar = *varIter;
 
       // Tout d'abord, on déplace la variable à projeter en fin de séquence afin
       // de simplifier la projection
       if (rd__->variablesSequence().exists(curVar))
         rd__->manager()->moveTo(curVar, rd__->variablesSequence().size() - 1);
 
       // 1er cas spécial : le diagramme est un un simple noeud terminal
       if (rd__->isTerminalNode(rd__->root())) {
         GUM_SCALAR newVal = neutral__, oldVal = rd__->nodeValue(rd__->root());
         for (Idx curVarModality = 0; curVarModality < curVar->domainSize();
              ++curVarModality)
           newVal = function__(newVal, oldVal);
 
         NodeId newSonId = rd__->manager()->addTerminalNode(newVal);
         rd__->manager()->setRootNode(newSonId);
 
         if (rd__->variablesSequence().exists(curVar)) rd__->erase(*curVar);
         continue;
       }
 
       // 2ème cas spécial : la racine du diagramme est associée à la variable
       // projetée
       if (rd__->node(rd__->root())->nodeVar() == curVar) {
         const InternalNode* curVarNode = rd__->node(rd__->root());
         GUM_SCALAR          newVal     = neutral__;
         for (Idx curVarModality = 0; curVarModality < curVar->domainSize();
              ++curVarModality)
           newVal = function__(newVal,
                               rd__->nodeValue(curVarNode->son(curVarModality)));
 
         NodeId newSonId = rd__->manager()->addTerminalNode(newVal);
 
         rd__->manager()->eraseNode(rd__->root(), newSonId, false);
 
         if (rd__->variablesSequence().exists(curVar)) rd__->erase(*curVar);
         continue;
       }
 
       // Cas général
       HashTable< NodeId, NodeId > visitedNode(2 * rd__->realSize(), true, false);
       std::vector< NodeId >       filo;
       filo.push_back(rd__->root());
 
       while (!filo.empty()) {
         NodeId curNodeId = filo.back();
         filo.pop_back();
 
         const InternalNode* curNode = rd__->node(curNodeId);
 
         for (Idx modality = 0; modality < curNode->nodeVar()->domainSize();
              ++modality) {
           NodeId oldSonId = curNode->son(modality);
 
           if (!visitedNode.exists(oldSonId)) {
             NodeId newSonId = oldSonId;
 
             if (!rd__->isTerminalNode(oldSonId)) {
               if (rd__->node(oldSonId)->nodeVar() != curVar) {
                 filo.push_back(oldSonId);
               } else {
                 const InternalNode* curVarNode = rd__->node(oldSonId);
                 GUM_SCALAR          newVal     = neutral__;
                 for (Idx curVarModality = 0; curVarModality < curVar->domainSize();
                      ++curVarModality)
                   newVal = function__(
                      newVal,
                      rd__->nodeValue(curVarNode->son(curVarModality)));
 
                 newSonId = rd__->manager()->addTerminalNode(newVal);
 
                 rd__->manager()->eraseNode(oldSonId, newSonId, false);
                 rd__->manager()->setSon(curNodeId, modality, newSonId);
               }
 
             } else {
               GUM_SCALAR newVal = neutral__, oldVal = rd__->nodeValue(oldSonId);
               for (Idx curVarModality = 0; curVarModality < curVar->domainSize();
                    ++curVarModality)
                 newVal = function__(newVal, oldVal);
 
               newSonId = rd__->manager()->addTerminalNode(newVal);
               rd__->manager()->setSon(curNodeId, modality, newSonId);
             }
 
             visitedNode.insert(oldSonId, newSonId);
 
           } else {
             if (rd__->node(curNodeId)->son(modality) != visitedNode[oldSonId])
               rd__->manager()->setSon(curNodeId, modality, visitedNode[oldSonId]);
           }
         }
       }
 
       if (rd__->variablesSequence().exists(curVar)) rd__->erase(*curVar);
     }
 
     return rd__;
   }

Here is the call graph for this function: