gum::prm::SVED< GUM_SCALAR > Class Template Reference

This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>. More...

#include <agrum/PRM/SVED.h>

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

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

Public Types
using	EMap = NodeProperty< const Tensor< GUM_SCALAR >* >
	Code alias.
using	EMapIterator = typename NodeProperty< const Tensor< GUM_SCALAR >* >::iterator_safe
	Code alias.
using	EMapConstIterator
	Code alias.

Public Member Functions
Constructors & destructor.
	SVED (const PRM< GUM_SCALAR > &prm, const PRMSystem< GUM_SCALAR > &model)
	Default Constructor.
	~SVED () override
	Destructor.
Getters & setters.
std::string	name () const override
	Returns the name of the current inference algorithm.
Query methods.
void	posterior (const Chain &chain, Tensor< GUM_SCALAR > &m)
	Compute the posterior of the formal attribute pointed by chain and stores it in m.
void	joint (const std::vector< Chain > &chains, Tensor< GUM_SCALAR > &j)
	Compute the joint probability of the formals attributes pointed by chains and stores it in m.
Evidence handling.
EMap &	evidence (const PRMInstance< GUM_SCALAR > &i)
	Returns EMap of evidences over i.
EMap &	evidence (const PRMInstance< GUM_SCALAR > *i)
	Returns EMap of evidences over i.
const EMap &	evidence (const PRMInstance< GUM_SCALAR > &i) const
	Returns EMap of evidences over i.
const EMap &	evidence (const PRMInstance< GUM_SCALAR > *i) const
	Returns EMap of evidences over i.
bool	hasEvidence (const PRMInstance< GUM_SCALAR > &i) const
	Returns true if i has evidence.
bool	hasEvidence (const PRMInstance< GUM_SCALAR > *i) const
	Returns EMap of evidences over i.
bool	hasEvidence (const Chain &chain) const
	Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.
bool	hasEvidence () const
	Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.
void	addEvidence (const Chain &chain, const Tensor< GUM_SCALAR > &p)
	Add an evidence to the given instance's elt.
void	removeEvidence (const Chain &chain)
	Remove evidence on the given instance's elt.
void	clearEvidence ()
	Remove all evidences.

Protected Attributes
Protected members.
PRM< GUM_SCALAR > const *	prm_
	The PRM<GUM_SCALAR> on which inference is done.
PRMSystem< GUM_SCALAR > const *	sys_
	The Model on which inference is done.

Private Types
using	BucketSet = Set< Tensor< GUM_SCALAR >* >
	Code alias.
using	BucketSetIterator = typename Set< Tensor< GUM_SCALAR >* >::iterator_safe
using	ArraySetIterator = typename Set< MultiDimArray< GUM_SCALAR >* >::iterator_safe

Private Member Functions
Inference sub methods.
void	_eliminateNodes_ (const PRMInstance< GUM_SCALAR > *query, NodeId id, BucketSet &pool, BucketSet &trash)
	Returns true if second can be eliminated before first.
void	_eliminateNodesDownward_ (const PRMInstance< GUM_SCALAR > *from, const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash, List< const PRMInstance< GUM_SCALAR > * > &elim_list, Set< const PRMInstance< GUM_SCALAR > * > &ignore)
	Returns true if second can be eliminated before first.
void	_eliminateNodesUpward_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash, List< const PRMInstance< GUM_SCALAR > * > &elim_list, Set< const PRMInstance< GUM_SCALAR > * > &ignore)
	Returns true if second can be eliminated before first.
void	_eliminateNodesWithEvidence_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash)
	Returns true if second can be eliminated before first.
void	_insertLiftedNodes_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash)
	Returns true if second can be eliminated before first.
bool	_checkElimOrder_ (const PRMInstance< GUM_SCALAR > *first, const PRMInstance< GUM_SCALAR > *second)
	Returns true if second can be eliminated before first.
void	_initElimOrder_ ()
	Returns true if second can be eliminated before first.
void	_insertEvidence_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool)
	Returns true if second can be eliminated before first.
std::vector< NodeId > &	_getElimOrder_ (const PRMClass< GUM_SCALAR > &c)
	Returns true if second can be eliminated before first.
Tensor< GUM_SCALAR > *	_getAggTensor_ (const PRMInstance< GUM_SCALAR > *i, const PRMAggregate< GUM_SCALAR > *agg)
	Returns true if second can be eliminated before first.
void	_initLiftedNodes_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &trash)
	Returns true if second can be eliminated before first.
void	_initReqSets_ (const PRMInstance< GUM_SCALAR > *i)
	Returns true if second can be eliminated before first.
Set< NodeId > &	_getAttrSet_ (const PRMInstance< GUM_SCALAR > *i)
	Returns true if second can be eliminated before first.
Set< NodeId > &	_getSCSet_ (const PRMInstance< GUM_SCALAR > *i)
	Returns true if second can be eliminated before first.
void	_reduceElimList_ (const PRMInstance< GUM_SCALAR > *i, List< const PRMInstance< GUM_SCALAR > * > &elim_list, List< const PRMInstance< GUM_SCALAR > * > &reduced_list, Set< const PRMInstance< GUM_SCALAR > * > &ignore, BucketSet &pool, BucketSet &trash)
	Returns true if second can be eliminated before first.
std::string	_trim_ (std::string_view s)
	Returns true if second can be eliminated before first.

Private Attributes
HashTable< const PRMClass< GUM_SCALAR > *, std::vector< NodeId > * >	_elim_orders_
HashTable< const Set< NodeId > *, BucketSet * >	_lifted_pools_
	The Set<NodeId> returned by StructuredBayesBall<GUM_SCALAR> is unique for each family of instances with the same requisite set (thus the same lifted tensors).
Sequence< std::string > *	_class_elim_order_
StructuredBayesBall< GUM_SCALAR >	_bb_
HashTable< const Set< NodeId > *, std::pair< Set< NodeId > *, Set< NodeId > * > >	_req_set_
	First pair -> requisite Attributes Second pair -> requisite SlotChains.

Query methods.
using	Chain = typename PRMInference< GUM_SCALAR >::Chain
	Code alias.
void	evidenceAdded_ (const Chain &chain) override
	See PRMInference::evidenceAdded_().
void	evidenceRemoved_ (const Chain &chain) override
	See PRMInference::evidenceRemoved_().
void	posterior_ (const Chain &chain, Tensor< GUM_SCALAR > &m) override
	See PRMInference::posterior_().
