<agrum/PRM/generator/clusteredLayerGenerator.h> More...

#include <clusteredLayerGenerator.h>

Inheritance diagram for gum::prm::ClusteredLayerGenerator< GUM_SCALAR >:

Collaboration diagram for gum::prm::ClusteredLayerGenerator< GUM_SCALAR >:

Classes
struct	MyData

Public Member Functions
Constructors and destructor.
	ClusteredLayerGenerator ()
	Default constructor.
	ClusteredLayerGenerator (const ClusteredLayerGenerator &source)
	Copy constructor.
ClusteredLayerGenerator &	operator= (const ClusteredLayerGenerator &source)
	Copy operator.
virtual	~ClusteredLayerGenerator ()
	Destructor.

Size	getDomainSize () const
	Getters and setters.
void	setDomainSize (Size s)
	Set the domain size of generated types.
Size	getMaxParents () const
	Returns the max number of parents allowed for any attribute or aggregator.
void	setMaxParents (Size s)
	Returns the max number of parents allowed for any attribute or aggregator.
double	getClusterRatio () const
	Returns the odds of a given class to be replaced by a cluster.
void	setClusterRatio (double ratio)
	Define the odds of a given class to be replaced by a cluster.
void	setLayers (const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &v)
	Defines the structure of each layers.
std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &	getLayer ()
	Getters and setters.
const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &	getLayer () const
	Getters and setters.
virtual PRM< GUM_SCALAR > *	generate ()
	Proceeds with the generation of the PRM<GUM_SCALAR>.

void	setNameGenerator (const NameGenerator &name_gen)
	Getters and setters.
const NameGenerator &	getNameGenerator () const
	Returns the NameGenerator used by this generator.

Protected Attributes
NameGenerator	name_gen_
	The name generator used by this class.

Private Member Functions
std::string	_generateType_ (PRMFactory< GUM_SCALAR > &f)
void	_generateInterfaces_ (PRMFactory< GUM_SCALAR > &f, std::string_view type, std::vector< MyData > &l)
void	_generateClasses_ (PRMFactory< GUM_SCALAR > &f, std::string_view type, std::vector< typename ClusteredLayerGenerator::MyData > &l)
void	_generateCluster_ (PRMFactory< GUM_SCALAR > &f, std::string_view type, std::vector< typename ClusteredLayerGenerator::MyData > &l, Size lvl, Set< std::string > &i)
void	_generateClass_ (PRMFactory< GUM_SCALAR > &f, std::string_view type, std::vector< typename ClusteredLayerGenerator::MyData > &l, Size lvl, Set< std::string > &i)
void	_generateClassDag_ (Size lvl, DAG &dag, Bijection< std::string, NodeId > &names, std::vector< typename ClusteredLayerGenerator::MyData > &l)
void	_generateSystem_ (PRMFactory< GUM_SCALAR > &factory, std::vector< typename ClusteredLayerGenerator::MyData > &l)

Private Attributes
std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData >	_layers_
Size	_domain_size_
Size	_max_parents_
double	_cluster_ratio_
HashTable< std::string, std::vector< std::string > * >	_cluster_map_

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::prm::ClusteredLayerGenerator< GUM_SCALAR >

This class generates PRMs with a clustered layer structure.

Definition at line 74 of file clusteredLayerGenerator.h.

Constructor & Destructor Documentation

◆ ClusteredLayerGenerator() [1/2]

template<GUM_Numeric GUM_SCALAR>

gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::ClusteredLayerGenerator ( )

Default constructor.

Definition at line 521 of file clusteredLayerGenerator_tpl.h.

                                                                   :
        _layers_(), _domain_size_(2), _max_parents_(INT_MAX), _cluster_ratio_(0.0) {
      GUM_CONSTRUCTOR(ClusteredLayerGenerator);
    }

References ClusteredLayerGenerator(), _cluster_ratio_, _domain_size_, _layers_, and _max_parents_.

