Private structure to represent data about a Class<GUM_SCALAR>. More...

Collaboration diagram for gum::prm::StructuredInference< GUM_SCALAR >::CData:

Public Member Functions
	CData (const PRMClass< GUM_SCALAR > &c)
	Default constructor.
	~CData ()
	Destructor.
NodeSet &	inners ()
	Returns the set of inner nodes.
NodeSet &	aggregators ()
	Returns the set of aggregators and their parents.
NodeSet &	outputs ()
	Returns the set of outputs nodes.
std::vector< NodeId > &	elim_order ()
	The elimination order for nodes of this class.

Public Attributes
const PRMClass< GUM_SCALAR > &	c
	The class about what this data is about.
UndiGraph	moral_graph
	The class moral graph. NodeId matches those in c.
NodeProperty< Size >	mods
	The class variables modalities.
List< NodeSet >	partial_order
	The partial order used of variable elimination.
Set< const PRMInstance< GUM_SCALAR > * >	instances
	The Set of Instances reduces at class level.
Set< Tensor< GUM_SCALAR > * >	pool
	The tensor pool obtained by C elimination of inner nodes.

Private Attributes
std::vector< NodeId >	_elim_order_
NodeSet	_inners_
NodeSet	_aggregators_
NodeSet	_outputs_
Set< Tensor< GUM_SCALAR > * >	_trash_

Detailed Description

template<typename GUM_SCALAR>
struct gum::prm::StructuredInference< GUM_SCALAR >::CData

Private structure to represent data about a Class<GUM_SCALAR>.

Definition at line 224 of file structuredInference.h.

Constructor & Destructor Documentation

◆ CData()

template<typename GUM_SCALAR>

gum::prm::StructuredInference< GUM_SCALAR >::CData::CData ( const PRMClass< GUM_SCALAR > & c )

Default constructor.

Definition at line 821 of file structuredInference_tpl.h.

                                                                                       :
        c(a_class), _elim_order_(0) {
      GUM_CONSTRUCTOR(StructuredInference< GUM_SCALAR >::CData);
 
      // First step we add Attributes and Aggregators
      for (const auto node: c.containerDag().nodes()) {
        switch (c.get(node).elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_attribute : {
            pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >(c.get(node).cpf())));
            // break omited : We want to execute the next block
            // for attributes
          }
 
          case PRMClassElement< GUM_SCALAR >::prm_aggregate : {
            moral_graph.addNodeWithId(node);
            mods.insert(node, c.get(node).type()->domainSize());
            break;
          }
 
          default : { /* do nothing */
          }
        }
      }
 
      // Second, we add edges, moralise the graph and build the partial ordering
      for (const auto node: moral_graph.nodes()) {
        const auto& parents = c.containerDag().parents(node);
 
        // Adding edges and marrying parents
        for (auto tail = parents.begin(); tail != parents.end(); ++tail) {
          if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(*tail))
              || PRMClassElement< GUM_SCALAR >::isAggregate(c.get(*tail))) {
            moral_graph.addEdge(*tail, node);
            NodeSet::const_iterator marry = tail;
            ++marry;
 
            while (marry != parents.end()) {
              if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(*marry))
                  || PRMClassElement< GUM_SCALAR >::isAggregate(c.get(*marry)))
                moral_graph.addEdge(*tail, *marry);
 
              ++marry;
            }
          }
        }
 
        // Adding nodes to the partial ordering
        switch (c.get(node).elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_aggregate : {
            if (c.isOutputNode(c.get(node))) outputs().insert(node);
            else aggregators().insert(node);
 
            // If the aggregators is not an output and have parents which are
            // not outputs, we must eliminate the parents after adding the
            // aggregator's CPT
            for (const auto par: c.containerDag().parents(node)) {
              const auto& prnt = c.get(par);
 
              if ((!c.isOutputNode(prnt))
                  && (PRMClassElement< GUM_SCALAR >::isAttribute(prnt)
                      || PRMClassElement< GUM_SCALAR >::isAggregate(prnt))) {
                inners().erase(prnt.id());
                aggregators().insert(prnt.id());
              }
            }
 
            break;
          }
 
          case PRMClassElement< GUM_SCALAR >::prm_attribute : {
            pool.insert(const_cast< Tensor< GUM_SCALAR >* >(&(c.get(node).cpf())));
 
            if (c.isOutputNode(c.get(node))) outputs().insert(node);
            else if (!aggregators().exists(node)) inners().insert(node);
 
            break;
          }
 
          default : { /* Do nothing */
          }
        }
      }
 
      if (inners().size()) partial_order.insert(inners());
 
      if (aggregators().size()) partial_order.insert(aggregators());
 
      if (outputs().size()) partial_order.insert(outputs());
 
      GUM_ASSERT(partial_order.size());
      PartialOrderedTriangulation t(&moral_graph, &mods, &partial_order);
      _elim_order_ = t.eliminationOrder();
 
      for (size_t i = 0; i < inners().size(); ++i)
        eliminateNode(&(c.get(_elim_order_[i]).type().variable()), pool, _trash_);
    }

References _elim_order_, _trash_, aggregators(), c, gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key >::erase(), inners(), gum::Set< Key >::insert(), gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), mods, moral_graph, outputs(), partial_order, pool, gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, and gum::Set< Key >::size().

Here is the call graph for this function:

◆ ~CData()

template<typename GUM_SCALAR>

gum::prm::StructuredInference< GUM_SCALAR >::CData::~CData ( )

Destructor.

Definition at line 919 of file structuredInference_tpl.h.

                                                   {
      GUM_DESTRUCTOR(StructuredInference< GUM_SCALAR >::CData);
 
      for (const auto pot: _trash_)
        delete pot;
    }