void	joint_ (const std::vector< Chain > &queries, Tensor< GUM_SCALAR > &j) override
	See PRMInference::joint_().

Private evidence handling methods and members.
using	EvidenceIterator
	Code alias.
using	EvidenceConstIterator
	Code alias.
HashTable< const PRMInstance< GUM_SCALAR > *, EMap * >	_evidences_
	Mapping of evidence over PRMInstance<GUM_SCALAR>'s nodes.
EMap &	_EMap_ (const PRMInstance< GUM_SCALAR > *i)
	Private getter over evidences, if necessary creates an EMap for i.

Detailed Description

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

This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>.

Definition at line 74 of file SVED.h.

Member Typedef Documentation

ArraySetIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::SVED< GUM_SCALAR >::ArraySetIterator = typename Set< MultiDimArray< GUM_SCALAR >* >::iterator_safe

private

Definition at line 125 of file SVED.h.

BucketSet

template<GUM_Numeric GUM_SCALAR>

using gum::prm::SVED< GUM_SCALAR >::BucketSet = Set< Tensor< GUM_SCALAR >* >

private

Code alias.

Definition at line 123 of file SVED.h.

BucketSetIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::SVED< GUM_SCALAR >::BucketSetIterator = typename Set< Tensor< GUM_SCALAR >* >::iterator_safe

private

Definition at line 124 of file SVED.h.

Chain

template<GUM_Numeric GUM_SCALAR>

using gum::prm::SVED< GUM_SCALAR >::Chain = typename PRMInference< GUM_SCALAR >::Chain

protected

Code alias.

Definition at line 105 of file SVED.h.

EMap

template<GUM_Numeric GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMap = NodeProperty< const Tensor< GUM_SCALAR >* >

inherited

Code alias.

Definition at line 74 of file PRMInference.h.

EMapConstIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMapConstIterator

inherited

Initial value:

 
typename NodeProperty< const Tensor< GUM_SCALAR >* >::const_iterator_safe

Code alias.

Definition at line 80 of file PRMInference.h.

EMapIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMapIterator = typename NodeProperty< const Tensor< GUM_SCALAR >* >::iterator_safe

inherited

Code alias.

Definition at line 77 of file PRMInference.h.

EvidenceConstIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EvidenceConstIterator

privateinherited

Initial value:

 
typename HashTable< const PRMInstance< GUM_SCALAR >*, EMap* >::const_iterator_safe

Code alias.

Definition at line 241 of file PRMInference.h.

EvidenceIterator

template<GUM_Numeric GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EvidenceIterator

privateinherited

Initial value:

 
typename HashTable< const PRMInstance< GUM_SCALAR >*, EMap* >::iterator_safe

Code alias.

Definition at line 238 of file PRMInference.h.

Constructor & Destructor Documentation

SVED()

template<GUM_Numeric GUM_SCALAR>

gum::prm::SVED< GUM_SCALAR >::SVED	(	const PRM< GUM_SCALAR > &	prm,
		const PRMSystem< GUM_SCALAR > &	model )

Default Constructor.

Definition at line 485 of file SVED_tpl.h.

                                                                                               :
        PRMInference< GUM_SCALAR >(prm, model), _class_elim_order_(0), _bb_(*this) {
      GUM_CONSTRUCTOR(SVED);
    }

References gum::prm::PRMInference< GUM_SCALAR >::PRMInference(), SVED(), _bb_, and _class_elim_order_.

Referenced by SVED(), and ~SVED().

Here is the call graph for this function:

Here is the caller graph for this function:

~SVED()

template<GUM_Numeric GUM_SCALAR>

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

override

Destructor.

Definition at line 56 of file SVED_tpl.h.

                              {
      GUM_DESTRUCTOR(SVED);
 
      for (const auto& elt: _elim_orders_)
        delete elt.second;
 
      if (_class_elim_order_ != nullptr) delete _class_elim_order_;
    }

References SVED(), _class_elim_order_, and _elim_orders_.

Here is the call graph for this function:

Member Function Documentation

_checkElimOrder_()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::SVED< GUM_SCALAR >::_checkElimOrder_ ( const PRMInstance< GUM_SCALAR > * first, const PRMInstance< GUM_SCALAR > * second )

private

Returns true if second can be eliminated before first.

Definition at line 510 of file SVED_tpl.h.

                                                                                       {
      if (_class_elim_order_ == 0) { _initElimOrder_(); }
 
      auto first_name  = _trim_(first->type().name());
      auto second_name = _trim_(second->type().name());
      return (_class_elim_order_->pos(first_name) <= _class_elim_order_->pos(second_name));
    }

References _class_elim_order_, _initElimOrder_(), _trim_(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by _eliminateNodes_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), and _reduceElimList_().

Here is the call graph for this function:

Here is the caller graph for this function:

_eliminateNodes_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_eliminateNodes_ ( const PRMInstance< GUM_SCALAR > * query, NodeId id, BucketSet & pool, BucketSet & trash )

private

Returns true if second can be eliminated before first.

Definition at line 66 of file SVED_tpl.h.

                                                                                      {
      Set< const PRMInstance< GUM_SCALAR >* > ignore;
      ignore.insert(query);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = _getAttrSet_(query);
      Set< NodeId >& sc_set   = _getSCSet_(query);
      // Downward elimination
      List< const PRMInstance< GUM_SCALAR >* > elim_list;
 
      for (const auto attr: attr_set) {
        if (query->hasRefAttr(attr)) {
          for (auto iter = query->getRefAttr(attr).begin(); iter != query->getRefAttr(attr).end();
               ++iter)
            if ((!ignore.exists(iter->first)) && (_bb_.exists(iter->first)))
              _eliminateNodesDownward_(query, iter->first, pool, trash, elim_list, ignore);
        }
      }
 
      // Eliminating all nodes in query instance, except query
      InstanceBayesNet< GUM_SCALAR >         bn(*query);
      const auto                             moralg = bn.moralGraph();
      DefaultTriangulation                   t(&moralg, &(bn.modalities()));
      std::vector< const DiscreteVariable* > elim_order;
 
      if (this->hasEvidence(query)) _insertEvidence_(query, pool);
 
      for (const auto attr: attr_set)
        pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >(query->get(attr).cpf())));
 
      for (size_t idx = 0; idx < t.eliminationOrder().size(); ++idx) {
        if (t.eliminationOrder()[idx] != node) {
          auto        var_id = t.eliminationOrder()[idx];
          const auto& var    = bn.variable(var_id);
          elim_order.push_back(&var);
        }
      }
 
      eliminateNodes(elim_order, pool, trash);
      // Eliminating instance in elim_list
      List< const PRMInstance< GUM_SCALAR >* > tmp_list;
      _reduceElimList_(query, elim_list, tmp_list, ignore, pool, trash);
 
      while (!elim_list.empty()) {
        if (_checkElimOrder_(query, elim_list.front())) {
          if ((!ignore.exists(elim_list.front())) && (_bb_.exists(elim_list.front())))
            _eliminateNodesDownward_(query, elim_list.front(), pool, trash, elim_list, ignore);
        } else if (_bb_.exists(elim_list.front())) {
          tmp_list.insert(elim_list.front());
        }
 
        elim_list.popFront();
      }
 
      // Upward elimination
      for (const auto chain: sc_set)
        for (const auto parent: query->getInstances(chain))
          if ((!ignore.exists(parent)) && (_bb_.exists(*parent)))
            _eliminateNodesUpward_(parent, pool, trash, tmp_list, ignore);
    }

