namespace for all probabilistic relational models entities More...

Namespaces
namespace	gspan
namespace	o3prm
namespace	o3prmr

Classes
class	ClassBayesNet
	This class decorates a gum::prm::Class<GUM_SCALAR> has an IBaseBayesNet. More...
class	ClassDependencyGraph
	This class represent the dependencies of all classes in a PRM<GUM_SCALAR>. More...
class	PRMAggregate
class	PRMAttribute
	PRMAttribute is a member of a Class in a PRM. More...
class	PRMInterface
	An PRMInterface is implemented by a Class<GUM_SCALAR> and defines a set of PRMReferenceSlot<GUM_SCALAR> and PRMAttribute<GUM_SCALAR> which the implementing Class<GUM_SCALAR> must contain. More...
class	PRMClass
	A PRMClass is an object of a PRM representing a fragment of a Bayesian network which can be instantiated in PRMInstance. More...
struct	ParamScopeData
class	PRMClassElement
	Abstract class representing an element of PRM class. More...
class	PRMClassElementContainer
	<agrum/PRM/classElementContainer.h> More...
class	PRMFormAttribute
	<agrum/PRM/elements/formAttribute.h> More...
class	PRMFuncAttribute
	<agrum/PRM/elements/funcAttribute.h> More...
class	PRMInstance
	An PRMInstance is a Bayesian network fragment defined by a Class and used in a PRMSystem. More...
class	PRMObject
	Abstract base class for any element defined in a PRM. More...
class	PRMSlotChain
	A PRMSlotChain represents a sequence of gum::prm::PRMClassElement<GUM_SCALAR> where the n-1 first gum::prm::PRMClassElement<GUM_SCALAR> are gum::prm::PRMReferenceSlot and the last gum::prm::PRMClassElement<GUM_SCALAR> an gum::prm::PRMAttribute or an gum::prm::PRMAggregate. More...
class	PRMReferenceSlot
	A PRMReferenceSlot represent a relation between two PRMClassElementContainer. More...
class	PRMSystem
	A PRMSystem is a container of PRMInstance and describe a relational skeleton. More...
class	PRMParameter
	PRMParameter is a member of a Class in a PRM. More...
class	PRMScalarAttribute
	<agrum/PRM/elements/scalarAttribute.h> More...
class	PRMFactory
	Factory which builds a PRM<GUM_SCALAR>. More...
class	PRMType
	This is a decoration of the DiscreteVariable class. More...
class	ClusteredLayerGenerator
	<agrum/PRM/generator/clusteredLayerGenerator.h> More...
class	LayerGenerator
	<agrum/PRM/generator/layerGenerator.h> More...
class	NameGenerator
	This is a name generator for classes, types, systems, instances and class elements. More...
class	PRMGenerator
	This class is the base class to all PRM generators. More...
class	GSpan
	This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference. More...
class	GroundedInference
	<agrum/PRM/groundedInference.h> More...
class	PRMInference
	This abstract class is used as base class for all inference class on PRM<GUM_SCALAR>. More...
class	StructuredBayesBall
	<agrum/PRM/structuredBayesBall.h> More...
class	StructuredInference
	<agrum/PRM/structuredInference.h> More...
class	SVE
	This class is an implementation of the Structured Variable Elimination algorithm on PRM<GUM_SCALAR>. More...
class	SVED
	This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>. More...
class	InstanceBayesNet
	This class decorates an PRMInstance<GUM_SCALAR> as an IBaseBayesNet. More...
class	IPRMFactory
	non-template interface-like parent for every PRM Factory More...
class	PRM
	This class represents a Probabilistic Relational PRMSystem<GUM_SCALAR>. More...

Typedefs
using	prm_float = float
	PRMType for real numbers.

Functions
std::ostream &	operator<< (std::ostream &out, PRMObject::prm_type obj_type)
	For printing PRMType easily.