Referenced by ClusteredLayerGenerator(), ClusteredLayerGenerator(), ~ClusteredLayerGenerator(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClusteredLayerGenerator() [2/2]

template<GUM_Numeric GUM_SCALAR>

gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::ClusteredLayerGenerator ( const ClusteredLayerGenerator< GUM_SCALAR > & source )

Copy constructor.

Definition at line 527 of file clusteredLayerGenerator_tpl.h.

                                                             :
        _layers_(source._layers_), _domain_size_(source._domain_size_),
        _max_parents_(source._max_parents_) {
      GUM_CONS_CPY(ClusteredLayerGenerator);
    }

References ClusteredLayerGenerator(), _domain_size_, _layers_, and _max_parents_.

Here is the call graph for this function:

◆ ~ClusteredLayerGenerator()

template<GUM_Numeric GUM_SCALAR>

gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::~ClusteredLayerGenerator ( )

virtual

Destructor.

Definition at line 535 of file clusteredLayerGenerator_tpl.h.

                                                                    {
      GUM_DESTRUCTOR(ClusteredLayerGenerator);
    }

References ClusteredLayerGenerator().

Here is the call graph for this function:

Member Function Documentation

◆ _generateClass_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClass_	(	PRMFactory< GUM_SCALAR > &	f,
		std::string_view	type,
		std::vector< typename ClusteredLayerGenerator< GUM_SCALAR >::MyData > &	l,
		Size	lvl,
		Set< std::string > &	i )

private

Definition at line 327 of file clusteredLayerGenerator_tpl.h.

                                                                                {
      Size       size = 0;
      GUM_SCALAR sum  = 0.0;
      l[lvl].c.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS));
      f.startClass(l[lvl].c.back(), "", &i);
 
      if (lvl) f.addReferenceSlot(l[lvl - 1].i, l[lvl].r, true);
 
      DAG                              dag;
      Bijection< std::string, NodeId > names;
      _generateClassDag_(lvl, dag, names, l);
 
      // Adding aggregates
      if (lvl) {
        for (const auto& agg: l[lvl].g) {
          std::vector< std::string > chain(
              1,
              std::format("{}.{}", l[lvl].r, l[lvl - 1].a[randomValue(l[lvl - 1].a.size())])),
              param(1, "1");
          f.addAggregator(agg, "exists", chain, param);
        }
      }
 
      // Adding attributes
      for (const auto& attr: l[lvl].a) {
        f.startAttribute(type, attr, true);
        size = getDomainSize();
 
        for (const auto par: dag.parents(names.second(attr))) {
          f.addParent(names.first(par));
          size *= f.retrieveClass(l[lvl].c.back()).get(names.first(par)).type()->domainSize();
        }
 
        std::vector< GUM_SCALAR > cpf(size), val(getDomainSize());
 
        for (size_t norms = 0; norms < size; norms += getDomainSize()) {
          sum = 0.0;
 
          for (size_t idx = 0; idx < getDomainSize(); ++idx) {
            val[idx] = 1 + std::rand();
            sum += val[idx];
          }
 
          for (size_t idx = 0; idx < getDomainSize(); ++idx)
            cpf[norms + idx] = val[idx] / sum;
        }
 
        f.setRawCPFByLines(cpf);
        f.endAttribute();
      }
 
      f.endClass();
    }