References _bb_, _checkElimOrder_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), _getAttrSet_(), _getSCSet_(), _insertEvidence_(), _reduceElimList_(), gum::prm::eliminateNodes(), gum::StaticTriangulation::eliminationOrder(), gum::List< Val >::empty(), gum::Set< Key >::exists(), gum::List< Val >::front(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::PRMInstance< GUM_SCALAR >::hasRefAttr(), gum::List< Val >::insert(), gum::Set< Key >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::List< Val >::popFront(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by posterior_().

Here is the call graph for this function:

Here is the caller graph for this function:

_eliminateNodesDownward_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_eliminateNodesDownward_ ( const PRMInstance< GUM_SCALAR > * from, const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash, List< const PRMInstance< GUM_SCALAR > * > & elim_list, Set< const PRMInstance< GUM_SCALAR > * > & ignore )

private

Returns true if second can be eliminated before first.

Definition at line 130 of file SVED_tpl.h.

                                                          {
      ignore.insert(i);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = _getAttrSet_(i);
      Set< NodeId >& sc_set   = _getSCSet_(i);
      // Calling elimination over child instance
      List< const PRMInstance< GUM_SCALAR >* > my_list;
 
      for (const auto attr: attr_set) {
        if (i->hasRefAttr(attr)) {
          for (auto iter = i->getRefAttr(attr).begin(); iter != i->getRefAttr(attr).end(); ++iter)
            if ((!ignore.exists(iter->first)) && (_bb_.exists(iter->first)))
              _eliminateNodesDownward_(i, iter->first, pool, trash, my_list, ignore);
        }
      }
 
      // Eliminating all nodes in current instance
      if (this->hasEvidence(i)) {
        _eliminateNodesWithEvidence_(i, pool, trash);
      } else {
        _insertLiftedNodes_(i, pool, trash);
 
        for (const auto agg: i->type().aggregates())
          if (_bb_.requisiteNodes(i).exists(agg->id())) pool.insert(_getAggTensor_(i, agg));
 
        if (auto p_eo = _elim_orders_.tryGet(&(i->type()))) {
          InstanceBayesNet< GUM_SCALAR >         bn(*i);
          std::vector< const DiscreteVariable* > elim_order;
 
          for (auto node: *(*p_eo)) {
            const auto& var = bn.variable(node);
            elim_order.push_back(&var);
          }
 
          eliminateNodes(elim_order, pool, trash);
        }
      }
 
      // Calling elimination over child's parents
      while (!my_list.empty()) {
        if (_checkElimOrder_(i, my_list.front())) {
          if ((!ignore.exists(my_list.front())) && (_bb_.exists(my_list.front())))
            _eliminateNodesDownward_(i, my_list.front(), pool, trash, my_list, ignore);
        } else if (_bb_.exists(my_list.front())) {
          elim_list.insert(my_list.front());
        }
 
        my_list.popFront();
      }
 
      // Adding parents instance to elim_list
      for (const auto chain: sc_set)
        for (const auto parent: i->getInstances(chain))
          if ((!ignore.exists(parent)) && _bb_.exists(parent) && (parent != from))
            elim_list.insert(parent);
    }

References _bb_, _checkElimOrder_(), _elim_orders_, _eliminateNodesDownward_(), _eliminateNodesWithEvidence_(), _getAggTensor_(), _getAttrSet_(), _getSCSet_(), _insertLiftedNodes_(), gum::prm::eliminateNodes(), gum::List< Val >::empty(), gum::List< Val >::front(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::PRMInstance< GUM_SCALAR >::hasRefAttr(), gum::List< Val >::insert(), gum::Set< Key >::insert(), gum::List< Val >::popFront(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by _eliminateNodes_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), and _reduceElimList_().

Here is the call graph for this function:

Here is the caller graph for this function:

_eliminateNodesUpward_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_eliminateNodesUpward_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash, List< const PRMInstance< GUM_SCALAR > * > & elim_list, Set< const PRMInstance< GUM_SCALAR > * > & ignore )

private

Returns true if second can be eliminated before first.

Definition at line 194 of file SVED_tpl.h.

                                                          {
      ignore.insert(i);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = _getAttrSet_(i);
      Set< NodeId >& sc_set   = _getSCSet_(i);
 
      // Downward elimination
      for (const auto attr: attr_set) {
        if (i->hasRefAttr(attr)) {
          for (auto iter = i->getRefAttr(attr).begin(); iter != i->getRefAttr(attr).end(); ++iter)
            if ((!ignore.exists(iter->first)) && (_bb_.exists(iter->first)))
              _eliminateNodesDownward_(i, iter->first, pool, trash, elim_list, ignore);
        }
      }
 
      // Eliminating all nodes in i instance
      if (this->hasEvidence(i)) {
        _eliminateNodesWithEvidence_(i, pool, trash);
      } else {
        _insertLiftedNodes_(i, pool, trash);
 
        for (const auto agg: i->type().aggregates())
          if (_bb_.requisiteNodes(i).exists(agg->id())) pool.insert(_getAggTensor_(i, agg));
 
        if (auto p_eo = _elim_orders_.tryGet(&(i->type()))) {
          InstanceBayesNet< GUM_SCALAR >         bn(*i);
          std::vector< const DiscreteVariable* > elim_order;
 
          for (auto node: *(*p_eo)) {
            const auto& var = bn.variable(node);
            elim_order.push_back(&var);
          }
          eliminateNodes(elim_order, pool, trash);
        }
      }
 
      // Eliminating instance in elim_list
      List< const PRMInstance< GUM_SCALAR >* > tmp_list;
 
      while (!elim_list.empty()) {
        if (_checkElimOrder_(i, elim_list.front())) {
          if ((!ignore.exists(elim_list.front())) && (_bb_.exists(elim_list.front())))
            _eliminateNodesDownward_(i, elim_list.front(), pool, trash, elim_list, ignore);
        } else if (_bb_.exists(elim_list.front())) {
          ignore.insert(elim_list.front());
        }
 
        elim_list.popFront();
      }
 
      // Upward elimination
      for (const auto chain: sc_set)
        for (const auto parent: i->getInstances(chain))
          if ((!ignore.exists(parent)) && (_bb_.exists(parent)))
            _eliminateNodesUpward_(parent, pool, trash, tmp_list, ignore);
    }

References _bb_, _checkElimOrder_(), _elim_orders_, _eliminateNodesDownward_(), _eliminateNodesUpward_(), _eliminateNodesWithEvidence_(), _getAggTensor_(), _getAttrSet_(), _getSCSet_(), _insertLiftedNodes_(), gum::prm::eliminateNodes(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::PRMInstance< GUM_SCALAR >::hasRefAttr(), gum::Set< Key >::insert(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by _eliminateNodes_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_eliminateNodesWithEvidence_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_eliminateNodesWithEvidence_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash )

private

Returns true if second can be eliminated before first.

Definition at line 257 of file SVED_tpl.h.

                                                                                                  {
      // Adding required evidences
      for (const auto& elt: this->evidence(i))
        if (_bb_.requisiteNodes(i).exists(elt.first))
          pool.insert(const_cast< Tensor< GUM_SCALAR >* >(elt.second));
 
      // Adding tensors and eliminating the remaining nodes
      for (const auto& a: *i)
        if (_bb_.requisiteNodes(i).exists(a.first))
          pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >(a.second->cpf())));
 
      InstanceBayesNet< GUM_SCALAR > bn(*i);
      const auto                     moralg = bn.moralGraph();
      DefaultTriangulation           t(&moralg, &(bn.modalities()));
      const std::vector< NodeId >&   full_elim_order = t.eliminationOrder();
 
      for (auto var = full_elim_order.begin(); var != full_elim_order.end(); ++var)
        eliminateNode(&(i->get(*var).type().variable()), pool, trash);
    }

References _bb_, gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::prm::PRMInference< GUM_SCALAR >::evidence(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::Set< Key >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), and gum::DAGmodel::moralGraph().

Referenced by _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_EMap_()

template<GUM_Numeric GUM_SCALAR>

PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::_EMap_ ( const PRMInstance< GUM_SCALAR > * i )

privateinherited

Private getter over evidences, if necessary creates an EMap for i.

Definition at line 117 of file PRMInference_tpl.h.

                                                                             {
      if (auto p = _evidences_.tryGet(i)) {
        return **p;
      } else {
        auto* emap = new PRMInference< GUM_SCALAR >::EMap();
        _evidences_.insert(i, emap);
        return *emap;
      }
    }

References _evidences_.

Referenced by removeEvidence().

Here is the caller graph for this function:

_getAggTensor_()

template<GUM_Numeric GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::prm::SVED< GUM_SCALAR >::_getAggTensor_ ( const PRMInstance< GUM_SCALAR > * i, const PRMAggregate< GUM_SCALAR > * agg )

private

Returns true if second can be eliminated before first.

Definition at line 521 of file SVED_tpl.h.

                                                                                  {
      return &(const_cast< Tensor< GUM_SCALAR >& >(i->get(agg->safeName()).cpf()));
    }

References gum::prm::PRMInstance< GUM_SCALAR >::get(), and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_getAttrSet_()

template<GUM_Numeric GUM_SCALAR>

Set< NodeId > & gum::prm::SVED< GUM_SCALAR >::_getAttrSet_ ( const PRMInstance< GUM_SCALAR > * i )

private

Returns true if second can be eliminated before first.

Definition at line 537 of file SVED_tpl.h.

                                                                                      {
      auto p = _req_set_.tryGet(&(_bb_.requisiteNodes(i)));
      if (!p) {
        _initReqSets_(i);
        p = _req_set_.tryGet(&(_bb_.requisiteNodes(i)));
      }
      return *(p->first);
    }

References _bb_, _initReqSets_(), and _req_set_.

Referenced by _eliminateNodes_(), _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_getElimOrder_()

template<GUM_Numeric GUM_SCALAR>

std::vector< NodeId > & gum::prm::SVED< GUM_SCALAR >::_getElimOrder_ ( const PRMClass< GUM_SCALAR > & c )

private

Returns true if second can be eliminated before first.

Definition at line 497 of file SVED_tpl.h.

                                                                                           {
      return *(_elim_orders_[&c]);
    }

References _elim_orders_.

_getSCSet_()

template<GUM_Numeric GUM_SCALAR>

Set< NodeId > & gum::prm::SVED< GUM_SCALAR >::_getSCSet_ ( const PRMInstance< GUM_SCALAR > * i )

private

Returns true if second can be eliminated before first.

Definition at line 547 of file SVED_tpl.h.

                                                                                    {
      auto p = _req_set_.tryGet(&(_bb_.requisiteNodes(i)));
      if (!p) {
        _initReqSets_(i);
        p = _req_set_.tryGet(&(_bb_.requisiteNodes(i)));
      }
      return *(p->second);
    }

References _bb_, _initReqSets_(), and _req_set_.

Referenced by _eliminateNodes_(), _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_initElimOrder_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_initElimOrder_ ( )

private

Returns true if second can be eliminated before first.

Definition at line 362 of file SVED_tpl.h.

                                             {
      ClassDependencyGraph< GUM_SCALAR >                        cdg(*(this->prm_));
      Sequence< const PRMClassElementContainer< GUM_SCALAR >* > class_elim_order;
      std::list< NodeId >                                       l;
 
      for (const auto node: cdg.internalDag().nodes()) {
        if (cdg.internalDag().parents(node).empty()) { l.push_back(node); }
      }
 
      Set< NodeId > visited_node;
 
      while (!l.empty()) {
        visited_node.insert(l.front());
 
        if (!class_elim_order.exists(cdg.get(l.front()).first)) {
          class_elim_order.insert(cdg.get(l.front()).first);
        }
 
        for (const auto child: cdg.internalDag().children(l.front())) {
          if (!visited_node.contains(child)) { l.push_back(child); }
        }
 
        l.pop_front();
      }
 
      _class_elim_order_ = new Sequence< std::string >();
      for (auto c: class_elim_order) {
        std::string name = c->name();
        if (auto pos = name.find_first_of("<"); pos != std::string::npos) {
          name = name.substr(0, pos);
        }
        try {
          _class_elim_order_->insert(name);
        } catch (DuplicateElement const&) {}
      }
    }

References _class_elim_order_, gum::ArcGraphPart::children(), gum::Set< Key >::contains(), gum::Set< Key >::empty(), gum::SequenceImplementation< Key, Gen >::exists(), gum::prm::ClassDependencyGraph< GUM_SCALAR >::get(), gum::SequenceImplementation< Key, Gen >::insert(), gum::Set< Key >::insert(), gum::prm::ClassDependencyGraph< GUM_SCALAR >::internalDag(), name(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), and gum::prm::PRMInference< GUM_SCALAR >::prm_.

Referenced by _checkElimOrder_().

Here is the call graph for this function:

Here is the caller graph for this function:

_initLiftedNodes_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_initLiftedNodes_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & trash )

