gum::MultiDimFunctionGraphGenerator Class Reference

Class implementing a function graph generator with template type double. More...

#include <multiDimFunctionGraphGenerator.h>

Collaboration diagram for gum::MultiDimFunctionGraphGenerator:

Public Member Functions
MultiDimFunctionGraph< double > *	generate ()
	Generates a MultiDimFunctionGraph.
Constructors / Destructors
	MultiDimFunctionGraphGenerator (Idx maxVar, Idx minVar, const Sequence< const DiscreteVariable * > &varSeq)
	Default constructor.
	~MultiDimFunctionGraphGenerator ()
	Class destructor.

Private Member Functions
bool	_createLeaf_ (NodeId currentNodeId, HashTable< NodeId, Idx > &node2MinVar)
	Creates a leaf.
Idx	_generateVarPos_ (Idx offset, Idx span)
	Generate a variable position.

Private Attributes
const Sequence< const DiscreteVariable * >	_varSeq_
	The variables.
Idx	_nbTotalVar_
	The total number of variables.

Static Private Attributes
static Idx	_genSeed_
	The seed for random numbers.

Detailed Description

Class implementing a function graph generator with template type double.

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/base/multidim/implementations/multiDimFunctionGraphGenerator.h>

Definition at line 75 of file multiDimFunctionGraphGenerator.h.

Constructor & Destructor Documentation

MultiDimFunctionGraphGenerator()

gum::MultiDimFunctionGraphGenerator::MultiDimFunctionGraphGenerator	(	Idx	maxVar,
		Idx	minVar,
		const Sequence< const DiscreteVariable * > &	varSeq )

Default constructor.

Definition at line 61 of file multiDimFunctionGraphGenerator.cpp.

                                                         : _varSeq_(varSeq) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphGenerator);
 
    _nbTotalVar_ = _varSeq_.size();
  }

References MultiDimFunctionGraphGenerator(), _nbTotalVar_, and _varSeq_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

~MultiDimFunctionGraphGenerator()

gum::MultiDimFunctionGraphGenerator::~MultiDimFunctionGraphGenerator

(

)

Class destructor.

Definition at line 71 of file multiDimFunctionGraphGenerator.cpp.

                                                                  {
    GUM_DESTRUCTOR(MultiDimFunctionGraphGenerator);
  }

References MultiDimFunctionGraphGenerator().

Here is the call graph for this function:

Member Function Documentation

_createLeaf_()

bool gum::MultiDimFunctionGraphGenerator::_createLeaf_ ( NodeId currentNodeId, HashTable< NodeId, Idx > & node2MinVar )

private

Creates a leaf.

Definition at line 152 of file multiDimFunctionGraphGenerator.cpp.

                                                                                           {
    return !(currentNodeId == 1
             || (randomProba() < 0.9
                                     + 0.01
                                           * (float(_nbTotalVar_ - node2MinVar[currentNodeId])
                                              / float(_nbTotalVar_))
                 && node2MinVar[currentNodeId] < _nbTotalVar_ - 1));
  }

References _nbTotalVar_, and gum::randomProba().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

_generateVarPos_()

Idx gum::MultiDimFunctionGraphGenerator::_generateVarPos_ ( Idx offset, Idx span )

private

Generate a variable position.

Definition at line 162 of file multiDimFunctionGraphGenerator.cpp.

                                                                           {
    Idx randOut = 0;
 
    if (span != 0) {
      std::weibull_distribution< double > distribution(double(span), 1.0);
      randOut = (Idx)(distribution(gum::randomGenerator()) * span / 2);
      if (randOut > span) randOut = span;
    }
 
    return offset + randOut;
  }

References gum::randomGenerator().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

generate()

MultiDimFunctionGraph< double > * gum::MultiDimFunctionGraphGenerator::generate

(

)

Generates a MultiDimFunctionGraph.

