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

#include <agrum/base/multidim/patterns/multiDimFunctionGraphOperator.h>

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

Public Member Functions
Idx	nbCall ()
Idx	nbVarRetro ()
Idx	sizeVarRetroDomain ()
Constructors / Destructors
	MultiDimFunctionGraphOperator (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > DG1, const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > DG2)
	Default constructor.
	~MultiDimFunctionGraphOperator ()
	Default destructor.
Main Method
MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	compute ()
	Computes and builds the Function Graph that is the result of the operation.

Private Member Functions
void	_establishVarOrder_ ()
	Computes an order for the final Decision graph that will minimize the number of re exploration.
Idx	_distance_ (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > , const DiscreteVariable , const DiscreteVariable *)
	Heuristic methods to decide which of two retrograde variables should come first.
void	_findRetrogradeVariables_ (const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > dg, HashTable< NodeId, short int > &dgInstNeed)
	Establish for each node in both function graph if it has retrograde variables beneath it.
NodeId	_compute_ (O4DGContext &currentSituation, Idx lastInstVarPos)
	The main recursion function.

Private Attributes
Idx	_nbCall_
Idx	_nbVarRetro_
Idx	_sizeVarRetro_
const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	_DG1_
	One of the two function graphs used for the operation.
const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	_DG2_
	The other one.
MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	_rd_
	The resulting function graph.
Idx	_nbVar_
	The total number of variable implied in the operation.
const FUNCTOR< GUM_SCALAR >	_function_
	The function to be performed on the leaves.
HashTable< double, NodeId >	_explorationTable_
	The hashtable used to know if two pair of nodes have already been visited.
HashTable< NodeId, short int * >	_DG1InstantiationNeeded_
	Table uses to know if a given node of first function graph has retrograde vrariables.
HashTable< NodeId, short int * >	_DG2InstantiationNeeded_
	Table uses to know if a given node of second function graph has retrograde vrariables.
short int *	_default_
	Just a comptuationnal trick.

Detailed Description

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

Class used to perform Function Graph Operations.

Definition at line 73 of file multiDimFunctionGraphOperator.h.

Constructor & Destructor Documentation

◆ MultiDimFunctionGraphOperator()

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

gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::MultiDimFunctionGraphOperator	(	const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	DG1,
		const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	DG2 )

Default constructor.

Definition at line 59 of file multiDimFunctionGraphOperator_tpl.h.

                                                                              :
      _DG1_(DG1), _DG2_(DG2), _function_(), _DG1InstantiationNeeded_(DG1->realSize(), true, false),
      _DG2InstantiationNeeded_(DG2->realSize(), true, false) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphOperator);
    _rd_ = MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance();
    _nbVar_   = 0;
    _default_ = nullptr;
 
    _nbCall_       = 0;
    _nbVar_        = 0;
    _sizeVarRetro_ = 1;
  }

References MultiDimFunctionGraphOperator(), _default_, _DG1_, _DG1InstantiationNeeded_, _DG2_, _DG2InstantiationNeeded_, _function_, _nbCall_, _nbVar_, _rd_, _sizeVarRetro_, and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance().

Referenced by MultiDimFunctionGraphOperator(), and ~MultiDimFunctionGraphOperator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~MultiDimFunctionGraphOperator()

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

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

Default destructor.

Definition at line 78 of file multiDimFunctionGraphOperator_tpl.h.

                                       {
    GUM_DESTRUCTOR(MultiDimFunctionGraphOperator);
 
 
    for (auto instIter = _DG1InstantiationNeeded_.beginSafe();
         instIter != _DG1InstantiationNeeded_.endSafe();
         ++instIter)
      SOA_DEALLOCATE(instIter.val(), sizeof(short int) * _nbVar_);
 
    for (auto instIter = _DG2InstantiationNeeded_.beginSafe();
         instIter != _DG2InstantiationNeeded_.endSafe();
         ++instIter)
      SOA_DEALLOCATE(instIter.val(), sizeof(short int) * _nbVar_);
 
    if (_nbVar_ != 0) SOA_DEALLOCATE(_default_, sizeof(short int) * _nbVar_);
  }

References MultiDimFunctionGraphOperator(), _default_, _DG1InstantiationNeeded_, _DG2InstantiationNeeded_, _nbVar_, and SOA_DEALLOCATE.

Here is the call graph for this function:

Member Function Documentation

◆ _compute_()

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

