Draws a random k-DBN template (structure and, optionally, CPTs). More...

#include <agrum/KTBN/generator/KTBNGenerator.h>

Collaboration diagram for gum::KTBNGenerator< GUM_SCALAR >:

Classes
struct	_Arc_
	A (tail, head) endpoint pair, each as (base, slice). More...

Public Member Functions
Constructors / Destructor
	KTBNGenerator (Size k, Size nbTemporal, Size nbAtemporal=0, Size maxArcs=0, Size maxModality=2)
	Constructor.
	~KTBNGenerator ()
	Destructor.
Generation
void	generateKTBN (KTBN< GUM_SCALAR > &out)
	Fills `out` with a freshly drawn model (its previous content is discarded). Seed it with gum::initRandom() for reproducibility.
KTBN< GUM_SCALAR >	generate ()
	Same, returning the model by value.
Configuration (fluent)
KTBNGenerator< GUM_SCALAR > &	setDensity (double density)
	Fraction of the legal arc set to draw, in \([0,1]\). Ignored when a non-zero `maxArcs` was given to the constructor. Default 0.1.
KTBNGenerator< GUM_SCALAR > &	setDomainRange (Size minModality, Size maxModality)
	Domain sizes are drawn uniformly in \([min, max]\).
KTBNGenerator< GUM_SCALAR > &	setMaxParents (Size maxParents)
	Caps the number of parents of any node, which bounds CPT size. 0 (default) means unlimited — a dense draw can then produce very large CPTs, so set it when generating dense or high-k models.
KTBNGenerator< GUM_SCALAR > &	setGuaranteeOrder (bool on)
	Force one arc of lag \(k-1\) into the kernel slice, so the model's effective order equals \(k\) (see the class doc). Default `true`. No-op when \(k = 1\) or there is no temporal process.
KTBNGenerator< GUM_SCALAR > &	setGenerateCPTs (bool on)
	Whether to fill the CPTs with random values (default `true`). When `false` only the structure is drawn and the CPTs stay at their default content.
KTBNGenerator< GUM_SCALAR > &	setNamePrefixes (const std::string &temporal, const std::string &atemporal)
	Name prefixes; variables are `prefix0`, `prefix1`, … Defaults are `"X"` (temporal) and `"A"` (atemporal).
Accessors
Size	k () const
Size	nbLegalArcs () const

Private Member Functions
std::vector< _Arc_ >	_legalArcs_ (const std::vector< std::string > &temporal, const std::vector< std::string > &atemporal, const std::vector< Size > &tRank, const std::vector< Size > &aRank) const
	Every arc the k-DBN's rules allow, with the two cycle-prone families (lag 0, atemporal→atemporal) already restricted to the ranks given by `tRank` / `aRank`, so the result is acyclic by construction.

Static Private Member Functions
template<typename T>
static void	_shuffle_ (std::vector< T > &v)
	Fisher-Yates through gum::randomValue, so gum::initRandom() alone makes a whole generation reproducible.

Private Attributes
Size	_k_
Size	_nbTemporal_
Size	_nbAtemporal_
Size	_maxArcs_
Size	_minModality_ {2}
Size	_maxModality_
Size	_maxParents_ {0}
double	_density_ {0.1}
bool	_guaranteeOrder_ {true}
bool	_generateCPTs_ {true}
std::string	_temporalPrefix_ {"X"}
std::string	_atemporalPrefix_ {"A"}

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::KTBNGenerator< GUM_SCALAR >

Draws a random k-DBN template (structure and, optionally, CPTs).

Usage: initRandom(42); // reproducible

KTBNGenerator<double> gen(3, 4, 1); // k=3, 4 temporal, 1 atemporal

gen.setDensity(0.15).setMaxParents(4);

KTBN<double> model = gen.generate();

gum::KTBNGenerator::KTBNGenerator
KTBNGenerator(Size k, Size nbTemporal, Size nbAtemporal=0, Size maxArcs=0, Size maxModality=2)
Constructor.
Definition KTBNGenerator_tpl.h:71

gum::KTBN
Class representing a k-order dynamic Bayesian network (k-DBN).
Definition KTBN.h:197