Definition at line 75 of file multiDimFunctionGraphGenerator.cpp.

                                                                            {
    MultiDimFunctionGraph< double >* generatedFunctionGraph
        = MultiDimFunctionGraph< double >::getReducedAndOrderedInstance();
 
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter = _varSeq_.beginSafe();
         varIter != _varSeq_.endSafe();
         ++varIter) {
      generatedFunctionGraph->add(**varIter);
    }
 
    HashTable< NodeId, Idx > node2MinVar;
 
    std::vector< NodeId > filo;
 
    generatedFunctionGraph->manager()->setRootNode(
        generatedFunctionGraph->manager()->addInternalNode(_varSeq_.atPos(0)));
    node2MinVar.insert(generatedFunctionGraph->root(), 0);
    filo.push_back(generatedFunctionGraph->root());
 
    while (!filo.empty()) {
      NodeId currentNodeId = filo.back();
      filo.pop_back();
      Idx                 cvp         = node2MinVar[currentNodeId];
      const InternalNode* currentNode = generatedFunctionGraph->node(currentNodeId);
 
      LinkedList< NodeId > tensorSons;
      Idx                  nbTensorSons = 0;
      for (Idx varPos = 0; varPos < generatedFunctionGraph->variablesSequence().size(); varPos++) {
        const DiscreteVariable* var = generatedFunctionGraph->variablesSequence().atPos(varPos);
 
        Idx vsp = _varSeq_.pos(var);
        if (vsp > cvp) {
          const Link< NodeId >* nicleIter = generatedFunctionGraph->varNodeListe(var)->list();
          while (nicleIter) {
            nbTensorSons++;
            tensorSons.addLink(nicleIter->element());
            nicleIter = nicleIter->nextLink();
          }
        }
      }
 
      for (Idx modality = 0; modality < currentNode->nodeVar()->domainSize(); modality++) {
        if (!tensorSons.list() || randomProba() > (1.0 / (1.0 + 3.0 / nbTensorSons))) {
          if (_createLeaf_(currentNodeId, node2MinVar)) {
            generatedFunctionGraph->manager()->setSon(
                currentNodeId,
                modality,
                generatedFunctionGraph->manager()->addTerminalNode(100.0 * randomProba()));
          } else {
            Idx sonVarPos = _generateVarPos_(node2MinVar[currentNodeId] + 1,
                                             _nbTotalVar_ - node2MinVar[currentNodeId] - 2);
            generatedFunctionGraph->manager()->setSon(
                currentNodeId,
                modality,
                generatedFunctionGraph->manager()->addInternalNode(_varSeq_.atPos(sonVarPos)));
            filo.push_back(currentNode->son(modality));
            node2MinVar.insert(currentNode->son(modality), sonVarPos);
          }
        } else {
          Idx sonPos                = randomValue(nbTensorSons);
          sonPos                    = sonPos == nbTensorSons ? nbTensorSons - 1 : sonPos;
          Link< NodeId >* nicleIter = tensorSons.list();
          while (sonPos) {
            nicleIter = nicleIter->nextLink();
            sonPos--;
          }
          generatedFunctionGraph->manager()->setSon(currentNodeId, modality, nicleIter->element());
        }
      }
    }
 
    generatedFunctionGraph->manager()->reduce();
    generatedFunctionGraph->manager()->clean();
 
    return generatedFunctionGraph;
  }

References _createLeaf_(), _generateVarPos_(), _nbTotalVar_, _varSeq_, gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::add(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addInternalNode(), gum::LinkedList< T >::addLink(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::addTerminalNode(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::clean(), gum::Link< T >::element(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance(), gum::HashTable< Key, Val >::insert(), gum::LinkedList< T >::list(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::manager(), gum::Link< T >::nextLink(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::node(), gum::InternalNode::nodeVar(), gum::randomProba(), gum::randomValue(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::reduce(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::root(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setRootNode(), gum::MultiDimFunctionGraphManager< GUM_SCALAR, TerminalNodePolicy >::setSon(), gum::InternalNode::son(), gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence(), and gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::varNodeListe().

Here is the call graph for this function:

Member Data Documentation

_genSeed_

Idx gum::MultiDimFunctionGraphGenerator::_genSeed_

staticprivate

The seed for random numbers.

Definition at line 120 of file multiDimFunctionGraphGenerator.h.

_nbTotalVar_

Idx gum::MultiDimFunctionGraphGenerator::_nbTotalVar_

private

The total number of variables.

Definition at line 117 of file multiDimFunctionGraphGenerator.h.

Referenced by MultiDimFunctionGraphGenerator(), _createLeaf_(), and generate().

_varSeq_

const Sequence< const DiscreteVariable* > gum::MultiDimFunctionGraphGenerator::_varSeq_

private

The variables.

Definition at line 114 of file multiDimFunctionGraphGenerator.h.

Referenced by MultiDimFunctionGraphGenerator(), and generate().

---

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

• agrum/base/multidim/implementations/multiDimFunctionGraphGenerator.h
• agrum/base/multidim/implementations/multiDimFunctionGraphGenerator.cpp