NodeId gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_compute_	(	O4DGContext &	currentSituation,
		Idx	lastInstVarPos )

private

The main recursion function.

Main recursion function, called every time we move on a node to determine what we have to do.

Definition at line 332 of file multiDimFunctionGraphOperator_tpl.h.

                                   {
    _nbCall_ += 1;
 
    NodeId newNode = 0;
 
 
    // If both current nodes are terminal,
    // we only have to compute the resulting value
    if (_DG1_->isTerminalNode(currentSituation.DG1Node())
        && _DG2_->isTerminalNode(currentSituation.DG2Node())) {
      // We have to compute new valueand we insert a new node in diagram with
      // this value, ...
      return _rd_->manager()->addTerminalNode(
          _function_(_DG1_->terminalNodeValue(currentSituation.DG1Node()),
                     _DG2_->terminalNodeValue(currentSituation.DG2Node())));
    }
 
    // If not,
    // we'll have to do some exploration
 
    // First we ensure that we hadn't already visit this pair of node under hte
    // same circumstances
 
    short int* dg1NeededVar = _DG1InstantiationNeeded_.exists(currentSituation.DG1Node())
                                ? _DG1InstantiationNeeded_[currentSituation.DG1Node()]
                                : _default_;
    Idx        dg1CurrentVarPos
        = _DG1_->isTerminalNode(currentSituation.DG1Node())
            ? _nbVar_
            : _rd_->variablesSequence().pos(_DG1_->node(currentSituation.DG1Node())->nodeVar());
    short int* dg2NeededVar = _DG2InstantiationNeeded_.exists(currentSituation.DG2Node())
                                ? _DG2InstantiationNeeded_[currentSituation.DG2Node()]
                                : _default_;
    Idx        dg2CurrentVarPos
        = _DG2_->isTerminalNode(currentSituation.DG2Node())
            ? _nbVar_
            : _rd_->variablesSequence().pos(_DG2_->node(currentSituation.DG2Node())->nodeVar());
 
    short int* instNeeded = static_cast< short int* >(SOA_ALLOCATE(sizeof(short int) * _nbVar_));
    for (Idx i = 0; i < _nbVar_; i++)
      instNeeded[i] = dg1NeededVar[i] + dg2NeededVar[i];
 
    double curSitKey = currentSituation.key(instNeeded);
 
    if (_explorationTable_.exists(curSitKey)) {
      SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
      return _explorationTable_[curSitKey];
    }
 
    // ====================================================
 
    NodeId origDG1 = currentSituation.DG1Node(), origDG2 = currentSituation.DG2Node();
 
    const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >* leaddg     = nullptr;
    NodeId                                                         leadNodeId = 0;
    Idx leadVarPos        = _rd_->variablesSequence().size();
    using SetNodeFunction = void (O4DGContext::*)(const NodeId&);
 
    SetNodeFunction leadFunction = nullptr;
 
    bool sameVar = false;
 
    if (!_DG1_->isTerminalNode(currentSituation.DG1Node())) {
      if (currentSituation.varModality(dg1CurrentVarPos) != 0) {
        currentSituation.setDG1Node(_DG1_->node(currentSituation.DG1Node())
                                        ->son(currentSituation.varModality(dg1CurrentVarPos) - 1));
 
        newNode = _compute_(currentSituation, lastInstVarPos);
        _explorationTable_.insert(curSitKey, newNode);
        currentSituation.setDG1Node(origDG1);
        currentSituation.setDG2Node(origDG2);
 
        SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
 
        return newNode;
      }
 
      leaddg       = _DG1_;
      leadNodeId   = currentSituation.DG1Node();
      leadVarPos   = dg1CurrentVarPos;
      leadFunction = &O4DGContext::setDG1Node;
    }
 
    if (!_DG2_->isTerminalNode(currentSituation.DG2Node())) {
      if (currentSituation.varModality(dg2CurrentVarPos) != 0) {
        currentSituation.setDG2Node(_DG2_->node(currentSituation.DG2Node())
                                        ->son(currentSituation.varModality(dg2CurrentVarPos) - 1));
 
        newNode = _compute_(currentSituation, lastInstVarPos);
        _explorationTable_.insert(curSitKey, newNode);
        currentSituation.setDG1Node(origDG1);
        currentSituation.setDG2Node(origDG2);
 
        SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
 
        return newNode;
      }
 
      if (leadVarPos == dg2CurrentVarPos) { sameVar = true; }
 
      if (leadVarPos > dg2CurrentVarPos) {
        leaddg       = _DG2_;
        leadNodeId   = currentSituation.DG2Node();
        leadVarPos   = dg2CurrentVarPos;
        leadFunction = &O4DGContext::setDG2Node;
      }
    }
 
    // ====================================================
 
    // Before exploring nodes, we have to ensure that every anticipated
    // exploration is done
    for (Idx varPos = lastInstVarPos + 1; varPos < leadVarPos; ++varPos) {
      if (instNeeded[varPos]) {
        const DiscreteVariable* curVar = _rd_->variablesSequence().atPos(varPos);
        NodeId*                 sonsIds
            = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * curVar->domainSize()));
 
        for (Idx modality = 0; modality < curVar->domainSize(); modality++) {
          currentSituation.chgVarModality(varPos, modality + 1);
 
          sonsIds[modality] = _compute_(currentSituation, varPos);
        }
 
        newNode = _rd_->manager()->addInternalNode(curVar, sonsIds);
 
        _explorationTable_.insert(curSitKey, newNode);
        currentSituation.chgVarModality(varPos, 0);
        currentSituation.setDG1Node(origDG1);
        currentSituation.setDG2Node(origDG2);
 
        SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
 
        return newNode;
      }
    }
 
    // ====================================================
 
    // If only one of the current node is terminal,
    // we have to pursue deeper on the other diagram
    if (sameVar) {
      // If so - meaning it's the same variable - we have to go
      // down on both
      const InternalNode* dg1Node = _DG1_->node(origDG1);
      const InternalNode* dg2Node = _DG2_->node(origDG2);
 
      const DiscreteVariable* curVar = dg1Node->nodeVar();
      Idx                     varPos = _rd_->variablesSequence().pos(curVar);
 
      NodeId* sonsIds = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * curVar->domainSize()));
 
      for (Idx modality = 0; modality < curVar->domainSize(); modality++) {
        currentSituation.chgVarModality(varPos, modality + 1);
        currentSituation.setDG1Node(dg1Node->son(modality));
        currentSituation.setDG2Node(dg2Node->son(modality));
 
        sonsIds[modality] = _compute_(currentSituation, varPos);
      }
 
      newNode = _rd_->manager()->addInternalNode(curVar, sonsIds);
 
      _explorationTable_.insert(curSitKey, newNode);
      currentSituation.chgVarModality(varPos, 0);
      currentSituation.setDG1Node(origDG1);
      currentSituation.setDG2Node(origDG2);
 
      SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
 
      return newNode;
    }
    // ====================================================
    else {
      const InternalNode* leaddgNode = leaddg->node(leadNodeId);
 
      const DiscreteVariable* curVar = leaddgNode->nodeVar();
      NodeId* sonsIds = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * curVar->domainSize()));
 
      for (Idx modality = 0; modality < curVar->domainSize(); modality++) {
        currentSituation.chgVarModality(leadVarPos, modality + 1);
        (currentSituation.*leadFunction)(leaddgNode->son(modality));
 
        sonsIds[modality] = _compute_(currentSituation, leadVarPos);
      }
 
      newNode = _rd_->manager()->addInternalNode(curVar, sonsIds);
 
      _explorationTable_.insert(curSitKey, newNode);
      currentSituation.chgVarModality(leadVarPos, 0);
      currentSituation.setDG1Node(origDG1);
      currentSituation.setDG2Node(origDG2);
 
      SOA_DEALLOCATE(instNeeded, sizeof(short int) * _nbVar_);
 
      return newNode;
    }
  }