private

Returns true if second can be eliminated before first.

Definition at line 300 of file SVED_tpl.h.

                                                                                       {
      PRMClass< GUM_SCALAR >& c           = const_cast< PRMClass< GUM_SCALAR >& >(i->type());
      BucketSet*              lifted_pool = new BucketSet();
      _lifted_pools_.insert(&(_bb_.requisiteNodes(i)), lifted_pool);
 
      for (const auto node: _bb_.requisiteNodes(i))
        if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(node)))
          lifted_pool->insert(const_cast< Tensor< GUM_SCALAR >* >(&(c.get(node).cpf())));
 
      NodeSet inners, outers, ignore;
 
      for (const auto& elt: *i) {
        if (_bb_.requisiteNodes(*i).exists(elt.first)) {
          if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(elt.first))) {
            if (c.isOutputNode(c.get(elt.first))) outers.insert(elt.first);
            else if (!outers.exists(elt.first)) inners.insert(elt.first);
          } else if (PRMClassElement< GUM_SCALAR >::isAggregate(c.get(elt.first))) {
            outers.insert(elt.first);
 
            // We need to put in the output_elim_order aggregator's parents
            // which are
            // innner nodes
            for (const auto par: c.containerDag().parents(elt.first))
              if (PRMClassElement< GUM_SCALAR >::isAttribute(i->type().get(par))
                  && i->type().isInnerNode(i->type().get(par))
                  && _bb_.requisiteNodes(i).exists(par)) {
                inners.erase(par);
                outers.insert(par);
              }
          }
        } else {
          ignore.insert(elt.first);
        }
      }
 
      // Now we proceed with the elimination of inner attributes
      ClassBayesNet< GUM_SCALAR > bn(c);
      List< NodeSet >             partial_ordering;
 
      if (inners.size()) partial_ordering.pushBack(inners);
 
      if (outers.size()) partial_ordering.pushBack(outers);
 
      if (ignore.size()) partial_ordering.pushBack(ignore);
 
      GUM_ASSERT(inners.size() || outers.size());
      const auto                  moralg = bn.moralGraph();
      PartialOrderedTriangulation t(&moralg, &(bn.modalities()), &partial_ordering);
 
      for (size_t idx = 0; idx < inners.size(); ++idx)
        eliminateNode(&(c.get(t.eliminationOrder()[idx]).type().variable()), *lifted_pool, trash);
 
      // If there is not only inner and input Attributes
      if (outers.size()) {
        _elim_orders_.insert(&c,
                             new std::vector< NodeId >(t.eliminationOrder().begin() + inners.size(),
                                                       t.eliminationOrder().end()));
      }
    }