template<typename GUM_SCALAR>
std::string	__print_attribute__ (const PRMInstance< GUM_SCALAR > &i, const PRMAttribute< GUM_SCALAR > &a)
template<typename GUM_SCALAR>
std::string	__print_instance__ (const PRMInstance< GUM_SCALAR > &i)
template<typename GUM_SCALAR>
std::string	__print_system__ (const PRMSystem< GUM_SCALAR > &s)
template<typename LIST>
std::string	__print_list__ (LIST l)
template<typename GUM_SCALAR>
std::string	__print_pot__ (const Tensor< GUM_SCALAR > &pot)
template<typename SET>
std::string	__print_set__ (SET set)
void	decomposePath (const std::string &path, std::vector< std::string > &v)
	Decompose a string in a vector of strings using "." as separators.
NodeId	nextNodeId ()
	Returns the next value of an unique counter for PRM's node id.
template<typename GUM_SCALAR>
Tensor< GUM_SCALAR > *	copyTensor (const Bijection< const DiscreteVariable , const DiscreteVariable > &bij, const Tensor< GUM_SCALAR > &source)
	Returns a copy of a Tensor after applying a bijection over the variables in source.
template<typename GUM_SCALAR>
Tensor< GUM_SCALAR >	multTensor (const Tensor< GUM_SCALAR > &t1, const Tensor< GUM_SCALAR > &t2)
template<typename GUM_SCALAR>
void	eliminateNode (const DiscreteVariable var, Set< Tensor< GUM_SCALAR > > &pool, Set< Tensor< GUM_SCALAR > * > &trash)
	Proceeds with the elimination of var in pool.
template<typename GUM_SCALAR>
void	eliminateNodes (const std::vector< const DiscreteVariable * > &elim_order, Set< Tensor< GUM_SCALAR > * > &pool, Set< Tensor< GUM_SCALAR > * > &trash)

Detailed Description

namespace for all probabilistic relational models entities

Typedef Documentation

◆ prm_float

using gum::prm::prm_float = float

PRMType for real numbers.

Definition at line 65 of file utils_prm.h.

Function Documentation

◆ __print_attribute__()

template<typename GUM_SCALAR>

std::string gum::prm::__print_attribute__	(	const PRMInstance< GUM_SCALAR > &	i,
		const PRMAttribute< GUM_SCALAR > &	a )

Definition at line 56 of file SVE_tpl.h.

                                                                         {
      std::stringstream s;
      const auto&       class_a = i.type().get(a.safeName());
      s << &(a.type().variable()) << " - ";
      s << i.name() << "." << a.safeName() << ": input=" << i.type().isInputNode(class_a);
      s << " output=" << i.type().isOutputNode(class_a)
        << " inner=" << i.type().isInnerNode(class_a);
      return s.str();
    }

