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

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

Public Attributes
const PRMClass< GUM_SCALAR > &	c
	The class about what this data is about. More...

UndiGraph	moral_graph
	The class moral graph. NodeId matches those in c. More...

NodeProperty< Size >	mods
	The class variables modalities. More...

List< NodeSet >	partial_order
	The partial order used of variable elimination. More...

Set< const PRMInstance< GUM_SCALAR > *>	instances
	The Set of Instances reduces at class level. More...

Set< Potential< GUM_SCALAR > *>	pool
	The potential pool obtained by C elimination of inner nodes. More...

Public Member Functions
	CData (const PRMClass< GUM_SCALAR > &c)
	Default constructor. More...

	~CData ()
	Destructor. More...

NodeSet &	inners ()
	Returns the set of inner nodes. More...

NodeSet &	aggregators ()
	Returns the set of aggregators and their parents. More...

NodeSet &	outputs ()
	Returns the set of outputs nodes. More...

std::vector< NodeId > &	elim_order ()
	The elimination order for nodes of this class. More...

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 215 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 852 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< Potential< 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< Potential< 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);
     }

Here is the call graph for this function:

◆ ~CData()

template<typename GUM_SCALAR >

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

Destructor.

Definition at line 958 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::CData::__trash.

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