References _bb_, _elim_orders_, _lifted_pools_, gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key >::erase(), gum::Set< Key >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), gum::Set< Key >::insert(), gum::prm::PRMClassElement< GUM_SCALAR >::isAggregate(), gum::prm::PRMClassElement< GUM_SCALAR >::isAttribute(), gum::prm::PRMClass< GUM_SCALAR >::isOutputNode(), gum::prm::ClassBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::ArcGraphPart::parents(), gum::List< Val >::pushBack(), gum::Set< Key >::size(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by _insertLiftedNodes_().

Here is the call graph for this function:

Here is the caller graph for this function:

_initReqSets_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_initReqSets_ ( const PRMInstance< GUM_SCALAR > * i )

private

Returns true if second can be eliminated before first.

Definition at line 455 of file SVED_tpl.h.

                                                                             {
      Set< NodeId >* attr_set = new Set< NodeId >();
      Set< NodeId >* sc_set   = new Set< NodeId >();
 
      for (const auto node: _bb_.requisiteNodes(i)) {
        switch (i->type().get(node).elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_aggregate :
          case PRMClassElement< GUM_SCALAR >::prm_attribute : {
            attr_set->insert(node);
            break;
          }
 
          case PRMClassElement< GUM_SCALAR >::prm_slotchain : {
            sc_set->insert(node);
            break;
          }
 
          default : {
            GUM_ERROR(FatalError,
                      "There should not be elements other"
                      " than PRMAttribute<GUM_SCALAR> and SlotChain.");
          }
        }
      }
 
      _req_set_.insert(&(_bb_.requisiteNodes(i)),
                       std::pair< Set< NodeId >*, Set< NodeId >* >(attr_set, sc_set));
    }

References _bb_, _req_set_, GUM_ERROR, gum::Set< Key >::insert(), gum::prm::PRMClassElement< GUM_SCALAR >::prm_aggregate, gum::prm::PRMClassElement< GUM_SCALAR >::prm_attribute, gum::prm::PRMClassElement< GUM_SCALAR >::prm_slotchain, and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by _getAttrSet_(), and _getSCSet_().

Here is the call graph for this function:

Here is the caller graph for this function:

_insertEvidence_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_insertEvidence_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool )

private

Returns true if second can be eliminated before first.