gum::initRandom
GUM_SHARED_PUBLIC void initRandom(unsigned int seed=0)
Initialize random generator seed.
Definition utils_random_inl.h:79

Which arcs are legal: Exactly those gum::KTBN accepts: atemporal \(\to\) atemporal, atemporal \(\to\) temporal, and temporal \((b_1,s_1) \to (b_2,s_2)\) with \(s_1 \leq s_2\) (so the lag lies in \([0, k-1]\)). Temporal \(\to\) atemporal is forbidden. nbLegalArcs() counts them.

Acyclicity comes for free: A cross-slice arc can never close a cycle, since the slice index strictly increases along any path made of them. Only lag-0 arcs and atemporal \(\to\)atemporal arcs can. The generator therefore draws one random permutation of the temporal bases and one of the atemporal bases, and admits those two families only from the lower-ranked endpoint to the higher-ranked one. No cycle can be built, so no rejection sampling and no cycle test are needed.

Effective order vs. nominal \(\to\)#48: Drawn uniformly, a "k-TBN" may end up with no arc of lag \(k-1\) into the kernel slice \(k-1\) — its true Markov order is then below \(k\), and no learner can recover \(k\) from data sampled off it, because the data simply does not depend on that far a past. Order-recovery experiments built on such models silently score correct answers as errors, and the effect grows with \(k\) (more lags to miss at a fixed density). setGuaranteeOrder() (on by default) rules this out by forcing one arc of lag exactly \(k-1\) into slice \(k-1\), so the generated model's effective order really is \(k\). Switch it off to study the phenomenon.

Warning: The maximum lag a k-slice template can express is \(k-1\) (slice 0 to slice \(k-1\)), not \(k\): a lag of \(k\) would need \(k+1\) slices. For \(k=1\) there is no lag at all, and setGuaranteeOrder() is a silent no-op.

Definition at line 114 of file KTBNGenerator.h.

Constructor & Destructor Documentation

◆ KTBNGenerator()

template<GUM_Numeric GUM_SCALAR>

gum::KTBNGenerator< GUM_SCALAR >::KTBNGenerator	(	Size	k,
		Size	nbTemporal,
		Size	nbAtemporal = 0,
		Size	maxArcs = 0,
		Size	maxModality = 2 )

explicit

Constructor.

Parameters

k	Order of the generated k-DBN (number of template slices). Must be \(\geq 1\).
nbTemporal	Number of temporal processes.
nbAtemporal	Number of atemporal variables.
maxArcs	Hard cap on the number of arcs. 0 (default) means "derive it from the density" — see setDensity().
maxModality	Largest domain size; domains are drawn uniformly in \([2, maxModality]\). Must be \(\geq 2\).

Exceptions

InvalidArgument if k is 0 or maxModality is below 2.

Definition at line 71 of file KTBNGenerator_tpl.h.

                                                               :
      _k_(k), _nbTemporal_(nbTemporal), _nbAtemporal_(nbAtemporal), _maxArcs_(maxArcs),
      _maxModality_(maxModality) {
    if (k == 0) GUM_ERROR(InvalidArgument, "KTBNGenerator: k must be >= 1.")
    if (maxModality < 2) GUM_ERROR(InvalidArgument, "KTBNGenerator: maxModality must be >= 2.")
    GUM_CONSTRUCTOR(KTBNGenerator)
  }

References KTBNGenerator(), _k_, _maxArcs_, _maxModality_, _nbAtemporal_, _nbTemporal_, GUM_ERROR, and k().

Referenced by KTBNGenerator(), ~KTBNGenerator(), setDensity(), setDomainRange(), setGenerateCPTs(), setGuaranteeOrder(), and setMaxParents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~KTBNGenerator()

template<GUM_Numeric GUM_SCALAR>

gum::KTBNGenerator< GUM_SCALAR >::~KTBNGenerator ( )

Destructor.

Definition at line 84 of file KTBNGenerator_tpl.h.

                                              {
    GUM_DESTRUCTOR(KTBNGenerator)
  }

References KTBNGenerator().