Referenced by _generateCluster_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateClassDag_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClassDag_	(	Size	lvl,
		DAG &	dag,
		Bijection< std::string, NodeId > &	names,
		std::vector< typename ClusteredLayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 387 of file clusteredLayerGenerator_tpl.h.

                                                                              {
      float                 density = _layers_[lvl].inner_density;
      std::vector< NodeId > nodes;
      NodeId                id = 0;
 
      if (lvl) {
        for (std::vector< std::string >::iterator g = l[lvl].g.begin(); g != l[lvl].g.end(); ++g) {
          id = dag.addNode();
          names.insert(*g, id);
          nodes.push_back(id);
        }
      }
 
      for (std::vector< std::string >::iterator a = l[lvl].a.begin(); a != l[lvl].a.end(); ++a) {
        id = dag.addNode();
        names.insert(*a, id);
 
        for (std::vector< NodeId >::iterator prnt = nodes.begin(); prnt != nodes.end(); ++prnt)
          if (randomProba() < density) dag.addArc(*prnt, names.second(*a));
 
        nodes.push_back(id);
      }
 
      // For each nodes with #parents >  _max_parents_ we randomly remove parents
      // until
      // #parents <=  _max_parents_
      for (const auto node: dag.nodes()) {
        if (dag.parents(node).size() > getMaxParents()) {
          std::vector< NodeId > v;
 
          for (const auto par: dag.parents(node))
            v.push_back(par);
 
          while (dag.parents(node).size() > getMaxParents()) {
            size_t idx = randomValue(v.size());
            Arc    arc(v[idx], node);
            GUM_ASSERT(dag.existsArc(arc));
            dag.eraseArc(arc);
            v[idx] = v.back();
            v.pop_back();
          }
        }
      }
    }

References _layers_, gum::DAG::addArc(), gum::NodeGraphPart::addNode(), gum::ArcGraphPart::eraseArc(), gum::ArcGraphPart::existsArc(), getMaxParents(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::insert(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), gum::randomProba(), gum::randomValue(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::second(), and gum::Set< Key >::size().

Referenced by _generateClass_(), and _generateCluster_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateClasses_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateClasses_	(	PRMFactory< GUM_SCALAR > &	f,
		std::string_view	type,
		std::vector< typename ClusteredLayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 114 of file clusteredLayerGenerator_tpl.h.

                                                                              {
      // double ratio = getClusterRatio() + RAND_MAX;
      Set< std::string > i;
 
      for (Size lvl = 0; lvl < _layers_.size(); ++lvl) {
        i.insert(l[lvl].i);
 
        for (Size c = 0; c < _layers_[lvl].c; ++c) {
          // if (std::rand() < ratio)
          _generateCluster_(f, type, l, lvl, i);
          // else
          //   _generateClass_(f, type, l, lvl, i);
        }
 
        i.erase(l[lvl].i);
      }
    }

References _generateCluster_(), _layers_, and gum::Set< Key >::insert().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateCluster_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateCluster_	(	PRMFactory< GUM_SCALAR > &	f,
		std::string_view	type,
		std::vector< typename ClusteredLayerGenerator< GUM_SCALAR >::MyData > &	l,
		Size	lvl,
		Set< std::string > &	i )

private

Definition at line 136 of file clusteredLayerGenerator_tpl.h.

                                                                                {
      Size                        size = 0;
      GUM_SCALAR                  sum  = 0.0;
      std::string                 first, second, third;
      std::vector< std::string >* v = 0;
 
      switch (randomValue(2)) {
        // Shape A->B
        // v == [first, second, second.ref -> first]
        case 0 : {
          v = new std::vector< std::string >();
          _generateClass_(f, type, l, lvl, i);
          first = l[lvl].c.back();
          v->push_back(first);
          v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS));
          f.startClass(v->back());
          v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
          f.addReferenceSlot(first, v->back(), true);
          DAG                              dag;
          Bijection< std::string, NodeId > names;
          _generateClassDag_(lvl, dag, names, l);
 
          // Adding aggregates
          for (std::vector< std::string >::iterator g = l[lvl].g.begin(); g != l[lvl].g.end();
               ++g) {
            std::vector< std::string > chain(
                1,
                std::format("{}.{}", v->back(), l[lvl].a[randomValue(l[lvl].a.size())])),
                param(1, "1");
            f.addAggregator(*g, "exists", chain, param);
          }
 
          // Adding attributes
          for (std::vector< std::string >::iterator a = l[lvl].a.begin(); a != l[lvl].a.end();
               ++a) {
            f.startAttribute(type, *a, true);
            size = getDomainSize();
 
            for (const auto par: dag.parents(names.second(*a))) {
              f.addParent(names.first(par));
              size *= f.retrieveClass(l[lvl].c.back()).get(names.first(par)).type()->domainSize();
            }
 
            std::vector< GUM_SCALAR > cpf(size), val(getDomainSize());
 
            for (size_t norms = 0; norms < size; norms += getDomainSize()) {
              sum = 0.0;
 
              for (size_t idx = 0; idx < getDomainSize(); ++idx) {
                val[idx] = 1 + std::rand();
                sum += val[idx];
              }
 
              for (size_t idx = 0; idx < getDomainSize(); ++idx)
                cpf[norms + idx] = val[idx] / sum;
            }
 
            f.setRawCPFByLines(cpf);
            f.endAttribute();
          }
 
          f.endClass();
          break;
        }
 
        // Shape A -> B -> C
        // v == [first, second, second.ref -> first, third, third.ref -> second]
        case 1 : {
          v = new std::vector< std::string >();
          _generateClass_(f, type, l, lvl, i);
          {
            first = l[lvl].c.back();
            v->push_back(first);
            v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS));
            second = v->back();
            f.startClass(second);
            v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
            f.addReferenceSlot(first, v->back(), true);
            DAG                              dag;
            Bijection< std::string, NodeId > names;
            _generateClassDag_(lvl, dag, names, l);
 
            // Adding aggregates
            for (std::vector< std::string >::iterator g = l[lvl].g.begin(); g != l[lvl].g.end();
                 ++g) {
              std::vector< std::string > chain(
                  1,
                  std::format("{}.{}", v->back(), l[lvl].a[randomValue(l[lvl].a.size())])),
                  param(1, "1");
              f.addAggregator(*g, "exists", chain, param);
            }
 
            // Adding attributes
            for (std::vector< std::string >::iterator a = l[lvl].a.begin(); a != l[lvl].a.end();
                 ++a) {
              f.startAttribute(type, *a, true);
              size = getDomainSize();
 
              for (const auto par: dag.parents(names.second(*a))) {
                f.addParent(names.first(par));
                size *= f.retrieveClass(l[lvl].c.back()).get(names.first(par)).type()->domainSize();
              }
 
              std::vector< GUM_SCALAR > cpf(size), val(getDomainSize());
 
              for (size_t norms = 0; norms < size; norms += getDomainSize()) {
                sum = 0.0;
 
                for (size_t idx = 0; idx < getDomainSize(); ++idx) {
                  val[idx] = 1 + std::rand();
                  sum += val[idx];
                }
 
                for (size_t idx = 0; idx < getDomainSize(); ++idx)
                  cpf[norms + idx] = val[idx] / sum;
              }
 
              f.setRawCPFByLines(cpf);
              f.endAttribute();
            }
 
            f.endClass();
          }
          {
            v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS));
            third = v->back();
            f.startClass(third);
            v->push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
            f.addReferenceSlot(second, v->back(), true);
            DAG                              dag;
            Bijection< std::string, NodeId > names;
            _generateClassDag_(lvl, dag, names, l);
 
            // Adding aggregates
            for (std::vector< std::string >::iterator g = l[lvl].g.begin(); g != l[lvl].g.end();
                 ++g) {
              std::vector< std::string > chain(
                  1,
                  std::format("{}.{}", v->back(), l[lvl].a[randomValue(l[lvl].a.size())])),
                  param(1, "1");
              f.addAggregator(*g, "exists", chain, param);
            }
 
            // Adding attributes
            for (std::vector< std::string >::iterator a = l[lvl].a.begin(); a != l[lvl].a.end();
                 ++a) {
              f.startAttribute(type, *a, true);
              size = getDomainSize();
 
              for (const auto par: dag.parents(names.second(*a))) {
                f.addParent(names.first(par));
                size *= f.retrieveClass(l[lvl].c.back()).get(names.first(par)).type()->domainSize();
              }
 
              std::vector< GUM_SCALAR > cpf(size), val(getDomainSize());
 
              for (size_t norms = 0; norms < size; norms += getDomainSize()) {
                sum = 0.0;
 
                for (size_t idx = 0; idx < getDomainSize(); ++idx) {
                  val[idx] = 1 + std::rand();
                  sum += val[idx];
                }
 
                for (size_t idx = 0; idx < getDomainSize(); ++idx)
                  cpf[norms + idx] = val[idx] / sum;
              }
 
              f.setRawCPFByLines(cpf);
              f.endAttribute();
            }
 
            f.endClass();
          }
          break;
        }
 
        default : {
          GUM_ERROR(OperationNotAllowed, "unexpected value")
        }
      }
 
      _cluster_map_.insert(first, v);
    }

