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

Public Member Functions
Constructors and destructor.
	ClusteredLayerGenerator ()
	Default constructor. More...

	ClusteredLayerGenerator (const ClusteredLayerGenerator &source)
	Copy constructor. More...

ClusteredLayerGenerator &	operator= (const ClusteredLayerGenerator &source)
	Copy operator. More...

virtual	~ClusteredLayerGenerator ()
	Destructor. More...


Size	getDomainSize () const
	Getters and setters. More...

void	setDomainSize (Size s)
	Set the domain size of generated types. More...

Size	getMaxParents () const
	Returns the max number of parents allowed for any attribute or aggregator. More...

void	setMaxParents (Size s)
	Returns the max number of parents allowed for any attribute or aggregator. More...

double	getClusterRatio () const
	Returns the odds of a given class to be replaced by a cluster. More...

void	setClusterRatio (double ratio)
	Define the odds of a given class to be replaced by a cluster. More...

void	setLayers (const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &v)
	Defines the structure of each layers. More...

std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &	getLayer ()
	Getters and setters. More...

const std::vector< typename LayerGenerator< GUM_SCALAR >::LayerData > &	getLayer () const
	Getters and setters. More...

virtual PRM< GUM_SCALAR > *	generate ()
	Proceeds with the generation of the PRM<GUM_SCALAR>. More...


void	setNameGenerator (const NameGenerator &name_gen)
	Getters and setters. More...

const NameGenerator &	getNameGenerator () const
	Returns the NameGenerator used by this generator. More...

Protected Attributes
NameGenerator	_name_gen
	The name generator used by this class. More...

Classes
struct	MyData

Detailed Description

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

This class generates PRMs with a clustered layer structure.

Definition at line 54 of file clusteredLayerGenerator.h.

Constructor & Destructor Documentation

◆ ClusteredLayerGenerator() [1/2]

template<typename GUM_SCALAR >

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

Default constructor.

Definition at line 527 of file clusteredLayerGenerator_tpl.h.

                                                                           :
         __layers(), __domain_size(2), __max_parents(INT_MAX),
         __cluster_ratio(0.0) {
       GUM_CONSTRUCTOR(ClusteredLayerGenerator);
     }

◆ ClusteredLayerGenerator() [2/2]

template<typename GUM_SCALAR >

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

Copy constructor.

Definition at line 534 of file clusteredLayerGenerator_tpl.h.

                                                             :
         __layers(source.__layers),
         __domain_size(source.__domain_size), __max_parents(source.__max_parents) {
       GUM_CONS_CPY(ClusteredLayerGenerator);
     }

◆ ~ClusteredLayerGenerator()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 542 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::operator=().

                                                                            {
       GUM_DESTRUCTOR(ClusteredLayerGenerator);
       // typedef HashTable<std::string, std::vector<std::string>*>::iterator
       // Iter;
       // for (Iter iter = __cluster_map.begin(); iter != __cluster_map.end();
       // ++iter)
       // {
       //   delete *iter;
       // }
     }

Here is the call graph for this function:

Member Function Documentation

◆ __generateClass()

template<typename GUM_SCALAR>

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

private

Definition at line 317 of file clusteredLayerGenerator_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::addAggregator(), gum::prm::PRMFactory< GUM_SCALAR >::addParent(), gum::prm::PRMFactory< GUM_SCALAR >::addReferenceSlot(), gum::prm::PRMObject::CLASS, gum::prm::PRMFactory< GUM_SCALAR >::endAttribute(), gum::prm::PRMFactory< GUM_SCALAR >::endClass(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::first(), gum::ArcGraphPart::parents(), gum::prm::PRMFactory< GUM_SCALAR >::retrieveClass(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::second(), gum::prm::PRMFactory< GUM_SCALAR >::setRawCPFByLines(), gum::prm::PRMFactory< GUM_SCALAR >::startAttribute(), and gum::prm::PRMFactory< GUM_SCALAR >::startClass().

                                                                                {
       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::stringstream s;
           s << l[lvl].r << "." << l[lvl - 1].a[std::rand() % l[lvl - 1].a.size()];
           std::vector< std::string > chain(1, s.str()), 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();
     }

Here is the call graph for this function:

◆ __generateClassDag()

template<typename 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 379 of file clusteredLayerGenerator_tpl.h.

References gum::DAG::addArc(), gum::NodeGraphPart::addNode(), gum::ArcGraphPart::eraseArc(), gum::ArcGraphPart::existsArc(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::second(), and gum::Set< Key, Alloc >::size().

                                                                              {
       float                 density = __layers[lvl].inner_density * RAND_MAX;
       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 (std::rand() < 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 = std::rand() % v.size();
             Arc    arc(v[idx], node);
             GUM_ASSERT(dag.existsArc(arc));
             dag.eraseArc(arc);
             v[idx] = v.back();
             v.pop_back();
           }
         }
       }
     }

Here is the call graph for this function:

◆ __generateClasses()

template<typename GUM_SCALAR>

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

private

Definition at line 94 of file clusteredLayerGenerator_tpl.h.

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

                                                                              {
       // 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);
       }
     }