References gum::prm::PRMObject::name(), gum::prm::PRMClassElement< GUM_SCALAR >::safeName(), gum::prm::PRMAttribute< GUM_SCALAR >::type(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by __print_instance__().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __print_instance__()

template<typename GUM_SCALAR>

std::string gum::prm::__print_instance__ ( const PRMInstance< GUM_SCALAR > & i )

Definition at line 68 of file SVE_tpl.h.

                                                                     {
      std::stringstream s;
      s << i.name() << std::endl;
      s << "Attributes: " << std::endl;
      for (auto a: i) {
        s << __print_attribute__(i, *(a.second));
      }
      if (i.type().slotChains().size()) {
        s << std::endl << "SlotChains: " << std::endl;
        for (auto sc: i.type().slotChains()) {
          s << sc->name() << " ";
        }
      }
      return s.str();
    }

References __print_attribute__(), gum::prm::PRMObject::name(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by __print_system__().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __print_list__()

template<typename LIST>

std::string gum::prm::__print_list__ ( LIST l )

Definition at line 94 of file SVE_tpl.h.

                                     {
      std::stringstream s;
      s << "[";
      for (auto i: l) {
        s << i->name() << " ";
      }
      s << "]";
      return s.str();
    }

◆ __print_pot__()

template<typename GUM_SCALAR>

std::string gum::prm::__print_pot__ ( const Tensor< GUM_SCALAR > & pot )

Definition at line 105 of file SVE_tpl.h.

                                                             {
      std::stringstream s;
      s << "{";
      for (auto var: pot.variablesSequence()) {
        s << var << ", ";
      }
      s << "}";
      return s.str();
    }

Referenced by __print_set__().

Here is the caller graph for this function:

◆ __print_set__()

template<typename SET>

std::string gum::prm::__print_set__ ( SET set )

Definition at line 116 of file SVE_tpl.h.

                                     {
      std::stringstream s;
      s << "[";
      for (auto p: set) {
        s << __print_pot__(*p) << " ";
      }
      s << "]";
      return s.str();
    }

References __print_pot__().

Here is the call graph for this function:

◆ __print_system__()

template<typename GUM_SCALAR>

std::string gum::prm::__print_system__ ( const PRMSystem< GUM_SCALAR > & s )

Definition at line 85 of file SVE_tpl.h.

                                                                 {
      std::stringstream str;
      for (auto i: s) {
        str << __print_instance__(*(i.second)) << std::endl;
      }
      return str.str();
    }

References __print_instance__().

Here is the call graph for this function:

◆ copyTensor()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::prm::copyTensor	(	const Bijection< const DiscreteVariable , const DiscreteVariable > &	bij,
		const Tensor< GUM_SCALAR > &	source )

Returns a copy of a Tensor after applying a bijection over the variables in source.

This copies the Tensor source in a new Tensor by permuting all variables in source with respect to bij.

Warning: This method in most case creates the new Tensor using a gum::MultiDimBijArray, this means that the created Tensor holds a reference over source, so do not delete source if you still need the created tensor.

Parameters

bij	A Bijection of DiscreteVariable where firsts are variables in source and seconds variables added in the returned Tensor.
source	The copied Tensor.

Returns: a pointer over a Tensor which is a copy of source.

Exceptions

FatalError raised if an unknown MultiDimImplementation is encountered.

Definition at line 50 of file utils_prm_tpl.h.

                                                                                                {
      const MultiDimImplementation< GUM_SCALAR >* impl = source.content();
      Tensor< GUM_SCALAR >*                       p    = 0;
 
      try {
        if (dynamic_cast< const MultiDimReadOnly< GUM_SCALAR >* >(impl)) {
          if (dynamic_cast< const MultiDimNoisyORCompound< GUM_SCALAR >* >(impl)) {
            p = new Tensor< GUM_SCALAR >(new MultiDimNoisyORCompound< GUM_SCALAR >(
                bij,
                static_cast< const MultiDimNoisyORCompound< GUM_SCALAR >& >(*impl)));
          } else if (dynamic_cast< const MultiDimNoisyORNet< GUM_SCALAR >* >(impl)) {
            p = new Tensor< GUM_SCALAR >(new MultiDimNoisyORNet< GUM_SCALAR >(
                bij,
                static_cast< const MultiDimNoisyORNet< GUM_SCALAR >& >(*impl)));
          } else if (dynamic_cast< const aggregator::MultiDimAggregator< GUM_SCALAR >* >(impl)) {
            p = new Tensor< GUM_SCALAR >(
                static_cast< MultiDimImplementation< GUM_SCALAR >* >(impl->newFactory()));
 
            for (auto var: impl->variablesSequence())
              p->add(*(bij.second(var)));
          } else if (dynamic_cast< const MultiDimBucket< GUM_SCALAR >* >(impl)) {
            // This is necessary just to prevent non initialized arrays
            const_cast< MultiDimBucket< GUM_SCALAR >* >(
                static_cast< const MultiDimBucket< GUM_SCALAR >* >(impl))
                ->compute();
 
            try {
              p = new Tensor< GUM_SCALAR >(new MultiDimBijArray< GUM_SCALAR >(
                  bij,
                  static_cast< const MultiDimBucket< GUM_SCALAR >* >(impl)->bucket()));
            } catch (OperationNotAllowed const&) {
              // This is an empty bucket, it happens if all variables were
              // eliminated
              return new Tensor< GUM_SCALAR >();
            }
          } else {
            GUM_ERROR(FatalError, "encountered an unexpected MultiDim implementation")
          }
        } else {
          if (dynamic_cast< const MultiDimArray< GUM_SCALAR >* >(impl)) {
            p = new Tensor< GUM_SCALAR >(new MultiDimBijArray< GUM_SCALAR >(
                bij,
                static_cast< const MultiDimArray< GUM_SCALAR >& >(*impl)));
          } else if (dynamic_cast< const MultiDimBijArray< GUM_SCALAR >* >(impl)) {
            p = new Tensor< GUM_SCALAR >(new MultiDimBijArray< GUM_SCALAR >(
                bij,
                static_cast< const MultiDimBijArray< GUM_SCALAR >& >(*impl)));
          } else if (dynamic_cast< const MultiDimSparse< GUM_SCALAR >* >(impl)) {
            GUM_ERROR(FatalError, "There is no MultiDimSparse in PRMs, normally...")
          } else {
            // Just need to make the copy using the bijection but we only use
            // multidim array
            GUM_ERROR(FatalError, "encountered an unexpected MultiDim implementation")
          }
        }
 
        return p;
      } catch (Exception const&) {
        if (p) delete p;
 
        throw;
      }
    }

References GUM_ERROR, gum::MultiDimImplementation< GUM_SCALAR >::newFactory(), gum::BijectionImplementation< T1, T2, Gen >::second(), and gum::MultiDimImplementation< GUM_SCALAR >::variablesSequence().

Referenced by gum::prm::SVE< GUM_SCALAR >::_insertLiftedNodes_(), gum::prm::SVED< GUM_SCALAR >::_insertLiftedNodes_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), gum::prm::StructuredInference< GUM_SCALAR >::_translatePotSet_(), and gum::prm::PRMScalarAttribute< GUM_SCALAR >::copy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decomposePath()

void gum::prm::decomposePath	(	const std::string &	path,
		std::vector< std::string > &	v )

Decompose a string in a vector of strings using "." as separators.

Definition at line 48 of file utils_prm.cpp.

                                                                         {
      size_t prev   = 0;
      size_t length = 0;
      size_t idx_1  = path.find(".");
      size_t idx_2  = path.find(PRMObject::LEFT_CAST());
 
      if (idx_2 == std::string::npos) {
        // ignore safe names
        size_t idx = idx_1;
 
        while (idx != std::string::npos) {
          length = idx - prev;
          v.push_back(path.substr(prev, length));
          prev = idx + 1;
          idx  = path.find(".", prev);
        }
      } else {
        size_t tmp = 0;
 
        while (idx_1 != std::string::npos) {
          if (idx_1 < idx_2) {
            length = idx_1 - prev;
            v.push_back(path.substr(prev, length));
            prev  = idx_1 + 1;
            idx_1 = path.find(".", prev);
          } else if (idx_2 < idx_1) {
            tmp   = path.find(PRMObject::RIGHT_CAST(), idx_2);
            idx_1 = path.find(".", tmp);
            idx_2 = path.find(PRMObject::LEFT_CAST(), tmp);
          }
        }
      }
 
      v.push_back(path.substr(prev, std::string::npos));
    }

References gum::prm::PRMObject::LEFT_CAST(), and gum::prm::PRMObject::RIGHT_CAST().

Referenced by gum::prm::PRMFactory< GUM_SCALAR >::_buildSlotChain_(), and gum::prm::o3prm::O3ClassFactory< GUM_SCALAR >::_resolveSlotChain_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eliminateNode()

template<typename GUM_SCALAR>

void gum::prm::eliminateNode	(	const DiscreteVariable *	var,
		Set< Tensor< GUM_SCALAR > * > &	pool,
		Set< Tensor< GUM_SCALAR > * > &	trash )

Proceeds with the elimination of var in pool.

Parameters

var	The variable eliminated from every tensors in pool.
pool	A pool of tensors in which the elimination of var is done.
trash	All create tensors are inserted in this set, useful to delete later.

Definition at line 123 of file utils_prm_tpl.h.

                                                            {
      Tensor< GUM_SCALAR >* pot = nullptr;
      Tensor< GUM_SCALAR >* tmp = nullptr;
 
      gum::VariableSet var_set;
      var_set.insert(var);
      Set< const Tensor< GUM_SCALAR >* > pots;
 
      for (const auto p: pool)
        if (p->contains(*var)) pots.insert(p);
 
      if (pots.size() == 0) {
        return;
      } else if (pots.size() == 1) {
        tmp = const_cast< Tensor< GUM_SCALAR >* >(*pots.begin());
        pot = new Tensor< GUM_SCALAR >(tmp->sumOut(var_set));
      } else {
        MultiDimCombinationDefault< Tensor< GUM_SCALAR > > Comb(multTensor);
        tmp = Comb.execute(pots);
        pot = new Tensor< GUM_SCALAR >(tmp->sumOut(var_set));
        delete tmp;
      }
 
      for (const auto p: pots) {
        pool.erase(const_cast< Tensor< GUM_SCALAR >* >(p));
 
        if (trash.exists(const_cast< Tensor< GUM_SCALAR >* >(p))) {
          trash.erase(const_cast< Tensor< GUM_SCALAR >* >(p));
          delete const_cast< Tensor< GUM_SCALAR >* >(p);
        }
      }
 
      pool.insert(pot);
      trash.insert(pot);
    }

References gum::Set< Key >::begin(), gum::MultiDimCombinationDefault< TABLE >::execute(), gum::Set< Key >::insert(), multTensor(), and gum::Set< Key >::size().

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::CData::CData(), gum::prm::StructuredInference< GUM_SCALAR >::_buildReduceGraph_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesWithEvidence_(), gum::prm::StructuredInference< GUM_SCALAR >::_eliminateObservedNodes_(), gum::prm::StructuredInference< GUM_SCALAR >::_eliminateObservedNodesInSource_(), gum::prm::SVE< GUM_SCALAR >::_initLiftedNodes_(), gum::prm::SVED< GUM_SCALAR >::_initLiftedNodes_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), gum::prm::StructuredInference< GUM_SCALAR >::_reducePattern_(), and eliminateNodes().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eliminateNodes()