Here is the call graph for this function:

Member Function Documentation

◆ _legalArcs_()

template<GUM_Numeric GUM_SCALAR>

std::vector< typename KTBNGenerator< GUM_SCALAR >::_Arc_ > gum::KTBNGenerator< GUM_SCALAR >::_legalArcs_	(	const std::vector< std::string > &	temporal,
		const std::vector< std::string > &	atemporal,
		const std::vector< Size > &	tRank,
		const std::vector< Size > &	aRank ) const

private

Every arc the k-DBN's rules allow, with the two cycle-prone families (lag 0, atemporal→atemporal) already restricted to the ranks given by tRank / aRank, so the result is acyclic by construction.

Definition at line 169 of file KTBNGenerator_tpl.h.

                                                                                            {
    const int            k  = static_cast< int >(_k_);
    constexpr int        AT = KTBN< GUM_SCALAR >::ATEMPORAL;
    std::vector< _Arc_ > out;
    out.reserve(nbLegalArcs());
 
    // atemporal -> atemporal: only low rank to high rank, which keeps it acyclic
    for (std::size_t i = 0; i < atemporal.size(); ++i)
      for (std::size_t j = 0; j < atemporal.size(); ++j)
        if (aRank[i] < aRank[j]) out.push_back({atemporal[i], AT, atemporal[j], AT});
 
    // atemporal -> temporal, at any slice: never cyclic, since the k-DBN's own
    // rules already forbid a temporal variable from parenting an atemporal one.
    for (const auto& a: atemporal)
      for (const auto& b: temporal)
        for (int s = 0; s < k; ++s)
          out.push_back({a, AT, b, s});
 
    // temporal, lag >= 1: the slice index strictly increases, so never cyclic
    for (int s1 = 0; s1 < k; ++s1)
      for (int s2 = s1 + 1; s2 < k; ++s2)
        for (const auto& b1: temporal)
          for (const auto& b2: temporal)
            out.push_back({b1, s1, b2, s2});
 
    // temporal, lag 0: the other cycle-prone family, so rank-ordered as well
    for (int s = 0; s < k; ++s)
      for (std::size_t i = 0; i < temporal.size(); ++i)
        for (std::size_t j = 0; j < temporal.size(); ++j)
          if (tRank[i] < tRank[j]) out.push_back({temporal[i], s, temporal[j], s});
 
    return out;
  }

References _k_, gum::KTBN< GUM_SCALAR >::ATEMPORAL, k(), and nbLegalArcs().

Referenced by generateKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _shuffle_()

template<GUM_Numeric GUM_SCALAR>

template<typename T>

void gum::KTBNGenerator< GUM_SCALAR >::_shuffle_ ( std::vector< T > & v )

staticprivate

Fisher-Yates through gum::randomValue, so gum::initRandom() alone makes a whole generation reproducible.

Definition at line 61 of file KTBNGenerator_tpl.h.

                                                               {
    for (std::size_t i = v.size(); i > 1; --i)
      std::swap(v[i - 1], v[randomValue(static_cast< Size >(i))]);
  }

References gum::randomValue().

Referenced by generateKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate()

template<GUM_Numeric GUM_SCALAR>

KTBN< GUM_SCALAR > gum::KTBNGenerator< GUM_SCALAR >::generate ( )

Same, returning the model by value.

Definition at line 279 of file KTBNGenerator_tpl.h.

                                                           {
    KTBN< GUM_SCALAR > out(_k_);
    generateKTBN(out);
    return out;
  }

References _k_, and generateKTBN().

Here is the call graph for this function:

◆ generateKTBN()

template<GUM_Numeric GUM_SCALAR>

void gum::KTBNGenerator< GUM_SCALAR >::generateKTBN ( KTBN< GUM_SCALAR > & out )

Fills out with a freshly drawn model (its previous content is discarded). Seed it with gum::initRandom() for reproducibility.