Definition at line 491 of file SVED_tpl.h.

                                                                                                 {
      for (const auto& elt: this->evidence(i))
        pool.insert(const_cast< Tensor< GUM_SCALAR >* >(elt.second));
    }

References gum::prm::PRMInference< GUM_SCALAR >::evidence(), and gum::Set< Key >::insert().

Referenced by _eliminateNodes_().

Here is the call graph for this function:

Here is the caller graph for this function:

_insertLiftedNodes_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_insertLiftedNodes_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash )

private

Returns true if second can be eliminated before first.

Definition at line 280 of file SVED_tpl.h.

                                                                                         {
      BucketSet* lifted_pool = nullptr;
 
      auto p_lp = _lifted_pools_.tryGet(&(_bb_.requisiteNodes(i)));
      if (!p_lp) {
        _initLiftedNodes_(i, trash);
        p_lp = _lifted_pools_.tryGet(&(_bb_.requisiteNodes(i)));
      }
      lifted_pool = *p_lp;
 
      for (const auto lifted_pot: *lifted_pool) {
        Tensor< GUM_SCALAR >* pot = copyTensor(i->bijection(), *lifted_pot);
        pool.insert(pot);
        trash.insert(pot);
      }
    }

References _bb_, _initLiftedNodes_(), _lifted_pools_, gum::prm::PRMInstance< GUM_SCALAR >::bijection(), gum::prm::copyTensor(), and gum::Set< Key >::insert().

Referenced by _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_reduceElimList_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::_reduceElimList_ ( const PRMInstance< GUM_SCALAR > * i, List< const PRMInstance< GUM_SCALAR > * > & elim_list, List< const PRMInstance< GUM_SCALAR > * > & reduced_list, Set< const PRMInstance< GUM_SCALAR > * > & ignore, BucketSet & pool, BucketSet & trash )

private

Returns true if second can be eliminated before first.

Definition at line 558 of file SVED_tpl.h.

                                                                                              {
      while (!elim_list.empty()) {
        if (_checkElimOrder_(i, elim_list.front())) {
          if ((!ignore.exists(elim_list.front())) && (_bb_.exists(elim_list.front()))) {
            _eliminateNodesDownward_(i, elim_list.front(), pool, trash, elim_list, ignore);
          }
        } else if (_bb_.exists(elim_list.front())) {
          reduced_list.insert(elim_list.front());
        }
 
        elim_list.popFront();
      }
    }

References _bb_, _checkElimOrder_(), and _eliminateNodesDownward_().

Referenced by _eliminateNodes_().

Here is the call graph for this function:

Here is the caller graph for this function:

_trim_()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::SVED< GUM_SCALAR >::_trim_ ( std::string_view s )

private

Returns true if second can be eliminated before first.

Definition at line 502 of file SVED_tpl.h.

                                                         {
      if (auto pos = s.find_first_of("<"); pos != std::string::npos) {
        return std::string{s.substr(0, pos)};
      }
      return std::string{s};
    }

Referenced by _checkElimOrder_().

Here is the caller graph for this function:

addEvidence()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::addEvidence ( const Chain & chain, const Tensor< GUM_SCALAR > & p )

inherited

Add an evidence to the given instance's elt.

Parameters

chain	The variable being observed.
p	The Tensor added (by copy) as evidence.

Exceptions

NotFound	Raised if elt does not belong to i.
OperationNotAllowed	Raised if p is inconsistent with elt.

Definition at line 128 of file PRMInference_tpl.h.

                                                                                {
      if (chain.first->exists(chain.second->id())) {
        if ((p.nbrDim() != 1) || (!p.contains(chain.second->type().variable())))
          GUM_ERROR(OperationNotAllowed, "illegal evidence for the given PRMAttribute.")
 
        Tensor< GUM_SCALAR >* e = new Tensor< GUM_SCALAR >();
        e->add(chain.second->type().variable());
        Instantiation i(*e);
 
        for (i.setFirst(); !i.end(); i.inc())
          e->set(i, p.get(i));
 
        PRMInference< GUM_SCALAR >::EMap& emap = _EMap_(chain.first);
 
        if (emap.exists(chain.second->id())) {
          delete emap[chain.second->id()];
          emap[chain.second->id()] = e;
        } else {
          emap.insert(chain.second->id(), e);
        }
 
        evidenceAdded_(chain);
      } else {
        GUM_ERROR(NotFound,
                  "the given PRMAttribute does not belong to this "
                  "Instance<GUM_SCALAR>.");
      }
    }

References gum::Instantiation::end(), GUM_ERROR, gum::Instantiation::inc(), and gum::Instantiation::setFirst().

Here is the call graph for this function:

clearEvidence()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::clearEvidence ( )

inherited

Remove all evidences.

Definition at line 57 of file PRMInference_tpl.h.

                                                   {
      for (const auto& elt: _evidences_) {
        for (const auto& elt2: *elt.second)
          delete elt2.second;
 
        delete elt.second;
      }
 
      _evidences_.clear();
    }

References _evidences_.

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

Here is the caller graph for this function:

evidence() [1/4]

template<GUM_Numeric GUM_SCALAR>

PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > & i )

inherited

Returns EMap of evidences over i.

Exceptions

NotFound

if i has no evidence.

Definition at line 173 of file PRMInference_tpl.h.

                                                                               {
      if (!_evidences_.exists(&i)) GUM_ERROR(NotFound, "this instance has no evidence.")
      return *(_evidences_[&i]);
    }

References _evidences_, and GUM_ERROR.

Referenced by gum::prm::SVE< GUM_SCALAR >::_eliminateNodesWithEvidence_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesWithEvidence_(), gum::prm::SVE< GUM_SCALAR >::_insertEvidence_(), gum::prm::SVED< GUM_SCALAR >::_insertEvidence_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), evidence(), gum::prm::GroundedInference< GUM_SCALAR >::evidenceAdded_(), hasEvidence(), posterior(), and gum::prm::StructuredInference< GUM_SCALAR >::posterior_().

Here is the caller graph for this function:

evidence() [2/4]

template<GUM_Numeric GUM_SCALAR>

const PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > & i ) const

inherited

Returns EMap of evidences over i.

Exceptions

NotFound

if i has no evidence.

Definition at line 180 of file PRMInference_tpl.h.

                                                                                     {
      if (!_evidences_.exists(&i)) GUM_ERROR(NotFound, "this instance has no evidence.")
      return *(_evidences_[&i]);
    }

References _evidences_, and GUM_ERROR.

