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

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

#include <agrum/PRM/SVE.h>

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

Collaboration diagram for gum::prm::SVE< 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.
	SVE (const PRM< GUM_SCALAR > &prm, const PRMSystem< GUM_SCALAR > &system)
	Default Constructor.
	~SVE () 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, Set< const PRMInstance< GUM_SCALAR > * > &eliminated)
	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, Set< const PRMInstance< GUM_SCALAR > * > &eliminated)
	Returns true if second can be eliminated before first.
void	_eliminateNodesWithEvidence_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash, Set< NodeId > *delayedVars=0)
	Returns true if second can be eliminated before first.
void	_eliminateDelayedVariables_ (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.
void	_variableElimination_ (const PRMInstance< GUM_SCALAR > *i, BucketSet &pool, BucketSet &trash, Set< NodeId > *delayedVars=0)
	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.
void	_addDelayedVariable_ (const PRMInstance< GUM_SCALAR > *i, const PRMInstance< GUM_SCALAR > *j, NodeId id)
	When there is a loop in the references some variable elimination must be delayed, this methods add such variable to delayedVariables to keep track of them.
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 PRMClass< GUM_SCALAR > &c)
	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 PRMClass< GUM_SCALAR > *, BucketSet * >	_lifted_pools_
Sequence< std::string > *	_class_elim_order_
HashTable< const PRMInstance< GUM_SCALAR > *, gum::VariableSet * >	_delayedVariables_
HashTable< std::string, Size >	_delayedVariablesCounters_
	Some variable must be delayed for more than one PRMInstance<GUM_SCALAR>, when the delayed variable counter reach 0 it can be eliminated.
BucketSet	_lifted_trash_

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

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

Definition at line 74 of file SVE.h.

Member Typedef Documentation

ArraySetIterator

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 125 of file SVE.h.

BucketSet

template<GUM_Numeric GUM_SCALAR>

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

private

Code alias.

Definition at line 123 of file SVE.h.

BucketSetIterator

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 124 of file SVE.h.

Chain

template<GUM_Numeric GUM_SCALAR>

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

protected

Code alias.

Definition at line 105 of file SVE.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

SVE()

template<GUM_Numeric GUM_SCALAR>

gum::prm::SVE< GUM_SCALAR >::SVE	(	const PRM< GUM_SCALAR > &	prm,
		const PRMSystem< GUM_SCALAR > &	system )

Default Constructor.

Definition at line 623 of file SVE_tpl.h.

                                                                                              :
        PRMInference< GUM_SCALAR >(prm, system), _class_elim_order_(0) {
      GUM_CONSTRUCTOR(SVE);
    }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

~SVE()

template<GUM_Numeric GUM_SCALAR>

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

override

Destructor.

Definition at line 128 of file SVE_tpl.h.

                            {
      GUM_DESTRUCTOR(SVE);
 
      for (const auto& elt: _elim_orders_)
        delete elt.second;
 
      for (const auto& elt: _lifted_pools_)
        delete elt.second;
 
      if (_class_elim_order_ != nullptr) delete _class_elim_order_;
 
      for (const auto trash: _lifted_trash_)
        delete trash;
 
      for (auto set: _delayedVariables_)
        delete set.second;
    }

References SVE(), _class_elim_order_, _delayedVariables_, _elim_orders_, _lifted_pools_, and _lifted_trash_.

Here is the call graph for this function:

Member Function Documentation

_addDelayedVariable_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVE< GUM_SCALAR >::_addDelayedVariable_ ( const PRMInstance< GUM_SCALAR > * i, const PRMInstance< GUM_SCALAR > * j, NodeId id )

private

When there is a loop in the references some variable elimination must be delayed, this methods add such variable to delayedVariables to keep track of them.

Parameters

i	An PRMInstance<GUM_SCALAR> with a child of j->get(id).
j	The PRMInstance<GUM_SCALAR> with the delayed variable.
id	The NodeId of the delayed variable.

Definition at line 674 of file SVE_tpl.h.

                                                                                      {
      auto p_dv = _delayedVariables_.tryGet(i);
      if (!p_dv) {
        _delayedVariables_.insert(i, new gum::VariableSet());
        p_dv = _delayedVariables_.tryGet(i);
      }
      try {
        (*p_dv)->insert(&(j->get(id).type().variable()));
      } catch (DuplicateElement const&) {
        // happends if j->get(id) is parent of more than one variable in i
      }
 
      static std::string dot = ".";
 
      auto key = j->name() + dot + j->get(id).safeName();
      if (auto p_cnt = _delayedVariablesCounters_.tryGet(key)) {
        *p_cnt += 1;
      } else {
        _delayedVariablesCounters_.insert(key, 1);
      }
    }

