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

Definition at line 53 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 __nbTotalVar, and __varSeq.

                                                                                :
      __varSeq(varSeq) {
    GUM_CONSTRUCTOR(MultiDimFunctionGraphGenerator);

    __nbTotalVar = __varSeq.size();
  }

~MultiDimFunctionGraphGenerator()

gum::MultiDimFunctionGraphGenerator::~MultiDimFunctionGraphGenerator

(

)

Class destructor.

Definition at line 49 of file multiDimFunctionGraphGenerator.cpp.

                                                                  {
    GUM_DESTRUCTOR(MultiDimFunctionGraphGenerator);
  }

Member Function Documentation

__createLeaf()

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

private

Creates a leaf.

Definition at line 147 of file multiDimFunctionGraphGenerator.cpp.

References __nbTotalVar.

Referenced by generate().

                                                                  {
    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 caller graph for this function:

__generateVarPos()

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

private

Generate a variable position.

Definition at line 158 of file multiDimFunctionGraphGenerator.cpp.

References gum::getRandomGenerator().

Referenced by generate().

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

Here is the caller graph for this function:

generate()

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

(

)

Generates a MultiDimFunctionGraph.

Definition at line 53 of file multiDimFunctionGraphGenerator.cpp.

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::DiscreteVariable::domainSize(), gum::Link< T >::element(), gum::MultiDimFunctionGraph< GUM_SCALAR, TerminalNodePolicy >::getReducedAndOrderedInstance(), gum::HashTable< Key, Val, Alloc >::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::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().

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

__nbTotalVar

Idx gum::MultiDimFunctionGraphGenerator::__nbTotalVar

private

The total number of variables.

Definition at line 94 of file multiDimFunctionGraphGenerator.h.

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

__varSeq

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

private

The variables.

Definition at line 91 of file multiDimFunctionGraphGenerator.h.

Referenced by generate(), and MultiDimFunctionGraphGenerator().

---

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

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