Referenced by _generateClasses_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateInterfaces_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateInterfaces_	(	PRMFactory< GUM_SCALAR > &	f,
		std::string_view	type,
		std::vector< MyData > &	l )

private

Definition at line 85 of file clusteredLayerGenerator_tpl.h.

                                                                              {
      for (Size lvl = 0; lvl < _layers_.size(); ++lvl) {
        l.push_back(ClusteredLayerGenerator< GUM_SCALAR >::MyData());
        l[lvl].i = this->name_gen_.nextName(PRMObject::prm_type::PRM_INTERFACE);
        f.startInterface(l[lvl].i);
 
        for (Size a = 0; a < _layers_[lvl].a; ++a) {
          l[lvl].a.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
          f.addAttribute(type, l[lvl].a.back());
        }
 
        if (lvl) {
          for (Size g = 0; g < _layers_[lvl].g; ++g) {
            l[lvl].g.push_back(this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT));
            f.addAttribute("boolean", l[lvl].g.back());
          }
 
          l[lvl].r = this->name_gen_.nextName(PRMObject::prm_type::CLASS_ELT);
          f.addReferenceSlot(l[lvl - 1].i, l[lvl].r, true);
        }
 
        f.endInterface();
      }
    }

References _layers_, gum::prm::PRMFactory< GUM_SCALAR >::addAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::addReferenceSlot(), gum::prm::PRMObject::CLASS_ELT, gum::prm::PRMFactory< GUM_SCALAR >::endInterface(), gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::prm::PRMObject::PRM_INTERFACE, and gum::prm::PRMFactory< GUM_SCALAR >::startInterface().

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateSystem_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateSystem_	(	PRMFactory< GUM_SCALAR > &	factory,
		std::vector< typename ClusteredLayerGenerator< GUM_SCALAR >::MyData > &	l )

