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 150 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:

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:

generateVarPos__()

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

private

Generate a variable position.

Definition at line 162 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:

Member Data Documentation

genSeed__

Idx gum::MultiDimFunctionGraphGenerator::genSeed__

staticprivate

The seed for random numbers.

Definition at line 100 of file multiDimFunctionGraphGenerator.h.

nbTotalVar__

Idx gum::MultiDimFunctionGraphGenerator::nbTotalVar__

private

The total number of variables.

Definition at line 97 of file multiDimFunctionGraphGenerator.h.

varSeq__

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

private

The variables.

Definition at line 94 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