template<typename GUM_SCALAR>

void gum::prm::eliminateNodes	(	const std::vector< const DiscreteVariable * > &	elim_order,
		Set< Tensor< GUM_SCALAR > * > &	pool,
		Set< Tensor< GUM_SCALAR > * > &	trash )

Definition at line 162 of file utils_prm_tpl.h.

                                                                             {
      for (auto var: elim_order) {
        eliminateNode(var, pool, trash);
      }
    }

References eliminateNode().

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::SVE< GUM_SCALAR >::_eliminateNodesWithEvidence_(), and gum::prm::SVE< GUM_SCALAR >::_variableElimination_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ multTensor()

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::prm::multTensor	(	const Tensor< GUM_SCALAR > &	t1,
		const Tensor< GUM_SCALAR > &	t2 )

Definition at line 117 of file utils_prm_tpl.h.

                                                                    {
      return t1 * t2;
    }

Referenced by eliminateNode(), and gum::prm::StructuredInference< GUM_SCALAR >::posterior_().

Here is the caller graph for this function:

◆ nextNodeId()

NodeId gum::prm::nextNodeId ( )

Returns the next value of an unique counter for PRM's node id.

Returns: Returns the next value of an unique counter for PRM's node id.

Definition at line 84 of file utils_prm.cpp.

                        {
      static NodeId id = 0;
      return ++id;
    }

Referenced by gum::prm::PRMClass< GUM_SCALAR >::_addCastDescendants_(), gum::prm::PRMClass< GUM_SCALAR >::_addCastDescendants_(), gum::prm::PRMClass< GUM_SCALAR >::_overloadAttribute_(), gum::prm::PRMClass< GUM_SCALAR >::add(), gum::prm::PRMInterface< double >::addArc(), and gum::prm::PRMInterface< double >::implementations().

Here is the caller graph for this function:

◆ operator<<()

std::ostream & gum::prm::operator<<	(	std::ostream &	out,
		PRMObject::prm_type	obj_type )

For printing PRMType easily.

Definition at line 101 of file PRMObject.cpp.

                                                                        {
      return (out << PRMObject::enum2str(obj_type));
    }

References gum::prm::PRMObject::enum2str().

Here is the call graph for this function:

Namespaces

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ prm_float

Function Documentation

◆ __print_attribute__()

◆ __print_instance__()

◆ __print_list__()

◆ __print_pot__()

◆ __print_set__()

◆ __print_system__()

◆ copyTensor()

◆ decomposePath()

◆ eliminateNode()

◆ eliminateNodes()

◆ multTensor()

◆ nextNodeId()

◆ operator<<()