evidence() [3/4]

template<GUM_Numeric GUM_SCALAR>

PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > * i )

inherited

Returns EMap of evidences over i.

Exceptions

NotFound

if i has no evidence.

Definition at line 187 of file PRMInference_tpl.h.

                                                                               {
      if (!_evidences_.exists(i)) GUM_ERROR(NotFound, "this instance has no evidence.")
      return *(_evidences_[i]);
    }

References PRMInference(), _evidences_, evidence(), and GUM_ERROR.

Here is the call graph for this function:

evidence() [4/4]

template<GUM_Numeric GUM_SCALAR>

const PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > * i ) const

inherited

Returns EMap of evidences over i.

Exceptions

NotFound

if i has no evidence.

Definition at line 194 of file PRMInference_tpl.h.

                                                                                     {
      if (!_evidences_.exists(i)) GUM_ERROR(NotFound, "this instance has no evidence.")
      return *(_evidences_[i]);
    }

References _evidences_, and GUM_ERROR.

evidenceAdded_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::evidenceAdded_ ( const Chain & chain )

overrideprotectedvirtual

See PRMInference::evidenceAdded_().

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

Definition at line 527 of file SVED_tpl.h.

                                                                                         {
      // Do nothing
    }

evidenceRemoved_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::evidenceRemoved_ ( const Chain & chain )

overrideprotectedvirtual

See PRMInference::evidenceRemoved_().

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

Definition at line 532 of file SVED_tpl.h.

                                                                                           {
      // Do nothing
    }

hasEvidence() [1/4]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( ) const

inherited

Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.

Definition at line 215 of file PRMInference_tpl.h.

                                                       {
      return (_evidences_.size() != (Size)0);
    }

References _evidences_.

hasEvidence() [2/4]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const Chain & chain ) const

inherited

Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.

Definition at line 210 of file PRMInference_tpl.h.

                                                                         {
      return (hasEvidence(chain.first)) ? evidence(chain.first).exists(chain.second->id()) : false;
    }

References evidence(), and hasEvidence().

Here is the call graph for this function:

hasEvidence() [3/4]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const PRMInstance< GUM_SCALAR > & i ) const

inherited

Returns true if i has evidence.

Definition at line 200 of file PRMInference_tpl.h.

                                                                                         {
      return _evidences_.exists(&i);
    }

References _evidences_.

Referenced by gum::prm::SVE< GUM_SCALAR >::_eliminateNodes_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodes_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesDownward_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesUpward_(), gum::prm::StructuredInference< GUM_SCALAR >::_insertNodeInElimLists_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), gum::prm::SVE< GUM_SCALAR >::_variableElimination_(), hasEvidence(), posterior(), gum::prm::StructuredInference< GUM_SCALAR >::posterior_(), and removeEvidence().

Here is the caller graph for this function:

hasEvidence() [4/4]

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const PRMInstance< GUM_SCALAR > * i ) const

inherited

Returns EMap of evidences over i.

Definition at line 205 of file PRMInference_tpl.h.

                                                                                         {
      return _evidences_.exists(i);
    }

References _evidences_.

joint()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::joint ( const std::vector< Chain > & chains, Tensor< GUM_SCALAR > & j )

inherited

Compute the joint probability of the formals attributes pointed by chains and stores it in m.

Parameters

chains	A Set of strings of the form instance.attribute.
j	An empty CPF which will be filed by the joint probability over chains.

Exceptions

NotFound	Raised if some chain in chains does not point to a formal attribute.
OperationNotAllowed	Raise if m is not empty.