References _delayedVariables_, _delayedVariablesCounters_, gum::prm::PRMInstance< GUM_SCALAR >::get(), and gum::prm::PRMObject::name().

Referenced by _eliminateNodes_(), and _eliminateNodesDownward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_checkElimOrder_()

template<GUM_Numeric GUM_SCALAR>

bool gum::prm::SVE< 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 648 of file SVE_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_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

Here is the caller graph for this function:

_eliminateDelayedVariables_()

template<GUM_Numeric GUM_SCALAR>

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

private

Returns true if second can be eliminated before first.

Definition at line 230 of file SVE_tpl.h.

                                                                                                {
      Set< Tensor< GUM_SCALAR >* > toRemove;
 
      for (const auto var: *_delayedVariables_[i]) {
        MultiDimBucket< GUM_SCALAR >* bucket = new MultiDimBucket< GUM_SCALAR >();
 
        for (const auto pot: pool)
          if (pot->contains(*var)) {
            bucket->add(*pot);
            toRemove.insert(pot);
          }
 
        for (const auto pot: toRemove)
          pool.erase(pot);
 
        for (const auto other: bucket->allVariables())
          if (other != var) bucket->add(*other);
 
        Tensor< GUM_SCALAR >* bucket_pot = new Tensor< GUM_SCALAR >(bucket);
        trash.insert(bucket_pot);
        pool.insert(bucket_pot);
      }
    }

References _delayedVariables_, gum::MultiDimBucket< GUM_ELEMENT >::add(), gum::MultiDimBucket< GUM_ELEMENT >::allVariables(), and gum::Set< Key >::insert().

Referenced by _eliminateNodes_(), and _variableElimination_().

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::SVE< 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 147 of file SVE_tpl.h.

                                                                                     {
      Set< const PRMInstance< GUM_SCALAR >* > ignore, eliminated;
      Set< NodeId >                           delayedVars;
      // Downward elimination
      List< const PRMInstance< GUM_SCALAR >* > elim_list;
      ignore.insert(query);
 
      for (auto iter = query->beginInvRef(); iter != query->endInvRef(); ++iter) {
        for (auto child = (*(iter.val())).begin(); child != (*(iter.val())).end(); ++child) {
          if (!ignore.exists(child->first)) {
            _eliminateNodesDownward_(query,
                                     child->first,
                                     pool,
                                     trash,
                                     elim_list,
                                     ignore,
                                     eliminated);
          } else if (!eliminated.exists(child->first)) {
            _addDelayedVariable_(child->first, query, iter.key());
            delayedVars.insert(iter.key());
          }
        }
      }
 
      // 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 (auto attr = query->begin(); attr != query->end(); ++attr) {
        pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >((*(attr.val())).cpf())));
      }
 
      for (size_t idx = 0; idx < t.eliminationOrder().size(); ++idx) {
        if ((t.eliminationOrder()[idx] != node)
            && (!delayedVars.exists(t.eliminationOrder()[idx]))) {
          auto        var_id = t.eliminationOrder()[idx];
          const auto& var    = bn.variable(var_id);
          elim_order.push_back(&var);
        }
      }
 
      eliminateNodes(elim_order, pool, trash);
 
      // Eliminating delayed variables, if any
      if (_delayedVariables_.exists(query)) { _eliminateDelayedVariables_(query, pool, trash); }
 
      eliminated.insert(query);
      // Eliminating instance in elim_list
      List< const PRMInstance< GUM_SCALAR >* > tmp_list;
 
      while (!elim_list.empty()) {
        if (_checkElimOrder_(query, elim_list.front())) {
          if (!ignore.exists(elim_list.front())) {
            _eliminateNodesDownward_(query,
                                     elim_list.front(),
                                     pool,
                                     trash,
                                     elim_list,
                                     ignore,
                                     eliminated);
          }
        } else {
          tmp_list.insert(elim_list.front());
        }
 
        elim_list.popFront();
      }
 
      // Upward elimination
      for (const auto chain: query->type().slotChains())
        for (const auto parent: query->getInstances(chain->id()))
          if (!ignore.exists(parent))
            _eliminateNodesUpward_(parent, pool, trash, tmp_list, ignore, eliminated);
    }