Here is the call graph for this function:

◆ __generateCluster()

template<typename GUM_SCALAR>

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

private

Definition at line 116 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 (std::rand() % 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::stringstream s;
             s << v->back() << "." << l[lvl].a[std::rand() % l[lvl].a.size()];
             std::vector< std::string > chain(1, s.str()), 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::stringstream s;
               s << v->back() << "." << l[lvl].a[std::rand() % l[lvl].a.size()];
               std::vector< std::string > chain(1, s.str()), 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::stringstream s;
               s << v->back() << "." << l[lvl].a[std::rand() % l[lvl].a.size()];
               std::vector< std::string > chain(1, s.str()), 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);
     }

Here is the call graph for this function:

◆ __generateInterfaces()

template<typename GUM_SCALAR>

void gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__generateInterfaces	(	PRMFactory< GUM_SCALAR > &	f,
		const std::string &	type,
		std::vector< MyData > &	l
	)

private

Definition at line 63 of file clusteredLayerGenerator_tpl.h.

References 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::PRMObject::PRM_INTERFACE, and gum::prm::PRMFactory< GUM_SCALAR >::startInterface().

                                                                              {
       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();
       }
     }

Here is the call graph for this function:

◆ __generateSystem()

template<typename 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 435 of file clusteredLayerGenerator_tpl.h.

References gum::prm::PRMFactory< GUM_SCALAR >::addInstance(), gum::prm::PRMFactory< GUM_SCALAR >::endSystem(), GUM_ERROR, gum::prm::PRMObject::INSTANCE, gum::prm::PRMFactory< GUM_SCALAR >::setReferenceSlot(), gum::prm::PRMFactory< GUM_SCALAR >::startSystem(), and gum::prm::PRMObject::SYSTEM.

                                                                              {
       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 * RAND_MAX;
 
         for (size_t count = 0; count < __layers[lvl].o; ++count) {
           c = l[lvl].c[std::rand() % 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);
                 std::stringstream chain;
                 chain << second << "." << v->at(2);
                 factory.setReferenceSlot(chain.str(), 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);
                 std::stringstream chain_1, chain_2;
                 chain_1 << second << "." << v->at(2);
                 factory.setReferenceSlot(chain_1.str(), first);
                 third = this->_name_gen.nextName(PRMObject::prm_type::INSTANCE);
                 factory.addInstance(v->at(3), third);
                 chain_2 << third << "." << v->at(4);
                 factory.setReferenceSlot(chain_2.str(), 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::stringstream chain;
             chain << 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 (std::rand() <= density) ref2add.push_back(*iter);
 
             if (ref2add.empty())
               factory.setReferenceSlot(
                  chain.str(), o[lvl - 1][std::rand() % o[lvl - 1].size()]);
 
             while (ref2add.size() > getMaxParents()) {
               idx = std::rand() % 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.str(), *iter);
           }
         }
       }
 
       factory.endSystem();
     }

Here is the call graph for this function:

◆ __generateType()

template<typename GUM_SCALAR >

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

private

Definition at line 47 of file clusteredLayerGenerator_tpl.h.

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

                                           {
       std::string name = this->_name_gen.nextName(PRMObject::prm_type::TYPE);
       factory.startDiscreteType(name);
 
       for (Size i = 0; i < __domain_size; ++i) {
         std::stringstream sBuff;
         sBuff << i;
         factory.addLabel(sBuff.str());
       }
 
       factory.endDiscreteType();
       return name;
     }