References _compute_(), _default_, _DG1_, _DG1InstantiationNeeded_, _DG2_, _DG2InstantiationNeeded_, _explorationTable_, _function_, _nbCall_, _nbVar_, _rd_, gum::O4DGContext::chgVarModality(), gum::O4DGContext::DG1Node(), gum::O4DGContext::DG2Node(), gum::DiscreteVariable::domainSize(), gum::O4DGContext::key(), gum::InternalNode::nodeVar(), gum::O4DGContext::setDG1Node(), gum::O4DGContext::setDG2Node(), SOA_ALLOCATE, SOA_DEALLOCATE, gum::InternalNode::son(), and gum::O4DGContext::varModality().

Referenced by _compute_(), and compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _distance_()

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

INLINE Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_distance_	(	const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	d,
		const DiscreteVariable *	from,
		const DiscreteVariable *	to )

private

Heuristic methods to decide which of two retrograde variables should come first.

Definition at line 223 of file multiDimFunctionGraphOperator_tpl.h.

                                                                         {
    Idx posi = d->variablesSequence().pos(from);
    Idx dist = 1;
 
    while (d->variablesSequence().atPos(posi) != to) {
      dist *= (*(d->variablesSequence().atPos(posi))).domainSize();
      posi++;
    }
 
    return dist;
  }

References gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Referenced by _establishVarOrder_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _establishVarOrder_()

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

void gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_establishVarOrder_ ( )

private

Computes an order for the final Decision graph that will minimize the number of re exploration.

Definition at line 131 of file multiDimFunctionGraphOperator_tpl.h.

                            {
    SequenceIteratorSafe< const DiscreteVariable* > fite = _DG1_->variablesSequence().beginSafe();
    SequenceIteratorSafe< const DiscreteVariable* > site = _DG2_->variablesSequence().beginSafe();
 
    while (fite != _DG1_->variablesSequence().endSafe()
           && site != _DG2_->variablesSequence().endSafe()) {
      // Test : if var from first order is already in final order
      // we move onto the next one
      if (_rd_->variablesSequence().exists(*fite)) {
        ++fite;
        continue;
      }
 
      // Test : if var from second order is already in final order
      // we move onto the next one
      if (_rd_->variablesSequence().exists(*site)) {
        ++site;
        continue;
      }
 
      // Test : is current var of the first order present in the second order.
      // if not we add it to final order
      if (!_DG2_->variablesSequence().exists(*fite)) {
        _rd_->add(**fite);
        ++fite;
        continue;
      }
 
      // Test : is current var of the second order present in the first order.
      // if not we add it to final order
      if (!_DG1_->variablesSequence().exists(*site)) {
        _rd_->add(**site);
        ++site;
        continue;
      }
 
      // Test : is current var of the second order present in the first order.
      // if not we add it to final order
      if (*fite == *site) {
        _rd_->add(**fite);
        ++fite;
        ++site;
        continue;
      }
 
      // Test : the current tested situation is when two retrograde variables
      // are detected.
      // Chosen solution here is to find compute domainSize in between
      // and chose the one with the smallest
      _nbVarRetro_++;
      if (_distance_(_DG1_, *fite, *site) < _distance_(_DG2_, *site, *fite)) {
        _rd_->add(**fite);
        _sizeVarRetro_ *= (*fite)->domainSize();
        ++fite;
        continue;
      } else {
        _rd_->add(**site);
        _sizeVarRetro_ *= (*site)->domainSize();
        ++site;
        continue;
      }
    }
 
    // Whenever an iterator has finished its sequence,
    // the other may still be in the middle of its one.
    // Hence, this part ensures that any variables remaining
    // will be added to the final sequence if needed.
    if (fite == _DG1_->variablesSequence().endSafe()) {
      for (; site != _DG2_->variablesSequence().endSafe(); ++site)
        if (!_rd_->variablesSequence().exists(*site)) _rd_->add(**site);
    } else {
      for (; fite != _DG1_->variablesSequence().endSafe(); ++fite)
        if (!_rd_->variablesSequence().exists(*fite)) _rd_->add(**fite);
    }
 
 
    // Various initialization needed now that we have a bigger picture
    _nbVar_ = _rd_->variablesSequence().size();
 
    if (_nbVar_ != 0) {
      _default_ = static_cast< short int* >(SOA_ALLOCATE(sizeof(short int) * _nbVar_));
      for (Idx i = 0; i < _nbVar_; i++)
        _default_[i] = (short int)0;
    }
  }

References _default_, _DG1_, _DG2_, _distance_(), _nbVar_, _nbVarRetro_, _rd_, _sizeVarRetro_, and SOA_ALLOCATE.

Referenced by compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _findRetrogradeVariables_()

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

INLINE void gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_findRetrogradeVariables_	(	const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > *	dg,
		HashTable< NodeId, short int * > &	dgInstNeed )

private

Establish for each node in both function graph if it has retrograde variables beneath it.