private

Definition at line 437 of file clusteredLayerGenerator_tpl.h.

                                                                              {
      factory.startSystem(this->name_gen_.nextName(PRMObject::prm_type::SYSTEM));
      std::vector< std::vector< std::string > > o(_layers_.size());
      std::string                               name, c, first, second, third;
      std::vector< std::string >*               v   = 0;
      size_t                                    idx = 0;
 
      for (size_t lvl = 0; lvl < _layers_.size(); ++lvl) {
        float density = _layers_[lvl].outter_density;
 
        for (size_t count = 0; count < _layers_[lvl].o; ++count) {
          c = l[lvl].c[randomValue(l[lvl].c.size())];
 
          if (_cluster_map_.exists(c)) {
            v = _cluster_map_[c];
 
            switch (v->size()) {
              case 3 : {
                first = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
                factory.addInstance(c, first);
                second = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
                factory.addInstance(v->at(1), second);
                factory.setReferenceSlot(std::format("{}.{}", second, v->at(2)), first);
                break;
              }
 
              case 5 : {
                first = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
                factory.addInstance(c, first);
                second = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
                factory.addInstance(v->at(1), second);
                factory.setReferenceSlot(std::format("{}.{}", second, v->at(2)), first);
                third = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
                factory.addInstance(v->at(3), third);
                factory.setReferenceSlot(std::format("{}.{}", third, v->at(4)), second);
                break;
              }
 
              default : {
                GUM_ERROR(OperationNotAllowed, "unexpected vector size")
              }
            }
 
            //  _cluster_map_.erase(c);
            // delete v;
            name = first;
          } else {
            name = this->name_gen_.nextName(PRMObject::prm_type::INSTANCE);
            factory.addInstance(c, name);
          }
 
          o[lvl].push_back(name);
 
          if (lvl) {
            std::string                chain = std::format("{}.{}", name, l[lvl].r);
            std::vector< std::string > ref2add;
 
            for (std::vector< std::string >::iterator iter = o[lvl - 1].begin();
                 iter != o[lvl - 1].end();
                 ++iter)
              if (randomProba() <= density) ref2add.push_back(*iter);
 
            if (ref2add.empty())
              factory.setReferenceSlot(chain, o[lvl - 1][randomValue(o[lvl - 1].size())]);
 
            while (ref2add.size() > getMaxParents()) {
              idx          = randomValue(ref2add.size());
              ref2add[idx] = ref2add.back();
              ref2add.pop_back();
            }
 
            for (std::vector< std::string >::iterator iter = ref2add.begin(); iter != ref2add.end();
                 ++iter)
              factory.setReferenceSlot(chain, *iter);
          }
        }
      }
 
      factory.endSystem();
    }

References _cluster_map_, _layers_, gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::endSystem(), getMaxParents(), GUM_ERROR, gum::prm::PRMObject::INSTANCE, gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::randomProba(), gum::randomValue(), gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot(), gum::prm::PRMFactory< GUM_SCALAR >::startSystem(), and gum::prm::PRMObject::SYSTEM.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _generateType_()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_generateType_ ( PRMFactory< GUM_SCALAR > & f )

private

Definition at line 72 of file clusteredLayerGenerator_tpl.h.

                                                                                               {
      std::string name = this->name_gen_.nextName(PRMObject::prm_type::TYPE);
      factory.startDiscreteType(name);
 
      for (Size i = 0; i < _domain_size_; ++i) {
        factory.addLabel(std::to_string(i));
      }
 
      factory.endDiscreteType();
      return name;
    }