Definition at line 207 of file KTBNGenerator_tpl.h.

                                                                        {
    out = KTBN< GUM_SCALAR >(_k_);
 
    // ---- variables, with domain sizes drawn in [_minModality_, _maxModality_] ----
    const Size                 spread = _maxModality_ - _minModality_ + 1;
    std::vector< std::string > temporal, atemporal;
    temporal.reserve(_nbTemporal_);
    atemporal.reserve(_nbAtemporal_);
 
    for (Size i = 0; i < _nbTemporal_; ++i) {
      const std::string name = _temporalPrefix_ + std::to_string(i);
      out.add(LabelizedVariable(name, name, _minModality_ + randomValue(spread)), true);
      temporal.push_back(name);
    }
    for (Size i = 0; i < _nbAtemporal_; ++i) {
      const std::string name = _atemporalPrefix_ + std::to_string(i);
      out.add(LabelizedVariable(name, name, _minModality_ + randomValue(spread)), false);
      atemporal.push_back(name);
    }
 
    // ---- random ranks for the two cycle-prone arc families ----
    std::vector< Size > tPerm(_nbTemporal_), aPerm(_nbAtemporal_);
    for (Size i = 0; i < _nbTemporal_; ++i)
      tPerm[i] = i;
    for (Size i = 0; i < _nbAtemporal_; ++i)
      aPerm[i] = i;
    _shuffle_(tPerm);
    _shuffle_(aPerm);
 
    std::vector< Size > tRank(_nbTemporal_), aRank(_nbAtemporal_);
    for (Size i = 0; i < _nbTemporal_; ++i)
      tRank[tPerm[i]] = i;
    for (Size i = 0; i < _nbAtemporal_; ++i)
      aRank[aPerm[i]] = i;
 
    // ---- how many arcs to draw ----
    const Size legalCount = nbLegalArcs();
    Size       target     = (_maxArcs_ != 0)
                              ? _maxArcs_
                              : static_cast< Size >(std::llround(_density_ * double(legalCount)));
    if (target > legalCount) target = legalCount;
 
    Size added = 0;
 
    // ---- the guaranteed lag-(k-1) kernel arc ----
    // Slice 0 -> slice k-1 is the widest reach a k-slice template can express, so
    // this alone pins the model's effective order to k. Placed before the random
    // fill, and counted against the budget, so density still bounds the total.
    if (_guaranteeOrder_ && _k_ >= 2 && _nbTemporal_ >= 1) {
      const std::string& tail = temporal[randomValue(_nbTemporal_)];
      const std::string& head = temporal[randomValue(_nbTemporal_)];
      out.addArc(tail, 0, head, static_cast< int >(_k_) - 1);
      ++added;
    }
 
    // ---- fill with random legal arcs ----
    auto legal = _legalArcs_(temporal, atemporal, tRank, aRank);
    _shuffle_(legal);
    for (const auto& a: legal) {
      if (added >= target) break;
      if (out.existsArc(a.tailBase, a.tailSlice, a.headBase, a.headSlice)) continue;
      if (_maxParents_ != 0
          && static_cast< Size >(out.parents(a.headBase, a.headSlice).size()) >= _maxParents_)
        continue;
      out.addArc(a.tailBase, a.tailSlice, a.headBase, a.headSlice);
      ++added;
    }
 
    if (_generateCPTs_) out.generateCPTs();
  }

References gum::LabelizedVariable::LabelizedVariable(), _atemporalPrefix_, _density_, _generateCPTs_, _guaranteeOrder_, _k_, _legalArcs_(), _maxArcs_, _maxModality_, _maxParents_, _minModality_, _nbAtemporal_, _nbTemporal_, _shuffle_(), _temporalPrefix_, nbLegalArcs(), and gum::randomValue().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ k()

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::k ( ) const

Returns: The order of the generated models.

Definition at line 147 of file KTBNGenerator_tpl.h.

                                            {
    return _k_;
  }

References _k_.

Referenced by KTBNGenerator(), _legalArcs_(), and nbLegalArcs().

Here is the caller graph for this function:

◆ nbLegalArcs()

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::nbLegalArcs ( ) const

Returns: How many arcs the k-DBN's own rules allow, given the current shape. The density is a fraction of this, and it is the ceiling any maxArcs is silently clamped to.