Definition at line 243 of file multiDimFunctionGraphOperator_tpl.h.

                                                                             {
    HashTable< NodeId, short int* > nodesVarDescendant;
    Size                            tableSize = Size(_nbVar_ * sizeof(short int));
 
    for (auto varIter = dg->variablesSequence().rbeginSafe();
         varIter != dg->variablesSequence().rendSafe();
         --varIter) {
      Idx                   varPos   = _rd_->variablesSequence().pos(*varIter);
      const Link< NodeId >* nodeIter = dg->varNodeListe(*varIter)->list();
      while (nodeIter != nullptr) {
        short int* instantiationNeeded = static_cast< short int* >(SOA_ALLOCATE(tableSize));
        dgInstNeed.insert(nodeIter->element(), instantiationNeeded);
 
        short int* varDescendant = static_cast< short int* >(SOA_ALLOCATE(tableSize));
        nodesVarDescendant.insert(nodeIter->element(), varDescendant);
        for (Idx j = 0; j < _nbVar_; j++) {
          instantiationNeeded[j] = (short int)0;
          varDescendant[j]       = (short int)0;
        }
 
        varDescendant[varPos] = (short int)1;
        for (Idx modality = 0; modality < dg->node(nodeIter->element())->nbSons(); ++modality) {
          if (!dg->isTerminalNode(dg->node(nodeIter->element())->son(modality))) {
            short int* sonVarDescendant
                = nodesVarDescendant[dg->node(nodeIter->element())->son(modality)];
            for (Idx varIdx = 0; varIdx < _nbVar_; varIdx++) {
              varDescendant[varIdx] += sonVarDescendant[varIdx];
              if (varDescendant[varIdx] && varIdx < varPos)
                instantiationNeeded[varIdx] = (short int)1;
            }
          }
        }
        nodeIter = nodeIter->nextLink();
      }
    }
 
    for (auto varIter = dg->variablesSequence().beginSafe();
         varIter != dg->variablesSequence().endSafe();
         ++varIter) {
      const Link< NodeId >* nodeIter = dg->varNodeListe(*varIter)->list();
      while (nodeIter != nullptr) {
        for (Idx modality = 0; modality < dg->node(nodeIter->element())->nbSons(); ++modality) {
          NodeId sonId = dg->node(nodeIter->element())->son(modality);
          if (!dg->isTerminalNode(sonId)) {
            for (Idx varIdx = 0; varIdx < _nbVar_; ++varIdx) {
              if (dgInstNeed[nodeIter->element()][varIdx] && nodesVarDescendant[sonId][varIdx]) {
                dgInstNeed[sonId][varIdx] = (short int)1;
              }
            }
          }
        }
        nodeIter = nodeIter->nextLink();
      }
    }
 
    for (HashTableIterator< NodeId, short int* > it = nodesVarDescendant.begin();
         it != nodesVarDescendant.end();
         ++it) {
      SOA_DEALLOCATE(it.val(), tableSize);
    }
    nodesVarDescendant.clear();
  }

References _nbVar_, _rd_, gum::HashTable< Key, Val >::begin(), gum::HashTable< Key, Val >::clear(), gum::Link< T >::element(), gum::HashTable< Key, Val >::end(), gum::HashTable< Key, Val >::insert(), gum::Link< T >::nextLink(), SOA_ALLOCATE, SOA_DEALLOCATE, and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Referenced by compute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute()

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

MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy > * gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::compute ( )

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

Definition at line 102 of file multiDimFunctionGraphOperator_tpl.h.

                                                                                        {
    _establishVarOrder_();
    _findRetrogradeVariables_(_DG1_, _DG1InstantiationNeeded_);
    _findRetrogradeVariables_(_DG2_, _DG2InstantiationNeeded_);
 
    Idx* varInst = nullptr;
    if (_nbVar_ != 0) {
      varInst = static_cast< Idx* >(SOA_ALLOCATE(sizeof(Idx) * _nbVar_));
      for (Idx i = 0; i < _nbVar_; i++)
        varInst[i] = (Idx)0;
    }
 
    O4DGContext conti(varInst, _nbVar_);
    conti.setDG1Node(_DG1_->root());
    conti.setDG2Node(_DG2_->root());
 
    NodeId root = _compute_(conti, (Idx)0 - 1);
    _rd_->manager()->setRootNode(root);
 
    if (_nbVar_ != 0) SOA_DEALLOCATE(varInst, sizeof(Idx) * _nbVar_);
 
    return _rd_;
  }

References _compute_(), _DG1_, _DG1InstantiationNeeded_, _DG2_, _DG2InstantiationNeeded_, _establishVarOrder_(), _findRetrogradeVariables_(), _nbVar_, _rd_, gum::O4DGContext::setDG1Node(), gum::O4DGContext::setDG2Node(), SOA_ALLOCATE, and SOA_DEALLOCATE.