References _domain_size_, gum::prm::PRMFactory< GUM_SCALAR >::addLabel(), gum::prm::PRMFactory< GUM_SCALAR >::endDiscreteType(), gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_, gum::prm::PRMFactory< GUM_SCALAR >::startDiscreteType(), and gum::prm::PRMObject::TYPE.

Referenced by generate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate()

template<GUM_Numeric GUM_SCALAR>

PRM< GUM_SCALAR > * gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::generate ( )

virtual

Proceeds with the generation of the PRM<GUM_SCALAR>.

Implements gum::prm::PRMGenerator< GUM_SCALAR >.

Definition at line 56 of file clusteredLayerGenerator_tpl.h.

                                                                       {
      if (_layers_.size() == 0) {
        GUM_ERROR(OperationNotAllowed, "cannot generate a layered PRM<GUM_SCALAR> without layers")
      }
 
      std::vector< MyData >    l;
      PRMFactory< GUM_SCALAR > factory;
      std::string              type = _generateType_(factory);
      _generateInterfaces_(factory, type, l);
      _generateClasses_(factory, type, l);
      _generateSystem_(factory, l);
      return factory.prm();
    }

References _generateClasses_(), _generateInterfaces_(), _generateSystem_(), _generateType_(), _layers_, GUM_ERROR, and gum::prm::PRMFactory< GUM_SCALAR >::prm().

Here is the call graph for this function:

◆ getClusterRatio()

template<GUM_Numeric GUM_SCALAR>

double gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getClusterRatio ( ) const

Returns the odds of a given class to be replaced by a cluster.

Definition at line 587 of file clusteredLayerGenerator_tpl.h.

                                                                        {
      return _cluster_ratio_;
    }

References _cluster_ratio_.

◆ getDomainSize()

template<GUM_Numeric GUM_SCALAR>

Size gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getDomainSize ( ) const

Getters and setters.

Returns the domain size of generated types.

Definition at line 549 of file clusteredLayerGenerator_tpl.h.

                                                                    {
      return _domain_size_;
    }

References _domain_size_.

Referenced by _generateClass_(), and _generateCluster_().

Here is the caller graph for this function:

◆ getLayer() [1/2]

template<GUM_Numeric GUM_SCALAR>

std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > & gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getLayer ( )

Getters and setters.

Returns the domain size of generated types.

Definition at line 576 of file clusteredLayerGenerator_tpl.h.

                                                        {
      return _layers_;
    }

References _layers_.

◆ getLayer() [2/2]

template<GUM_Numeric GUM_SCALAR>

const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > & gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getLayer ( ) const

Getters and setters.

Returns the domain size of generated types.

Definition at line 582 of file clusteredLayerGenerator_tpl.h.

                                                              {
      return _layers_;
    }

References _layers_.

◆ getMaxParents()

template<GUM_Numeric GUM_SCALAR>

Size gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getMaxParents ( ) const

Returns the max number of parents allowed for any attribute or aggregator.

Definition at line 559 of file clusteredLayerGenerator_tpl.h.

                                                                    {
      return _max_parents_;
    }

References _max_parents_.

Referenced by _generateClassDag_(), and _generateSystem_().

Here is the caller graph for this function:

◆ getNameGenerator()

template<GUM_Numeric GUM_SCALAR>

const NameGenerator & gum::prm::PRMGenerator< GUM_SCALAR >::getNameGenerator ( ) const

inherited

Returns the NameGenerator used by this generator.

Definition at line 77 of file PRMGenerator_tpl.h.

                                                                            {
      return name_gen_;
    }

References name_gen_.

◆ operator=()

template<GUM_Numeric GUM_SCALAR>

ClusteredLayerGenerator< GUM_SCALAR > & gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::operator= ( const ClusteredLayerGenerator< GUM_SCALAR > & source )

Copy operator.

Definition at line 540 of file clusteredLayerGenerator_tpl.h.

                                                             {
      _layers_      = source._layers_;
      _domain_size_ = source._domain_size_;
      _max_parents_ = source._max_parents_;
      return *this;
    }

References ClusteredLayerGenerator(), _domain_size_, _layers_, and _max_parents_.

Here is the call graph for this function:

◆ setClusterRatio()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setClusterRatio ( double ratio )

Define the odds of a given class to be replaced by a cluster.

