namespace for all probabilistic relational models entities More...

Namespaces
	gspan

	o3prm

	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	ClusteredLayerGenerator
	<agrum/PRM/generator/clusteredLayerGenerator.h> More...

class	GroundedInference
	<agrum/PRM/groundedInference.h> More...

class	GSpan
	This class discovers pattern in a PRM<GUM_SCALAR>'s PRMSystem<GUM_SCALAR> to speed up structured inference. 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	LayerGenerator
	<agrum/PRM/generator/layerGenerator.h> More...

class	NameGenerator
	This is a name generator for classes, types, systems, instances and class elements. More...

struct	ParamScopeData

class	PRM
	This class represents a Probabilistic Relational PRMSystem<GUM_SCALAR>. More...

class	PRMAggregate

class	PRMAttribute
	PRMAttribute is a member of a Class in a PRM. 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...

class	PRMClassElement
	Abstract class representing an element of PRM class. More...

class	PRMClassElementContainer
	<agrum/PRM/classElementContainer.h> More...

class	PRMFactory
	Factory which builds a PRM<GUM_SCALAR>. More...

class	PRMFormAttribute
	<agrum/PRM/elements/formAttribute.h> More...

class	PRMFuncAttribute
	<agrum/PRM/elements/funcAttribute.h> More...

class	PRMGenerator
	This class is the base class to all PRM generators. More...

class	PRMInference
	This abstract class is used as base class for all inference class on PRM<GUM_SCALAR>. More...

class	PRMInstance
	An PRMInstance is a Bayesian network fragment defined by a Class and used in a PRMSystem. 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	PRMObject
	Abstract base class for any element defined in a PRM. More...

class	PRMParameter
	PRMParameter is a member of a Class in a PRM. More...

class	PRMReferenceSlot
	A PRMReferenceSlot represent a relation between two PRMClassElementContainer. More...

class	PRMScalarAttribute
	<agrum/PRM/elements/scalarAttribute.h> 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	PRMSystem
	A PRMSystem is a container of PRMInstance and describe a relational skeleton. More...

class	PRMType
	This is a decoration of the DiscreteVariable class. 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...

Typedefs
typedef float	prm_float
	PRMType for real numbers. More...

Functions
std::ostream &	operator<< (std::ostream &out, PRMObject::prm_type obj_type)
	For printing PRMType easily. More...

void	decomposePath (const std::string &path, std::vector< std::string > &v)
	Decompose a string in a vector of strings using "." as separators. More...

NodeId	nextNodeId ()
	Returns the next value of an unique counter for PRM's node id. More...

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 Potential< GUM_SCALAR > &pot)

template<typename SET >
std::string	__print_set__ (SET set)

template<typename GUM_SCALAR >
Potential< GUM_SCALAR > *	copyPotential (const Bijection< const DiscreteVariable , const DiscreteVariable > &bij, const Potential< GUM_SCALAR > &source)
	Returns a copy of a Potential after applying a bijection over the variables in source. More...

template<typename GUM_SCALAR >
Potential< GUM_SCALAR > *	multPotential (const Potential< GUM_SCALAR > &t1, const Potential< GUM_SCALAR > &t2)

template<typename GUM_SCALAR >
void	eliminateNode (const DiscreteVariable var, Set< Potential< GUM_SCALAR > > &pool, Set< Potential< GUM_SCALAR > * > &trash)
	Proceeds with the elimination of var in pool. More...

template<typename GUM_SCALAR >
void	eliminateNodes (const std::vector< const DiscreteVariable * > &elim_order, Set< Potential< GUM_SCALAR > * > &pool, Set< Potential< GUM_SCALAR > * > &trash)

Detailed Description

namespace for all probabilistic relational models entities

Typedef Documentation

◆ prm_float

typedef float gum::prm::prm_float

PRMType for real numbers.

Definition at line 46 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 35 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();
     }

◆ __print_instance__()

template<typename GUM_SCALAR >

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

Definition at line 47 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();
     }

◆ __print_list__()

template<typename LIST >

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

Definition at line 73 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 Potential< GUM_SCALAR > & pot )