Referenced by gum::MDDOperatorStrategy< GUM_SCALAR >::argmaximize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nbCall()

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

INLINE Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::nbCall ( )

Definition at line 535 of file multiDimFunctionGraphOperator_tpl.h.

                                                                                              {
    return _nbCall_;
  }

References _nbCall_.

◆ nbVarRetro()

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

INLINE Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::nbVarRetro ( )

Definition at line 543 of file multiDimFunctionGraphOperator_tpl.h.

                                                                                           {
    return _nbVarRetro_;
  }

References _nbVarRetro_.

◆ sizeVarRetroDomain()

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

INLINE Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::sizeVarRetroDomain ( )

Definition at line 550 of file multiDimFunctionGraphOperator_tpl.h.

                           {
    return _sizeVarRetro_;
  }

References _sizeVarRetro_.

Member Data Documentation

◆ _default_

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

short int* gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_default_

private

Just a comptuationnal trick.

Definition at line 162 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), ~MultiDimFunctionGraphOperator(), _compute_(), and _establishVarOrder_().

◆ _DG1_

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

const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_DG1_

private

One of the two function graphs used for the operation.

Definition at line 135 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), _compute_(), _establishVarOrder_(), and compute().

◆ _DG1InstantiationNeeded_

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

HashTable< NodeId, short int* > gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_DG1InstantiationNeeded_

private

Table uses to know if a given node of first function graph has retrograde vrariables.

Definition at line 155 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), ~MultiDimFunctionGraphOperator(), _compute_(), and compute().

◆ _DG2_

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

const MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_DG2_

private

The other one.

Definition at line 138 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), _compute_(), _establishVarOrder_(), and compute().

◆ _DG2InstantiationNeeded_

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

HashTable< NodeId, short int* > gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_DG2InstantiationNeeded_

private

Table uses to know if a given node of second function graph has retrograde vrariables.

Definition at line 159 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), ~MultiDimFunctionGraphOperator(), _compute_(), and compute().

◆ _explorationTable_

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

HashTable< double, NodeId > gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_explorationTable_

private

The hashtable used to know if two pair of nodes have already been visited.

Definition at line 151 of file multiDimFunctionGraphOperator.h.

Referenced by _compute_().

◆ _function_

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

const FUNCTOR< GUM_SCALAR > gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_function_

private

The function to be performed on the leaves.

Definition at line 147 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), and _compute_().

◆ _nbCall_

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

Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_nbCall_

private

Definition at line 111 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), _compute_(), and nbCall().

◆ _nbVar_

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

Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_nbVar_

private

The total number of variable implied in the operation.

Definition at line 144 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), ~MultiDimFunctionGraphOperator(), _compute_(), _establishVarOrder_(), _findRetrogradeVariables_(), and compute().

◆ _nbVarRetro_

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

Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_nbVarRetro_

private

Definition at line 112 of file multiDimFunctionGraphOperator.h.

Referenced by _establishVarOrder_(), and nbVarRetro().

◆ _rd_

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

MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >* gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_rd_

private

The resulting function graph.

Definition at line 141 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), _compute_(), _establishVarOrder_(), _findRetrogradeVariables_(), and compute().

◆ _sizeVarRetro_

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

Idx gum::MultiDimFunctionGraphOperator< GUM_SCALAR, FUNCTOR, TerminalNodePolicy >::_sizeVarRetro_

private

Definition at line 113 of file multiDimFunctionGraphOperator.h.

Referenced by MultiDimFunctionGraphOperator(), _establishVarOrder_(), and sizeVarRetroDomain().

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

agrum/base/multidim/utils/FunctionGraphUtilities/operators/multiDimFunctionGraphOperator.h
agrum/base/multidim/utils/FunctionGraphUtilities/operators/multiDimFunctionGraphOperator_tpl.h

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MultiDimFunctionGraphOperator()

◆ ~MultiDimFunctionGraphOperator()

Member Function Documentation

◆ _compute_()

◆ _distance_()

◆ _establishVarOrder_()

◆ _findRetrogradeVariables_()

◆ compute()

◆ nbCall()

◆ nbVarRetro()

◆ sizeVarRetroDomain()

Member Data Documentation

◆ _default_

◆ _DG1_

◆ _DG1InstantiationNeeded_

◆ _DG2_

◆ _DG2InstantiationNeeded_

◆ _explorationTable_

◆ _function_

◆ _nbCall_

◆ _nbVar_

◆ _nbVarRetro_

◆ _rd_

◆ _sizeVarRetro_