Definition at line 592 of file clusteredLayerGenerator_tpl.h.

                                                                            {
      _cluster_ratio_ = ratio;
    }

References _cluster_ratio_.

◆ setDomainSize()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setDomainSize ( Size s )

Set the domain size of generated types.

Definition at line 554 of file clusteredLayerGenerator_tpl.h.

                                                                    {
      _domain_size_ = s;
    }

References _domain_size_.

◆ setLayers()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setLayers ( const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > & v )

Defines the structure of each layers.

Each value in v defines a layer, were v[i].first is the number of different classes in the i-th layer and v[i].second is the number of instances in the i-th layer.

Parameters

v	A vector describing each layer.

Definition at line 569 of file clusteredLayerGenerator_tpl.h.

                                                                              {
      _layers_ = v;
    }

References _layers_.

◆ setMaxParents()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setMaxParents ( Size s )

Returns the max number of parents allowed for any attribute or aggregator.

Definition at line 564 of file clusteredLayerGenerator_tpl.h.

                                                                    {
      _max_parents_ = s;
    }

References _max_parents_.

◆ setNameGenerator()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMGenerator< GUM_SCALAR >::setNameGenerator ( const NameGenerator & name_gen )

inherited

Getters and setters.

Defines the NameGenerator used by this generator.

Definition at line 72 of file PRMGenerator_tpl.h.

                                                                                   {
      name_gen_ = name_gen;
    }

References name_gen_.

Member Data Documentation

◆ _cluster_map_

template<GUM_Numeric GUM_SCALAR>

HashTable< std::string, std::vector< std::string >* > gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_cluster_map_

private

Definition at line 138 of file clusteredLayerGenerator.h.

Referenced by _generateCluster_(), and _generateSystem_().

◆ _cluster_ratio_

template<GUM_Numeric GUM_SCALAR>

double gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_cluster_ratio_

private

Definition at line 137 of file clusteredLayerGenerator.h.

Referenced by ClusteredLayerGenerator(), getClusterRatio(), and setClusterRatio().

◆ _domain_size_

template<GUM_Numeric GUM_SCALAR>

Size gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_domain_size_

private

Definition at line 135 of file clusteredLayerGenerator.h.

Referenced by ClusteredLayerGenerator(), ClusteredLayerGenerator(), _generateType_(), getDomainSize(), operator=(), and setDomainSize().

◆ _layers_

template<GUM_Numeric GUM_SCALAR>

std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_layers_

private

Definition at line 134 of file clusteredLayerGenerator.h.

Referenced by ClusteredLayerGenerator(), ClusteredLayerGenerator(), _generateClassDag_(), _generateClasses_(), _generateInterfaces_(), _generateSystem_(), generate(), getLayer(), getLayer(), operator=(), and setLayers().

◆ _max_parents_

template<GUM_Numeric GUM_SCALAR>

Size gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::_max_parents_

private

Definition at line 136 of file clusteredLayerGenerator.h.

Referenced by ClusteredLayerGenerator(), ClusteredLayerGenerator(), getMaxParents(), operator=(), and setMaxParents().

◆ name_gen_

template<GUM_Numeric GUM_SCALAR>

NameGenerator gum::prm::PRMGenerator< GUM_SCALAR >::name_gen_

protectedinherited

The name generator used by this class.

Definition at line 101 of file PRMGenerator.h.

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

agrum/PRM/generator/clusteredLayerGenerator.h
agrum/PRM/generator/clusteredLayerGenerator_tpl.h

Classes

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ClusteredLayerGenerator() [1/2]

◆ ClusteredLayerGenerator() [2/2]

◆ ~ClusteredLayerGenerator()

Member Function Documentation

◆ _generateClass_()

◆ _generateClassDag_()

◆ _generateClasses_()

◆ _generateCluster_()

◆ _generateInterfaces_()

◆ _generateSystem_()

◆ _generateType_()

◆ generate()

◆ getClusterRatio()

◆ getDomainSize()

◆ getLayer() [1/2]

◆ getLayer() [2/2]

◆ getMaxParents()

◆ getNameGenerator()

◆ operator=()

◆ setClusterRatio()

◆ setDomainSize()

◆ setLayers()

◆ setMaxParents()

◆ setNameGenerator()

Member Data Documentation

◆ _cluster_map_

◆ _cluster_ratio_

◆ _domain_size_

◆ _layers_

◆ _max_parents_

◆ name_gen_