References _addDelayedVariable_(), _checkElimOrder_(), _delayedVariables_, _eliminateDelayedVariables_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), _insertEvidence_(), gum::prm::PRMInstance< GUM_SCALAR >::begin(), gum::prm::PRMInstance< GUM_SCALAR >::beginInvRef(), gum::prm::eliminateNodes(), gum::StaticTriangulation::eliminationOrder(), gum::List< Val >::empty(), gum::prm::PRMInstance< GUM_SCALAR >::end(), gum::prm::PRMInstance< GUM_SCALAR >::endInvRef(), gum::Set< Key >::exists(), gum::List< Val >::front(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::List< Val >::insert(), gum::Set< Key >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::List< Val >::popFront(), gum::prm::PRMInstance< GUM_SCALAR >::type(), 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::SVE< 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, Set< const PRMInstance< GUM_SCALAR > * > & eliminated )

private

Returns true if second can be eliminated before first.

Definition at line 257 of file SVE_tpl.h.

                                                              {
      Set< NodeId > delayedVars;
      ignore.insert(i);
      // Calling elimination over child instance
      List< const PRMInstance< GUM_SCALAR >* > my_list;
 
      for (auto iter = i->beginInvRef(); iter != i->endInvRef(); ++iter) {
        for (auto child = (*(iter.val())).begin(); child != (*(iter.val())).end(); ++child) {
          if (!ignore.exists(child->first)) {
            _eliminateNodesDownward_(i, child->first, pool, trash, my_list, ignore, eliminated);
          } else if (!eliminated.exists(child->first)) {
            _addDelayedVariable_(child->first, i, iter.key());
            delayedVars.insert(iter.key());
          }
        }
      }
 
      // Eliminating all nodes in current instance
      _variableElimination_(i, pool, trash, (delayedVars.empty() ? 0 : &delayedVars));
      eliminated.insert(i);
 
      // Calling elimination over child's parents
      for (const auto node: my_list) {
        if (_checkElimOrder_(i, node) && (node != from)) {
          if (!ignore.exists(node)) {
            _eliminateNodesDownward_(i, node, pool, trash, elim_list, ignore, eliminated);
          }
        } else if (node != from) {
          elim_list.insert(node);
        }
      }
 
      // Adding parents instance to elim_list
      for (const auto chain: i->type().slotChains()) {
        for (const auto inst: i->getInstances(chain->id())) {
          if (inst != from) { elim_list.insert(inst); }
        }
      }
    }

References _addDelayedVariable_(), _checkElimOrder_(), _eliminateNodesDownward_(), _variableElimination_(), gum::prm::PRMInstance< GUM_SCALAR >::beginInvRef(), gum::Set< Key >::empty(), gum::prm::PRMInstance< GUM_SCALAR >::endInvRef(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::Set< Key >::insert(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

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

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::SVE< 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, Set< const PRMInstance< GUM_SCALAR > * > & eliminated )

private

Returns true if second can be eliminated before first.

Definition at line 343 of file SVE_tpl.h.

                                                              {
      // Downward elimination
      ignore.insert(i);
 
      for (auto iter = i->beginInvRef(); iter != i->endInvRef(); ++iter) {
        for (auto child = (*(iter.val())).begin(); child != (*(iter.val())).end(); ++child) {
          if (!ignore.exists(child->first)) {
            _eliminateNodesDownward_(i, child->first, pool, trash, elim_list, ignore, eliminated);
          }
        }
      }
 
      // Eliminating all nodes in i instance
      _variableElimination_(i, pool, trash);
      eliminated.insert(i);
      // 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())) {
            _eliminateNodesDownward_(i,
                                     elim_list.front(),
                                     pool,
                                     trash,
                                     elim_list,
                                     ignore,
                                     eliminated);
          }
        } else {
          tmp_list.insert(elim_list.front());
        }
 
        elim_list.popFront();
      }
 
      // Upward elimination
      for (const auto chain: i->type().slotChains()) {
        for (const auto parent: i->getInstances(chain->id())) {
          if (!ignore.exists(parent)) {
            _eliminateNodesUpward_(parent, pool, trash, tmp_list, ignore, eliminated);
          }
        }
      }
    }