Here is the call graph for this function:

◆ generate()

template<typename 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 31 of file clusteredLayerGenerator_tpl.h.

References GUM_ERROR, and gum::prm::PRMFactory< GUM_SCALAR >::prm().

                                                                        {
       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();
     }

Here is the call graph for this function:

◆ getClusterRatio()

template<typename GUM_SCALAR >

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

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

Definition at line 602 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__cluster_ratio.

                                                                                {
       return __cluster_ratio;
     }

◆ getDomainSize()

template<typename GUM_SCALAR >

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

Getters and setters.

Returns the domain size of generated types.

Definition at line 564 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__domain_size.

                                                                            {
       return __domain_size;
     }

◆ getLayer() [1/2]

template<typename GUM_SCALAR >

INLINE 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 591 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__layers.

                                                            {
       return __layers;
     }

◆ getLayer() [2/2]

template<typename GUM_SCALAR >

INLINE 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 597 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__layers.

                                                                        {
       return __layers;
     }

◆ getMaxParents()

template<typename GUM_SCALAR >

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

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

Definition at line 574 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__max_parents.

                                                                            {
       return __max_parents;
     }

◆ getNameGenerator()

template<typename GUM_SCALAR >

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

inherited

Returns the NameGenerator used by this generator.

Definition at line 55 of file PRMGenerator_tpl.h.

References gum::prm::PRMGenerator< GUM_SCALAR >::_name_gen.

                                                                     {
       return _name_gen;
     }

◆ operator=()

template<typename GUM_SCALAR >

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

Copy operator.

Definition at line 556 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__domain_size, gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__layers, and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__max_parents.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::~ClusteredLayerGenerator().

                                                                           {
       __layers = source.__layers;
       __domain_size = source.__domain_size;
       __max_parents = source.__max_parents;
       return *this;
     }

Here is the caller graph for this function:

◆ setClusterRatio()

template<typename GUM_SCALAR >

INLINE 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 608 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__cluster_ratio.

                                                                           {
       __cluster_ratio = ratio;
     }

◆ setDomainSize()

template<typename GUM_SCALAR >

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

Set the domain size of generated types.

Definition at line 569 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__domain_size.

                                                                            {
       __domain_size = s;
     }

◆ setLayers()

template<typename GUM_SCALAR >

INLINE 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 584 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__layers.

                                                                              {
       __layers = v;
     }

◆ setMaxParents()

template<typename GUM_SCALAR >

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

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

Definition at line 579 of file clusteredLayerGenerator_tpl.h.

References gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::__max_parents.

                                                                            {
       __max_parents = s;
     }

◆ setNameGenerator()

template<typename GUM_SCALAR >

INLINE 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 48 of file PRMGenerator_tpl.h.

References gum::prm::PRMGenerator< GUM_SCALAR >::_name_gen.

                                       {
       _name_gen = name_gen;
     }

Member Data Documentation

◆ __cluster_map

template<typename GUM_SCALAR>

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

private

Definition at line 119 of file clusteredLayerGenerator.h.

◆ __cluster_ratio

template<typename GUM_SCALAR>

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

private

Definition at line 118 of file clusteredLayerGenerator.h.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getClusterRatio(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setClusterRatio().

◆ __domain_size

template<typename GUM_SCALAR>

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

private

Definition at line 116 of file clusteredLayerGenerator.h.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getDomainSize(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::operator=(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setDomainSize().

◆ __layers

template<typename GUM_SCALAR>

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

private

Definition at line 115 of file clusteredLayerGenerator.h.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getLayer(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::operator=(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setLayers().

◆ __max_parents

template<typename GUM_SCALAR>

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

private

Definition at line 117 of file clusteredLayerGenerator.h.

Referenced by gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::getMaxParents(), gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::operator=(), and gum::prm::ClusteredLayerGenerator< GUM_SCALAR >::setMaxParents().

◆ _name_gen

template<typename GUM_SCALAR >

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

protectedinherited

The name generator used by this class.

Definition at line 78 of file PRMGenerator.h.

Referenced by gum::prm::PRMGenerator< GUM_SCALAR >::getNameGenerator(), and gum::prm::PRMGenerator< GUM_SCALAR >::setNameGenerator().

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

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

Public Member Functions

Protected Attributes

Classes

Detailed Description

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

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

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