Definition at line 152 of file KTBNGenerator_tpl.h.

                                                      {
    const Size n = _nbTemporal_, m = _nbAtemporal_, k = _k_;
    // guarded against unsigned underflow: each term is 0 when its shape is degenerate
    const Size atemporalPairs = (m >= 2) ? m * (m - 1) / 2 : 0;         // atemporal -> atemporal
    const Size atemporalToAll = m * n * k;                              // atemporal -> temporal
    const Size slicePairs     = (k >= 2) ? k * (k - 1) / 2 : 0;
    const Size crossSlice     = n * n * slicePairs;                     // temporal, lag >= 1
    const Size intraSlice     = ((n >= 2) ? n * (n - 1) / 2 : 0) * k;   // temporal, lag 0
    return atemporalPairs + atemporalToAll + crossSlice + intraSlice;
  }

References _k_, _nbAtemporal_, _nbTemporal_, and k().

Referenced by _legalArcs_(), and generateKTBN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setDensity()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setDensity ( double density )

Fraction of the legal arc set to draw, in \([0,1]\). Ignored when a non-zero maxArcs was given to the constructor. Default 0.1.

Exceptions

OutOfBounds if density is outside \([0,1]\).

Definition at line 93 of file KTBNGenerator_tpl.h.

                                                                                     {
    if (density < 0.0 || density > 1.0)
      GUM_ERROR(OutOfBounds, "KTBNGenerator: density must lie in [0,1].")
    _density_ = density;
    return *this;
  }

References KTBNGenerator(), _density_, and GUM_ERROR.

Here is the call graph for this function:

◆ setDomainRange()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setDomainRange	(	Size	minModality,
		Size	maxModality )

Domain sizes are drawn uniformly in \([min, max]\).

Exceptions

InvalidArgument if minModality < 2 or maxModality < minModality.

Definition at line 101 of file KTBNGenerator_tpl.h.

                                                                                             {
    if (minModality < 2) GUM_ERROR(InvalidArgument, "KTBNGenerator: minModality must be >= 2.")
    if (maxModality < minModality)
      GUM_ERROR(InvalidArgument, "KTBNGenerator: maxModality must be >= minModality.")
    _minModality_ = minModality;
    _maxModality_ = maxModality;
    return *this;
  }

References KTBNGenerator(), _maxModality_, _minModality_, and GUM_ERROR.

Here is the call graph for this function:

◆ setGenerateCPTs()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setGenerateCPTs ( bool on )

Whether to fill the CPTs with random values (default true). When false only the structure is drawn and the CPTs stay at their default content.

Definition at line 124 of file KTBNGenerator_tpl.h.

                                                                                   {
    _generateCPTs_ = on;
    return *this;
  }

References KTBNGenerator(), and _generateCPTs_.

Here is the call graph for this function:

◆ setGuaranteeOrder()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setGuaranteeOrder ( bool on )

Force one arc of lag \(k-1\) into the kernel slice, so the model's effective order equals \(k\) (see the class doc). Default true. No-op when \(k = 1\) or there is no temporal process.

Definition at line 118 of file KTBNGenerator_tpl.h.

                                                                                     {
    _guaranteeOrder_ = on;
    return *this;
  }

References KTBNGenerator(), and _guaranteeOrder_.

Here is the call graph for this function:

◆ setMaxParents()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setMaxParents ( Size maxParents )

Caps the number of parents of any node, which bounds CPT size. 0 (default) means unlimited — a dense draw can then produce very large CPTs, so set it when generating dense or high-k models.

Definition at line 112 of file KTBNGenerator_tpl.h.

                                                                                         {
    _maxParents_ = maxParents;
    return *this;
  }

References KTBNGenerator(), and _maxParents_.

Here is the call graph for this function:

◆ setNamePrefixes()

template<GUM_Numeric GUM_SCALAR>

KTBNGenerator< GUM_SCALAR > & gum::KTBNGenerator< GUM_SCALAR >::setNamePrefixes	(	const std::string &	temporal,
		const std::string &	atemporal )

Name prefixes; variables are prefix0, prefix1, … Defaults are "X" (temporal) and "A" (atemporal).