References _checkElimOrder_(), _eliminateNodesDownward_(), _eliminateNodesUpward_(), _variableElimination_(), gum::prm::PRMInstance< GUM_SCALAR >::beginInvRef(), gum::prm::PRMInstance< GUM_SCALAR >::endInvRef(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::List< Val >::insert(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

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::SVE< GUM_SCALAR >::_eliminateNodesWithEvidence_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash, Set< NodeId > * delayedVars = 0 )

private

Returns true if second can be eliminated before first.

Definition at line 396 of file SVE_tpl.h.

                                                                                     {
      // First we check if evidences are on inner nodes
      bool inner = false;
 
      for (const auto& elt: this->evidence(i)) {
        inner
            = i->type().isInputNode(i->get(elt.first)) || i->type().isInnerNode(i->get(elt.first));
 
        if (inner) { break; }
      }
 
      // Evidence on inner nodes
      if (inner) {
        BucketSet tmp_pool;
        _insertEvidence_(i, tmp_pool);
 
        // We need a local to not eliminate queried inner nodes of the same
        // class
        for (const auto& elt: *i) {
          tmp_pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >(elt.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();
        // Removing Output nodes of elimination order
        std::vector< const DiscreteVariable* > inner_elim_order;
        std::vector< const DiscreteVariable* > output_elim_order;
 
        for (size_t idx = 0; idx < full_elim_order.size(); ++idx) {
          auto        var_id = full_elim_order[idx];
          const auto& var    = bn.variable(var_id);
 
          if (!i->type().isOutputNode(i->get(full_elim_order[idx]))) {
            inner_elim_order.push_back(&var);
          } else if (delayedVars != nullptr) {
            if (!delayedVars->exists(full_elim_order[idx])) { output_elim_order.push_back(&var); }
          } else {
            output_elim_order.push_back(&var);
          }
        }
 
        eliminateNodes(inner_elim_order, tmp_pool, trash);
 
        // Now we add the new tensors in pool and eliminate output nodes
        for (const auto pot: tmp_pool)
          pool.insert(pot);
 
        if (!output_elim_order.empty()) eliminateNodes(output_elim_order, pool, trash);
 
      } else {
        InstanceBayesNet< GUM_SCALAR > bn(*i);
        _insertEvidence_(i, pool);
        _insertLiftedNodes_(i, pool, trash);
 
        for (const auto agg: i->type().aggregates())
          pool.insert(_getAggTensor_(i, agg));
 
        if (auto p_eo2 = _elim_orders_.tryGet(&(i->type())); !p_eo2) {
          GUM_ERROR(FatalError, "there should be at least one node here.")
        } else {
          std::vector< const DiscreteVariable* > elim;
 
          for (auto iter = (*p_eo2)->begin(); iter != (*p_eo2)->end(); ++iter) {
            const auto& var = bn.variable(*iter);
            if (delayedVars != nullptr) {
              if (!delayedVars->exists(*iter)) { elim.push_back(&var); }
            } else {
              elim.push_back(&var);
            }
          }
 
          eliminateNodes(elim, pool, trash);
        }
      }
    }

References _elim_orders_, _getAggTensor_(), _insertEvidence_(), _insertLiftedNodes_(), gum::prm::eliminateNodes(), gum::StaticTriangulation::eliminationOrder(), gum::prm::PRMInference< GUM_SCALAR >::evidence(), gum::Set< Key >::exists(), gum::prm::PRMInstance< GUM_SCALAR >::get(), GUM_ERROR, gum::Set< Key >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by _variableElimination_().

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::SVE< 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 658 of file SVE_tpl.h.

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

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

Referenced by _eliminateNodesWithEvidence_(), and _variableElimination_().

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::SVE< GUM_SCALAR >::_getElimOrder_ ( const PRMClass< GUM_SCALAR > & c )

private

Returns true if second can be eliminated before first.

Definition at line 635 of file SVE_tpl.h.

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

References _elim_orders_.

_initElimOrder_()

template<GUM_Numeric GUM_SCALAR>

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

private

Returns true if second can be eliminated before first.

Definition at line 548 of file SVE_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::SVE< GUM_SCALAR >::_initLiftedNodes_ ( const PRMClass< GUM_SCALAR > & c )

private

Returns true if second can be eliminated before first.

Definition at line 498 of file SVE_tpl.h.

                                                                             {
      BucketSet* lifted_pool = new BucketSet();
      _lifted_pools_.insert(&c, lifted_pool);
      NodeSet inners, outers;
 
      for (const auto node: c.containerDag().nodes())
        if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(node))) {
          if (c.isOutputNode(c.get(node))) outers.insert(node);
          else if (!outers.exists(node)) inners.insert(node);
 
          lifted_pool->insert(const_cast< Tensor< GUM_SCALAR >* >(&(c.get(node).cpf())));
        } else if (PRMClassElement< GUM_SCALAR >::isAggregate(c.get(node))) {
          outers.insert(node);
 
          // We need to put in the output_elim_order aggregator's parents which
          // are
          // innner nodes
          for (const auto par: c.containerDag().parents(node))
            if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(par))
                && c.isInnerNode(c.get(par))) {
              inners.erase(par);
              outers.insert(par);
            }
        }
 
      // Now we proceed with the elimination of inner attributes
      ClassBayesNet< GUM_SCALAR > bn(c);
      List< NodeSet >             partial_ordering;
 
      if (inners.size()) partial_ordering.push_back(inners);
 
      if (outers.size()) partial_ordering.push_back(outers);
 
      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,
                      _lifted_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 _elim_orders_, _lifted_pools_, _lifted_trash_, 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::PRMClassElementContainer< GUM_SCALAR >::isInnerNode(), gum::prm::PRMClass< GUM_SCALAR >::isOutputNode(), gum::prm::ClassBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::NodeGraphPart::nodes(), gum::ArcGraphPart::parents(), gum::List< Val >::push_back(), and gum::Set< Key >::size().