Definition at line 84 of file SVE_tpl.h.

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

◆ __print_set__()

template<typename SET >

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

Definition at line 95 of file SVE_tpl.h.

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

◆ __print_system__()

template<typename GUM_SCALAR >

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

Definition at line 64 of file SVE_tpl.h.

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

◆ copyPotential()

template<typename GUM_SCALAR >

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

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

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

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

Parameters

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

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

Exceptions

FatalError raised if an unknown MultiDimImplementation is encountered.

Definition at line 29 of file utils_prm_tpl.h.

                                                                                                   {
       const MultiDimImplementation< GUM_SCALAR >* impl = source.content();
       Potential< GUM_SCALAR >*                    p    = 0;
 
       try {
         if (dynamic_cast< const MultiDimReadOnly< GUM_SCALAR >* >(impl)) {
           if (dynamic_cast< const MultiDimNoisyORCompound< GUM_SCALAR >* >(impl)) {
             p = new Potential< 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 Potential< 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 Potential< 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 Potential< GUM_SCALAR >(new MultiDimBijArray< GUM_SCALAR >(
                  bij,
                  static_cast< const MultiDimBucket< GUM_SCALAR >* >(impl)->bucket()));
             } catch (OperationNotAllowed&) {
               // This is an empty bucket, it happens if all variables were
               // eliminated
               return new Potential< GUM_SCALAR >();
             }
           } else {
             GUM_ERROR(FatalError, "encountered an unexpected MultiDim implementation")
           }
         } else {
           if (dynamic_cast< const MultiDimArray< GUM_SCALAR >* >(impl)) {
             p = new Potential< 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 Potential< 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&) {
         if (p) delete p;
 
         throw;
       }
     }

◆ 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 28 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));
     }

◆ eliminateNode()

template<typename GUM_SCALAR >

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

Proceeds with the elimination of var in pool.

Parameters

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

Definition at line 102 of file utils_prm_tpl.h.

                                                                {
       Potential< GUM_SCALAR >* pot = nullptr;
       Potential< GUM_SCALAR >* tmp = nullptr;
 
       Set< const DiscreteVariable* > var_set;
       var_set.insert(var);
       Set< const Potential< 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< Potential< GUM_SCALAR >* >(*pots.begin());
         pot = new Potential< GUM_SCALAR >(tmp->margSumOut(var_set));
       } else {
         MultiDimCombinationDefault< GUM_SCALAR, Potential > Comb(multPotential);
         tmp = Comb.combine(pots);
         pot = new Potential< GUM_SCALAR >(tmp->margSumOut(var_set));
         delete tmp;
       }
 
       for (const auto p: pots) {
         pool.erase(const_cast< Potential< GUM_SCALAR >* >(p));
 
         if (trash.exists(const_cast< Potential< GUM_SCALAR >* >(p))) {
           trash.erase(const_cast< Potential< GUM_SCALAR >* >(p));
           delete const_cast< Potential< GUM_SCALAR >* >(p);
         }
       }
 
       pool.insert(pot);
       trash.insert(pot);
     }

◆ eliminateNodes()

template<typename GUM_SCALAR >

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

Definition at line 141 of file utils_prm_tpl.h.

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

◆ multPotential()

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > * gum::prm::multPotential	(	const Potential< GUM_SCALAR > &	t1,
		const Potential< GUM_SCALAR > &	t2
	)

Definition at line 96 of file utils_prm_tpl.h.

                                                                               {
       return new Potential< GUM_SCALAR >(t1 * t2);
     }

◆ 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 64 of file utils_prm.cpp.

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

◆ operator<<()

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

For printing PRMType easily.

Definition at line 78 of file PRMObject.cpp.

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

Namespaces

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ prm_float

Function Documentation

◆ __print_attribute__()

◆ __print_instance__()

◆ __print_list__()

◆ __print_pot__()

◆ __print_set__()

◆ __print_system__()

◆ copyPotential()

◆ decomposePath()

◆ eliminateNode()

◆ eliminateNodes()

◆ multPotential()

◆ nextNodeId()

◆ operator<<()