Exceptions

InvalidArgument if a prefix is empty or the two are equal.

Definition at line 131 of file KTBNGenerator_tpl.h.

                                                                               {
    if (temporal.empty() || atemporal.empty())
      GUM_ERROR(InvalidArgument, "KTBNGenerator: a name prefix cannot be empty.")
    if (temporal == atemporal)
      GUM_ERROR(InvalidArgument, "KTBNGenerator: the two name prefixes must differ.")
    _temporalPrefix_  = temporal;
    _atemporalPrefix_ = atemporal;
    return *this;
  }

References _atemporalPrefix_, _temporalPrefix_, and GUM_ERROR.

Member Data Documentation

◆ _atemporalPrefix_

template<GUM_Numeric GUM_SCALAR>

std::string gum::KTBNGenerator< GUM_SCALAR >::_atemporalPrefix_ {"A"}

private

Definition at line 228 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setNamePrefixes().

◆ _density_

template<GUM_Numeric GUM_SCALAR>

double gum::KTBNGenerator< GUM_SCALAR >::_density_ {0.1}

private

Definition at line 223 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setDensity().

◆ _generateCPTs_

template<GUM_Numeric GUM_SCALAR>

bool gum::KTBNGenerator< GUM_SCALAR >::_generateCPTs_ {true}

private

Definition at line 225 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setGenerateCPTs().

◆ _guaranteeOrder_

template<GUM_Numeric GUM_SCALAR>

bool gum::KTBNGenerator< GUM_SCALAR >::_guaranteeOrder_ {true}

private

Definition at line 224 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setGuaranteeOrder().

◆ _k_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_k_

private

Definition at line 216 of file KTBNGenerator.h.

Referenced by KTBNGenerator(), _legalArcs_(), generate(), generateKTBN(), k(), and nbLegalArcs().

◆ _maxArcs_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_maxArcs_

private

Definition at line 219 of file KTBNGenerator.h.

Referenced by KTBNGenerator(), and generateKTBN().

◆ _maxModality_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_maxModality_

private

Definition at line 221 of file KTBNGenerator.h.

Referenced by KTBNGenerator(), generateKTBN(), and setDomainRange().

◆ _maxParents_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_maxParents_ {0}

private

Definition at line 222 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setMaxParents().

◆ _minModality_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_minModality_ {2}

private

Definition at line 220 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setDomainRange().

◆ _nbAtemporal_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_nbAtemporal_

private

Definition at line 218 of file KTBNGenerator.h.

Referenced by KTBNGenerator(), generateKTBN(), and nbLegalArcs().

◆ _nbTemporal_

template<GUM_Numeric GUM_SCALAR>

Size gum::KTBNGenerator< GUM_SCALAR >::_nbTemporal_

private

Definition at line 217 of file KTBNGenerator.h.

Referenced by KTBNGenerator(), generateKTBN(), and nbLegalArcs().

◆ _temporalPrefix_

template<GUM_Numeric GUM_SCALAR>

std::string gum::KTBNGenerator< GUM_SCALAR >::_temporalPrefix_ {"X"}

private

Definition at line 227 of file KTBNGenerator.h.

Referenced by generateKTBN(), and setNamePrefixes().

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

agrum/KTBN/generator/KTBNGenerator.h
agrum/KTBN/generator/KTBNGenerator_tpl.h

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KTBNGenerator()

◆ ~KTBNGenerator()

Member Function Documentation

◆ _legalArcs_()

◆ _shuffle_()

◆ generate()

◆ generateKTBN()

◆ k()

◆ nbLegalArcs()

◆ setDensity()

◆ setDomainRange()

◆ setGenerateCPTs()

◆ setGuaranteeOrder()

◆ setMaxParents()

◆ setNamePrefixes()

Member Data Documentation

◆ _atemporalPrefix_

◆ _density_

◆ _generateCPTs_

◆ _guaranteeOrder_

◆ _k_

◆ _maxArcs_

◆ _maxModality_

◆ _maxParents_

◆ _minModality_

◆ _nbAtemporal_

◆ _nbTemporal_

◆ _temporalPrefix_