Definition at line 257 of file PRMInference_tpl.h.

                                                                            {
      if (j.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Tensor is not empty.") }
 
      for (auto chain = chains.begin(); chain != chains.end(); ++chain) {
        j.add(chain->second->type().variable());
      }
 
      joint_(chains, j);
    }

References GUM_ERROR, and joint_().

Here is the call graph for this function:

joint_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::joint_ ( const std::vector< Chain > & queries, Tensor< GUM_SCALAR > & j )

overrideprotectedvirtual

See PRMInference::joint_().

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

Definition at line 450 of file SVED_tpl.h.

                                                                                              {
      GUM_ERROR(FatalError, "Not implemented.")
    }

References GUM_ERROR.

name()

template<GUM_Numeric GUM_SCALAR>

std::string gum::prm::SVED< GUM_SCALAR >::name ( ) const

overridevirtual

Returns the name of the current inference algorithm.

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

Definition at line 578 of file SVED_tpl.h.

                                             {
      return "SVED";
    }

Referenced by _initElimOrder_().

Here is the caller graph for this function:

posterior()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::posterior ( const Chain & chain, Tensor< GUM_SCALAR > & m )

inherited

Compute the posterior of the formal attribute pointed by chain and stores it in m.

Parameters

chain	A string of the form instance.attribute.
m	An empty CPF which will be filed by the posterior of chain.

Exceptions

NotFound	Raised if chain is invalid.
TypeError	Raised if chain does not point to an PRMAttribute<GUM_SCALAR>.
OperationNotAllowed	Raise if m is not empty.

Definition at line 231 of file PRMInference_tpl.h.

                                                             {
      if (m.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Tensor is not empty.") }
 
      if (hasEvidence(chain)) {
        m.add(chain.second->type().variable());
        const Tensor< GUM_SCALAR >& e = *(evidence(chain.first)[chain.second->id()]);
        Instantiation               i(m), j(e);
 
        for (i.setFirst(), j.setFirst(); !i.end(); i.inc(), j.inc())
          m.set(i, e.get(j));
      } else {
        if (chain.second != &(chain.first->get(chain.second->safeName()))) {
          typename PRMInference< GUM_SCALAR >::Chain good_chain
              = std::make_pair(chain.first, &(chain.first->get(chain.second->safeName())));
          m.add(good_chain.second->type().variable());
          posterior_(good_chain, m);
        } else {
          m.add(chain.second->type().variable());
          posterior_(chain, m);
        }
      }
    }

References gum::prm::PRMInstance< GUM_SCALAR >::end(), evidence(), GUM_ERROR, hasEvidence(), gum::Instantiation::inc(), and gum::Instantiation::setFirst().

Here is the call graph for this function:

posterior_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVED< GUM_SCALAR >::posterior_ ( const Chain & chain, Tensor< GUM_SCALAR > & m )

overrideprotectedvirtual

See PRMInference::posterior_().

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

Definition at line 400 of file SVED_tpl.h.

                                                                                   {
      const PRMInstance< GUM_SCALAR >*  i   = chain.first;
      const PRMAttribute< GUM_SCALAR >* elt = chain.second;
      SVED< GUM_SCALAR >::BucketSet     pool, trash;
      _bb_.compute(i, elt->id());
      _eliminateNodes_(i, elt->id(), pool, trash);
 
      std::vector< const Tensor< GUM_SCALAR >* > result;
      for (auto pot: pool) {
        if (pot->contains(*(m.variablesSequence().atPos(0)))) result.push_back(pot);
      }
 
      while (result.size() > 1) {
        const auto& p1 = *(result.back());
        result.pop_back();
        const auto& p2 = *(result.back());
        result.pop_back();
        auto mult = new Tensor< GUM_SCALAR >(p1 * p2);
        result.push_back(mult);
        trash.insert(mult);
      }
 
      m = *(result.back());
      m.normalize();
 
      GUM_ASSERT(m.nbrDim() == (Size)1);
 
      // cleaning up the mess
      for (const auto pot: trash)
        delete pot;
 
      for (const auto& elt: _lifted_pools_)
        delete elt.second;
 
      _lifted_pools_.clear();
 
      for (const auto& elt: _req_set_) {
        delete elt.second.first;
        delete elt.second.second;
      }
 
      _req_set_.clear();
 
      for (const auto& elt: _elim_orders_)
        delete elt.second;
 
      _elim_orders_.clear();
    }

References _bb_, _elim_orders_, _eliminateNodes_(), _lifted_pools_, _req_set_, gum::prm::PRMClassElement< GUM_SCALAR >::id(), and gum::Set< Key >::insert().

Here is the call graph for this function:

removeEvidence()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::removeEvidence ( const Chain & chain )

inherited

Remove evidence on the given instance's elt.

Parameters

chain

The variable being observed.

Exceptions

NotFound	Raised if the given names are not found.
TypeError	Raised if the elt is not an PRMAttribute<GUM_SCALAR>.

Definition at line 220 of file PRMInference_tpl.h.

                                                                      {
      if (hasEvidence(chain.first)) {
        if (_EMap_(chain.first).exists(chain.second->id())) {
          evidenceRemoved_(chain);
          delete _EMap_(chain.first)[chain.second->id()];
          _EMap_(chain.first).erase(chain.second->id());
        }
      }
    }

References _EMap_(), evidenceRemoved_(), and hasEvidence().

Here is the call graph for this function:

Member Data Documentation

_bb_

template<GUM_Numeric GUM_SCALAR>

StructuredBayesBall< GUM_SCALAR > gum::prm::SVED< GUM_SCALAR >::_bb_

private

Definition at line 138 of file SVED.h.

Referenced by SVED(), _eliminateNodes_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), _eliminateNodesWithEvidence_(), _getAttrSet_(), _getSCSet_(), _initLiftedNodes_(), _initReqSets_(), _insertLiftedNodes_(), _reduceElimList_(), and posterior_().

_class_elim_order_

template<GUM_Numeric GUM_SCALAR>

Sequence< std::string >* gum::prm::SVED< GUM_SCALAR >::_class_elim_order_

private

Definition at line 136 of file SVED.h.

Referenced by SVED(), ~SVED(), _checkElimOrder_(), and _initElimOrder_().

_elim_orders_

template<GUM_Numeric GUM_SCALAR>

HashTable< const PRMClass< GUM_SCALAR >*, std::vector< NodeId >* > gum::prm::SVED< GUM_SCALAR >::_elim_orders_

private

Definition at line 127 of file SVED.h.

Referenced by ~SVED(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), _getElimOrder_(), _initLiftedNodes_(), and posterior_().

_evidences_

template<GUM_Numeric GUM_SCALAR>

HashTable< const PRMInstance< GUM_SCALAR >*, EMap* > gum::prm::PRMInference< GUM_SCALAR >::_evidences_

privateinherited

Mapping of evidence over PRMInstance<GUM_SCALAR>'s nodes.

Definition at line 245 of file PRMInference.h.

Referenced by PRMInference(), _EMap_(), clearEvidence(), evidence(), evidence(), evidence(), evidence(), hasEvidence(), hasEvidence(), and hasEvidence().

_lifted_pools_

template<GUM_Numeric GUM_SCALAR>

HashTable< const Set< NodeId >*, BucketSet* > gum::prm::SVED< GUM_SCALAR >::_lifted_pools_

private

The Set<NodeId> returned by StructuredBayesBall<GUM_SCALAR> is unique for each family of instances with the same requisite set (thus the same lifted tensors).

Definition at line 134 of file SVED.h.

Referenced by _initLiftedNodes_(), _insertLiftedNodes_(), and posterior_().

_req_set_

template<GUM_Numeric GUM_SCALAR>

HashTable< const Set< NodeId >*, std::pair< Set< NodeId >*, Set< NodeId >* > > gum::prm::SVED< GUM_SCALAR >::_req_set_

private

First pair -> requisite Attributes Second pair -> requisite SlotChains.

Definition at line 142 of file SVED.h.

Referenced by _getAttrSet_(), _getSCSet_(), _initReqSets_(), and posterior_().

prm_

template<GUM_Numeric GUM_SCALAR>

PRM< GUM_SCALAR > const* gum::prm::PRMInference< GUM_SCALAR >::prm_

protectedinherited

The PRM<GUM_SCALAR> on which inference is done.

Definition at line 224 of file PRMInference.h.

Referenced by PRMInference(), PRMInference(), gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference(), gum::prm::SVE< GUM_SCALAR >::_initElimOrder_(), gum::prm::SVED< GUM_SCALAR >::_initElimOrder_(), operator=(), and gum::prm::StructuredInference< GUM_SCALAR >::operator=().

sys_

template<GUM_Numeric GUM_SCALAR>

PRMSystem< GUM_SCALAR > const* gum::prm::PRMInference< GUM_SCALAR >::sys_

protectedinherited

The Model on which inference is done.

Definition at line 227 of file PRMInference.h.

Referenced by PRMInference(), PRMInference(), gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), operator=(), gum::prm::StructuredInference< GUM_SCALAR >::operator=(), and gum::prm::StructuredInference< GUM_SCALAR >::searchPatterns().

---

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

• agrum/PRM/inference/SVED.h
• agrum/PRM/inference/SVED_tpl.h