Referenced by _insertLiftedNodes_().

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::SVE< GUM_SCALAR >::_insertEvidence_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool )

private

Returns true if second can be eliminated before first.

Definition at line 629 of file SVE_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_(), and _eliminateNodesWithEvidence_().

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::SVE< 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 478 of file SVE_tpl.h.

                                                                                        {
      SVE< GUM_SCALAR >::BucketSet* lifted_pool = 0;
 
      auto p_lp = _lifted_pools_.tryGet(&(i->type()));
      if (!p_lp) {
        _initLiftedNodes_(i->type());
        p_lp = _lifted_pools_.tryGet(&(i->type()));
      }
      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 _initLiftedNodes_(), _lifted_pools_, gum::prm::PRMInstance< GUM_SCALAR >::bijection(), gum::prm::copyTensor(), gum::Set< Key >::insert(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by _eliminateNodesWithEvidence_(), and _variableElimination_().

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::SVE< GUM_SCALAR >::_trim_ ( std::string_view s )

private

Returns true if second can be eliminated before first.

Definition at line 640 of file SVE_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:

_variableElimination_()

template<GUM_Numeric GUM_SCALAR>

void gum::prm::SVE< GUM_SCALAR >::_variableElimination_ ( const PRMInstance< GUM_SCALAR > * i, BucketSet & pool, BucketSet & trash, Set< NodeId > * delayedVars = 0 )

private

Returns true if second can be eliminated before first.

Definition at line 305 of file SVE_tpl.h.

                                                                                                {
      if (this->hasEvidence(i)) {
        _eliminateNodesWithEvidence_(i, pool, trash, delayedVars);
      } else {
        _insertLiftedNodes_(i, pool, trash);
 
        for (const auto agg: i->type().aggregates())
          pool.insert(_getAggTensor_(i, agg));
 
        if (auto p_eo = _elim_orders_.tryGet(&(i->type()))) {
          InstanceBayesNet< GUM_SCALAR > bn(*i);
 
          std::vector< const DiscreteVariable* > elim;
 
          for (const auto node: *(*p_eo)) {
            const auto& var = bn.variable(node);
            if (delayedVars != nullptr) {
              if (!delayedVars->exists(node)) {
                const auto& var = bn.variable(node);
                elim.push_back(&var);
              }
            } else {
              elim.push_back(&var);
            }
          }
 
          eliminateNodes(elim, pool, trash);
        }
      }
 
      // Eliminating delayed variables, if any
      if (_delayedVariables_.exists(i)) { _eliminateDelayedVariables_(i, pool, trash); }
    }

References _delayedVariables_, _elim_orders_, _eliminateDelayedVariables_(), _eliminateNodesWithEvidence_(), _getAggTensor_(), _insertLiftedNodes_(), gum::prm::eliminateNodes(), gum::Set< Key >::exists(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::Set< Key >::insert(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by _eliminateNodesDownward_(), and _eliminateNodesUpward_().

Here is the call graph for this function:

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::SVE< GUM_SCALAR >::evidenceAdded_ ( const Chain & chain )

overrideprotectedvirtual

See PRMInference<GUM_SCALAR>::evidenceAdded_().

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

Definition at line 664 of file SVE_tpl.h.

                                                             {
      // Do nothing
    }

evidenceRemoved_()

template<GUM_Numeric GUM_SCALAR>

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

overrideprotectedvirtual

See PRMInference<GUM_SCALAR>::evidenceRemoved_().

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

Definition at line 669 of file SVE_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::SVE< GUM_SCALAR >::joint_ ( const std::vector< Chain > & queries, Tensor< GUM_SCALAR > & j )

overrideprotectedvirtual

See PRMInference<GUM_SCALAR>::joint_().

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

Definition at line 618 of file SVE_tpl.h.

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

References GUM_ERROR.

name()

template<GUM_Numeric GUM_SCALAR>

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

overridevirtual

Returns the name of the current inference algorithm.

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

Definition at line 699 of file SVE_tpl.h.

                                            {
      return "SVE";
    }

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::SVE< GUM_SCALAR >::posterior_ ( const Chain & chain, Tensor< GUM_SCALAR > & m )

overrideprotectedvirtual

See PRMInference<GUM_SCALAR>::posterior_().

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

Definition at line 586 of file SVE_tpl.h.

                                                                                  {
      const PRMInstance< GUM_SCALAR >*  i   = chain.first;
      const PRMAttribute< GUM_SCALAR >* elt = chain.second;
      SVE< GUM_SCALAR >::BucketSet      pool, trash;
 
      _eliminateNodes_(i, elt->id(), pool, trash);
 
      std::vector< Tensor< GUM_SCALAR >* > result;
 
      for (const auto pot: pool) {
        if (pot->contains(elt->type().variable())) { result.push_back(pot); }
      }
 
      while (result.size() > 1) {
        auto& p1 = *(result.back());
        result.pop_back();
        auto& p2 = *(result.back());
        result.pop_back();
        auto mult = new Tensor< GUM_SCALAR >(p1 * p2);
        trash.insert(mult);
        result.push_back(mult);
      }
 
      m = *(result.back());
      m.normalize();
 
      for (const auto pot: trash) {
        delete pot;
      }
    }

References _eliminateNodes_(), gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::Set< Key >::insert(), gum::prm::PRMAttribute< GUM_SCALAR >::type(), and gum::prm::PRMType::variable().

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

_class_elim_order_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 131 of file SVE.h.

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

_delayedVariables_

template<GUM_Numeric GUM_SCALAR>

HashTable< const PRMInstance< GUM_SCALAR >*, gum::VariableSet* > gum::prm::SVE< GUM_SCALAR >::_delayedVariables_

private

Definition at line 133 of file SVE.h.

Referenced by ~SVE(), _addDelayedVariable_(), _eliminateDelayedVariables_(), _eliminateNodes_(), and _variableElimination_().

_delayedVariablesCounters_

template<GUM_Numeric GUM_SCALAR>

HashTable< std::string, Size > gum::prm::SVE< GUM_SCALAR >::_delayedVariablesCounters_

private

Some variable must be delayed for more than one PRMInstance<GUM_SCALAR>, when the delayed variable counter reach 0 it can be eliminated.

Definition at line 140 of file SVE.h.

Referenced by _addDelayedVariable_().

_elim_orders_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 127 of file SVE.h.

Referenced by ~SVE(), _eliminateNodesWithEvidence_(), _getElimOrder_(), _initLiftedNodes_(), and _variableElimination_().

_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 PRMClass< GUM_SCALAR >*, BucketSet* > gum::prm::SVE< GUM_SCALAR >::_lifted_pools_

private

Definition at line 129 of file SVE.h.

Referenced by ~SVE(), _initLiftedNodes_(), and _insertLiftedNodes_().

_lifted_trash_

template<GUM_Numeric GUM_SCALAR>

BucketSet gum::prm::SVE< GUM_SCALAR >::_lifted_trash_

private

Definition at line 142 of file SVE.h.

Referenced by ~SVE(), and _initLiftedNodes_().

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/SVE.h
• agrum/PRM/inference/SVE_tpl.h