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. More...
Constructors / Destructors
	MultiDimFunctionGraphGenerator (Idx maxVar, Idx minVar, const Sequence< const DiscreteVariable * > &varSeq)
	Default constructor. More...
	~MultiDimFunctionGraphGenerator ()
	Class destructor. More...

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

Definition at line 54 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 40 of file multiDimFunctionGraphGenerator.cpp.

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

                                                        :
      _varSeq_(varSeq) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphGenerator);

    _nbTotalVar_ = _varSeq_.size();
  }

Here is the call graph for this function:

~MultiDimFunctionGraphGenerator()

gum::MultiDimFunctionGraphGenerator::~MultiDimFunctionGraphGenerator

(

)

Class destructor.

Definition at line 51 of file multiDimFunctionGraphGenerator.cpp.

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

                                                                  {
    GUM_DESTRUCTOR(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 137 of file multiDimFunctionGraphGenerator.cpp.

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

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

Here is the call graph for this function:

_generateVarPos_()

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

private

Generate a variable position.

Definition at line 147 of file multiDimFunctionGraphGenerator.cpp.

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

                                                                           {
    Idx randOut = 0;

    if (span != 0) {
      auto                                generator = gum::getRandomGenerator();
      std::weibull_distribution< double > distribution(double(span), 1.0);
      randOut = (Idx)(distribution(generator) * span / 2);
      if (randOut > span) randOut = span;
    }

    return offset + randOut;
  }

Here is the call graph for this function:

generate()

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

(

)

Generates a MultiDimFunctionGraph.

Definition at line 55 of file multiDimFunctionGraphGenerator.cpp.

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

                                                                            {
    MultiDimFunctionGraph< double >* generatedFunctionGraph
       = MultiDimFunctionGraph< double >::getReducedAndOrderedInstance();

    for (SequenceIteratorSafe< const DiscreteVariable* > varIter = _varSeq_.beginSafe();
         varIter != _varSeq_.endSafe();
         ++varIter) {
      generatedFunctionGraph->add(**varIter);
    }

    HashTable< NodeId, Idx > node2MinVar;
    Idx                      nbIter = 0;

    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()) {   //&& nbIter < 20 ){

      NodeId currentNodeId = filo.back();
      filo.pop_back();
      Idx                 cvp         = node2MinVar[currentNodeId];
      const InternalNode* currentNode = generatedFunctionGraph->node(currentNodeId);

      LinkedList< NodeId > potentialSons;
      Idx                  nbPotentialSons = 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) {
            nbPotentialSons++;
            potentialSons.addLink(nicleIter->element());
            nicleIter = nicleIter->nextLink();
          }
        }
      }

      for (Idx modality = 0; modality < currentNode->nodeVar()->domainSize(); modality++) {
        if (!potentialSons.list()
            || (double)std::rand() / (double)RAND_MAX > (1.0 / (1.0 + 3.0 / nbPotentialSons))) {
          if (_createLeaf_(currentNodeId, node2MinVar)) {
            generatedFunctionGraph->manager()->setSon(
               currentNodeId,
               modality,
               generatedFunctionGraph->manager()->addTerminalNode((double)std::rand()
                                                                  / (double)RAND_MAX * 100));
          } 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 = (Idx)(((double)std::rand() / (double)RAND_MAX) * nbPotentialSons);
          sonPos     = sonPos == nbPotentialSons ? nbPotentialSons - 1 : sonPos;
          Link< NodeId >* nicleIter = potentialSons.list();
          while (sonPos) {
            nicleIter = nicleIter->nextLink();
            sonPos--;
          }
          generatedFunctionGraph->manager()->setSon(currentNodeId, modality, nicleIter->element());
        }
      }
      ++nbIter;
    }

    generatedFunctionGraph->manager()->reduce();
    generatedFunctionGraph->manager()->clean();

    return generatedFunctionGraph;
  }

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 99 of file multiDimFunctionGraphGenerator.h.

_nbTotalVar_

Idx gum::MultiDimFunctionGraphGenerator::_nbTotalVar_

private

The total number of variables.

Definition at line 96 of file multiDimFunctionGraphGenerator.h.

_varSeq_

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

private

The variables.

Definition at line 93 of file multiDimFunctionGraphGenerator.h.

---

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

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