gum::IMarkovRandomField< GUM_SCALAR > Class Template Reference

Class representing the minimal interface for Markov random field. More...

#include <agrum/BN/IMarkovRandomField.h>

Inheritance diagram for gum::IMarkovRandomField< GUM_SCALAR >:

Collaboration diagram for gum::IMarkovRandomField< GUM_SCALAR >:

Public Member Functions
bool	operator== (const IMarkovRandomField< GUM_SCALAR > &from) const
	This operator compares 2 BNs !
Size	dim () const
	Returns the dimension (the number of free parameters) in this bayes net.
Size	maxVarDomainSize () const
GUM_SCALAR	minParam () const
GUM_SCALAR	maxParam () const
GUM_SCALAR	minNonZeroParam () const
GUM_SCALAR	maxNonOneParam () const
virtual std::string	toDot () const
virtual std::string	toDotAsFactorGraph () const
std::string	toString () const
NodeSet	minimalCondSet (NodeId target, const NodeSet &soids) const
NodeSet	minimalCondSet (const NodeSet &targets, const NodeSet &soids) const
bool	hasSameStructure (const UGmodel &other) const
	check if nodes X and nodes Y are independent given nodes Z
NodeProperty< NodeId >	connectedComponents () const
	Returns the connected components of the underlying undirected graph. Each node maps to the id of its component root.
NodeSet	family (const NodeId id) const final
	returns the node as a NodeSet (in mixed graph : family is the node and its parents
NodeSet	family (std::string_view name) const final
const UndiGraph &	internalGraph () const
	Returns a const reference to the internal (unnamed) graph. O(1), no copy. Use for stable references or pointers (graph listeners). For named node access, use graph() instead.
double	log10DomainSize () const
Constructors / Destructors
	IMarkovRandomField ()
	Default constructor.
	IMarkovRandomField (std::string_view name)
	Default constructor.
	~IMarkovRandomField () override
	Destructor.
	IMarkovRandomField (const IMarkovRandomField< GUM_SCALAR > &source)
	Copy constructor.
IMarkovRandomField< GUM_SCALAR > &	operator= (const IMarkovRandomField< GUM_SCALAR > &source)
	Copy operator.
Pure Virtual methods
virtual const Tensor< GUM_SCALAR > &	factor (const NodeSet &varIds) const =0
	Returns the factor of a set of variable.
virtual const NodeSet &	smallestFactorFromNode (NodeId node) const =0
	Returns the smallest factor that contains this variable.
virtual const NodeSet &	smallestFactorFromNode (std::string_view name) const
	Returns the smallest factor that contains this variable.
virtual const FactorTable< GUM_SCALAR > &	factors () const =0
	Returns the set of factors as a IMarkovRandomField::FactorTable.
Variable manipulation methods.
UndiGraph	graph () const
	Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.
Size	size () const final
	Returns the number of variables in this Directed Graphical Model.
Size	sizeEdges () const
	Returns the number of arcs in this Directed Graphical Model.
const NodeGraphPart &	nodes () const final
	Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.
bool	exists (NodeId node) const final
	Return true if this node exists in this graphical model.
bool	exists (std::string_view name) const final
	Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.
Edge manipulation methods.
const EdgeSet &	edges () const
	return true if the edge node1-node2 exists in the UGModel
bool	existsEdge (const NodeId node1, const NodeId node2) const
	return true if the edge node1-node2 exists in the UGModel
bool	existsEdge (std::string_view name1, std::string_view name2) const
	return true if the edge node1-node2 exists in the UGModel
const NodeSet &	neighbours (const NodeId id) const
	returns the neighbours of a node as set of nodes
const NodeSet &	neighbours (std::string_view name) const
	return true if the edge node1-node2 exists in the UGModel
bool	isIndependent (NodeId X, NodeId Y, const NodeSet &Z) const final
	check if X and Y are independent given Z
bool	isIndependent (const NodeSet &X, const NodeSet &Y, const NodeSet &Z) const final
	check if nodes X and nodes Y are independent given nodes Z
bool	isIndependent (std::string_view Xname, std::string_view Yname, const std::vector< std::string > &Znames) const
	return true if the edge node1-node2 exists in the UGModel
bool	isIndependent (const std::vector< std::string > &Xnames, const std::vector< std::string > &Ynames, const std::vector< std::string > &Znames) const
	return true if the edge node1-node2 exists in the UGModel
Variable accessor methods
const VariableNodeMap &	variableNodeMap () const override
	Returns a constant reference to the VariableNodeMap of this model.
const DiscreteVariable &	variable (NodeId id) const override
	Returns a constant reference over a variable given its node id.
NodeId	nodeId (const DiscreteVariable &var) const override
	Returns the NodeId of a variable.
NodeId	idFromName (std::string_view name) const override
	Returns the NodeId of a variable given its name.
const DiscreteVariable &	variableFromName (std::string_view name) const override
	Returns a constant reference over a variable given its name.
Getter and setters
const std::string &	property (std::string_view name) const
	Return the value of the property name of this GraphicalModel.
const std::string &	propertyWithDefault (std::string_view name, const std::string &byDefault) const
	Return the value of the property name of this GraphicalModel.
void	setProperty (std::string_view name, std::string_view value)
	Add or change a property of this GraphicalModel.
std::vector< std::string >	properties () const
	List of all the names of property in the Graphical model.
bool	existsProperty (std::string_view name) const
	check wether a property exists in this GraphicalModel
void	updateMetaData ()
	update the meta data of this Graphical Model (version, creation date, last modification date) This method is called by the writers ONLY before writing the model to a file.
Variable manipulation methods.
virtual bool	empty () const
	Return true if this graphical model is empty.
std::vector< std::string >	names (const std::vector< NodeId > &ids) const
	transform a vector of NodeId in a vector of names
std::vector< std::string >	names (const NodeSet &ids) const
	transform a NodeSet in a vector of names
std::vector< NodeId >	ids (const std::vector< std::string > &names) const
	transform a vector of names into a vector of nodeId
NodeSet	nodeset (const std::vector< std::string > &names) const
	transform a vector of names into a NodeSet
gum::VariableSet	variables (const std::vector< std::string > &l) const
	transform a vector of names into a VariableeSet
gum::VariableSet	variables (const NodeSet &ids) const
	transform a vector of NodeId into a VariableeSet
Instantiation	completeInstantiation () const
	Get an instantiation over all the variables of the model.

Static Public Member Functions
static std::string	spaceCplxToString (double dSize, int dim, Size usedMem)
	send to the stream the space complexity with 3 parametrs

Protected Member Functions
void	_nameNodes_ (NodeGraphPart &g) const
	Names every node of g using variable(id).name() for each node id in g.

Protected Attributes
UndiGraph	graph_
	The DAG of this Directed Graphical Model.
VariableNodeMap	varMap_
	Mapping between NodeIds and discrete variables.

Private Member Functions
void	_minimalCondSetVisit_ (NodeId node, const NodeSet &soids, NodeSet &minimal, NodeSet &alreadyVisited) const
const HashTable< std::string, std::string > &	_properties_ () const
	Return the properties of this Directed Graphical Model.

Private Attributes
HashTable< std::string, std::string >	_propertiesMap_
	The properties of this Directed Graphical Model.

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::IMarkovRandomField< GUM_SCALAR >

Class representing the minimal interface for Markov random field.

This class is used as a base class for different versions of Markov random fields. No data (except the graph herited from UGModel are included in this class. Many algorithms (inference for instance) may use this class when a simple MRF is needed.

Definition at line 75 of file IMarkovRandomField.h.

Constructor & Destructor Documentation

IMarkovRandomField() [1/3]

template<GUM_Numeric GUM_SCALAR>

gum::IMarkovRandomField< GUM_SCALAR >::IMarkovRandomField

(

)

Default constructor.

Definition at line 61 of file IMarkovRandomField_tpl.h.

                                                       : UGmodel() {
    GUM_CONSTRUCTOR(IMarkovRandomField);
  }

References IMarkovRandomField(), and gum::UGmodel::UGmodel().

Referenced by IMarkovRandomField(), IMarkovRandomField(), IMarkovRandomField(), ~IMarkovRandomField(), factors(), operator=(), and operator==().

Here is the call graph for this function:

Here is the caller graph for this function:

IMarkovRandomField() [2/3]

template<GUM_Numeric GUM_SCALAR>

gum::IMarkovRandomField< GUM_SCALAR >::IMarkovRandomField ( std::string_view name )

explicit

Default constructor.

Definition at line 66 of file IMarkovRandomField_tpl.h.

                                                                          : UGmodel() {
    GUM_CONSTRUCTOR(IMarkovRandomField);
    this->setProperty("name", name);
  }

References IMarkovRandomField(), gum::UGmodel::UGmodel(), and gum::GraphicalModel::setProperty().

Here is the call graph for this function:

~IMarkovRandomField()

template<GUM_Numeric GUM_SCALAR>

gum::IMarkovRandomField< GUM_SCALAR >::~IMarkovRandomField ( )

override

Destructor.

Definition at line 86 of file IMarkovRandomField_tpl.h.

                                                        {
    GUM_DESTRUCTOR(IMarkovRandomField);
  }

References IMarkovRandomField().

Here is the call graph for this function:

IMarkovRandomField() [3/3]

template<GUM_Numeric GUM_SCALAR>

gum::IMarkovRandomField< GUM_SCALAR >::IMarkovRandomField

(

const IMarkovRandomField< GUM_SCALAR > &

source

)

Copy constructor.

Definition at line 72 of file IMarkovRandomField_tpl.h.

                                                      : UGmodel(source) {
    GUM_CONS_CPY(IMarkovRandomField);
  }

References IMarkovRandomField(), and gum::UGmodel::UGmodel().

Here is the call graph for this function:

Member Function Documentation

_minimalCondSetVisit_()

template<GUM_Numeric GUM_SCALAR>

void gum::IMarkovRandomField< GUM_SCALAR >::_minimalCondSetVisit_ ( NodeId node, const NodeSet & soids, NodeSet & minimal, NodeSet & alreadyVisited ) const

private

Definition at line 319 of file IMarkovRandomField_tpl.h.

                                                                                              {
    if (alreadyVisited.contains(node)) return;
    alreadyVisited << node;
 
    if (soids.contains(node)) {
      minimal << node;
    } else {
      for (auto neig: graph_.neighbours(node))
        _minimalCondSetVisit_(neig, soids, minimal, alreadyVisited);
    }
  }

References _minimalCondSetVisit_(), gum::Set< Key >::contains(), and gum::UGmodel::graph_.

Referenced by _minimalCondSetVisit_(), and minimalCondSet().

Here is the call graph for this function:

Here is the caller graph for this function:

_nameNodes_()

INLINE void gum::GraphicalModel::_nameNodes_ ( NodeGraphPart & g ) const

protectedinherited

Names every node of g using variable(id).name() for each node id in g.

Call this before returning any newly constructed graph from a model method.

Definition at line 175 of file graphicalModel_inl.h.

                                                         {
    for (auto id: g)
      g.setName(id, variable(id).name());
  }

References gum::NodeGraphPart::setName(), and variable().

Referenced by gum::DAGmodel::dag(), gum::UGmodel::graph(), gum::DAGmodel::moralGraph(), and gum::DAGmodel::moralizedAncestralGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

_properties_()

INLINE const HashTable< std::string, std::string > & gum::GraphicalModel::_properties_ ( ) const

privateinherited

Return the properties of this Directed Graphical Model.

Definition at line 67 of file graphicalModel_inl.h.

                                                                              {
    return _propertiesMap_;
  }

References _propertiesMap_.

Referenced by property().

Here is the caller graph for this function:

completeInstantiation()

INLINE Instantiation gum::GraphicalModel::completeInstantiation ( ) const

inherited

Get an instantiation over all the variables of the model.

Definition at line 104 of file graphicalModel_inl.h.

                                                            {
    Instantiation I;
 
    for (const auto node: nodes())
      I << variable(node);
 
    return I;
  }

References nodes(), and variable().

Here is the call graph for this function:

connectedComponents()

INLINE NodeProperty< NodeId > gum::UGmodel::connectedComponents ( ) const

inherited

Returns the connected components of the underlying undirected graph. Each node maps to the id of its component root.

Definition at line 109 of file UGmodel_inl.h.

                                                                   {
    return graph_.connectedComponents();
  }

References graph_.

dim()

template<GUM_Numeric GUM_SCALAR>

Size gum::IMarkovRandomField< GUM_SCALAR >::dim

(

)

const

Returns the dimension (the number of free parameters) in this bayes net.

\( dim(G)=\sum_{i \in nodes} ((r_i-1)\cdot q_i) \) where \( r_i \) is the number of instantiations of node \( i \) and \( q_i \) is the number of instantiations of its parents.

Definition at line 91 of file IMarkovRandomField_tpl.h.

                                                   {
    Size res = 0;
    for (auto f: factors()) {
      res += f.second->domainSize();
    }
    return res;
  }

References factors().

Here is the call graph for this function:

edges()

INLINE const EdgeSet & gum::UGmodel::edges ( ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 73 of file UGmodel_inl.h.

{ return graph_.edges(); }

References graph_.

Referenced by hasSameStructure().

Here is the caller graph for this function:

empty()

INLINE bool gum::GraphicalModel::empty ( ) const

virtualinherited

Return true if this graphical model is empty.

Definition at line 114 of file graphicalModel_inl.h.

{ return size() == 0; }

References size().

Referenced by gum::IBayesNet< GUM_SCALAR >::check(), and gum::BayesNet< GUM_SCALAR >::clear().

Here is the call graph for this function:

Here is the caller graph for this function:

exists() [1/2]

INLINE bool gum::UGmodel::exists ( NodeId node ) const

finalvirtualinherited

Return true if this node exists in this graphical model.

Implements gum::GraphicalModel.

Definition at line 89 of file UGmodel_inl.h.

{ return graph_.exists(node); }

References graph_.

Referenced by exists(), hasSameStructure(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), and gum::IMarkovRandomField< GUM_SCALAR >::smallestFactorFromNode().

Here is the caller graph for this function:

exists() [2/2]

INLINE bool gum::UGmodel::exists ( std::string_view name ) const

finalvirtualinherited

Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.

O(n) — allocates a new graph. For a stable reference (listeners, long-lived pointers), use internalGraph().

Implements gum::GraphicalModel.

Definition at line 91 of file UGmodel_inl.h.

                                                       {
    try {
      return exists(idFromName(name));
    } catch ([[maybe_unused]] gum::NotFound& e) { return false; }
  }

References exists(), and gum::DiscreteGraphicalModel::idFromName().

Here is the call graph for this function:

existsEdge() [1/2]

INLINE bool gum::UGmodel::existsEdge ( const NodeId node1, const NodeId node2 ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 75 of file UGmodel_inl.h.

                                                                              {
    return graph_.existsEdge(node1, node2);
  }

References graph_.

Referenced by existsEdge().

Here is the caller graph for this function:

existsEdge() [2/2]

INLINE bool gum::UGmodel::existsEdge ( std::string_view name1, std::string_view name2 ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 79 of file UGmodel_inl.h.

                                                                                  {
    return existsEdge(idFromName(name1), idFromName(name2));
  }

References existsEdge(), and gum::DiscreteGraphicalModel::idFromName().

Here is the call graph for this function:

existsProperty()

INLINE bool gum::GraphicalModel::existsProperty ( std::string_view name ) const

inherited

check wether a property exists in this GraphicalModel

Definition at line 170 of file graphicalModel_inl.h.

                                                               {
    return _propertiesMap_.exists(name);
  }

References _propertiesMap_.

factor()

template<GUM_Numeric GUM_SCALAR>

virtual const Tensor< GUM_SCALAR > & gum::IMarkovRandomField< GUM_SCALAR >::factor ( const NodeSet & varIds ) const

pure virtual

Returns the factor of a set of variable.

Exceptions

NotFound

If no variable's id matches varId.

Referenced by operator==(), and toString().

Here is the caller graph for this function:

factors()

template<GUM_Numeric GUM_SCALAR>

virtual const FactorTable< GUM_SCALAR > & gum::IMarkovRandomField< GUM_SCALAR >::factors ( ) const

pure virtual

Returns the set of factors as a IMarkovRandomField::FactorTable.

References IMarkovRandomField().

Referenced by dim(), maxNonOneParam(), maxParam(), minNonZeroParam(), minParam(), operator==(), toDotAsFactorGraph(), and toString().

Here is the call graph for this function:

Here is the caller graph for this function:

family() [1/2]

INLINE NodeSet gum::UGmodel::family ( const NodeId id ) const

finalvirtualinherited

returns the node as a NodeSet (in mixed graph : family is the node and its parents

Parameters

id	the node which is the head of an arc with the returned nodes
name	the name of the node the node which is the head of an arc with the returned nodes

Implements gum::GraphicalModel.

Definition at line 113 of file UGmodel_inl.h.

                                                      {
    // family is the set of the note and its parent. So for a completely undirected model, it is
    // just the node.
    return gum::NodeSet{id};
  }

Referenced by family().

Here is the caller graph for this function:

family() [2/2]

INLINE NodeSet gum::UGmodel::family ( std::string_view name ) const

finalvirtualinherited

Implements gum::GraphicalModel.

Definition at line 119 of file UGmodel_inl.h.

{ return family(idFromName(name)); }

References family(), and gum::DiscreteGraphicalModel::idFromName().

Here is the call graph for this function:

graph()

INLINE UndiGraph gum::UGmodel::graph ( ) const

nodiscardinherited

Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.

O(n) — allocates a new graph. For a stable reference (listeners, long-lived pointers), use internalGraph().

Definition at line 61 of file UGmodel_inl.h.

                                 {
    UndiGraph g = graph_;
    _nameNodes_(g);
    return g;
  }

References gum::GraphicalModel::_nameNodes_(), and graph_.

Referenced by gum::MarginalTargetedMRFInference< GUM_SCALAR >::MarginalTargetedMRFInference(), and gum::IMarkovRandomField< GUM_SCALAR >::toString().

Here is the call graph for this function:

Here is the caller graph for this function:

hasSameStructure()

bool gum::UGmodel::hasSameStructure ( const UGmodel & other ) const

inherited

check if nodes X and nodes Y are independent given nodes Z

Returns

true if all the named node are the same and all the named arcs are the same

Definition at line 82 of file UGmodel.cpp.

                                                           {
    if (this == &other) return true;
 
    if (size() != other.size()) return false;
 
    if (sizeEdges() != other.sizeEdges()) return false;
 
    for (const auto& nid: nodes()) {
      if (!other.exists(variable(nid).name())) return false;
    }
 
    for (const auto& edge: edges()) {
      if (!other.edges().exists(Edge(other.idFromName(variable(edge.first()).name()),
                                     other.idFromName(variable(edge.second()).name()))))
        return false;
    }
 
    return true;
  }

References UGmodel(), edges(), gum::Set< Key >::exists(), exists(), gum::DiscreteGraphicalModel::idFromName(), nodes(), size(), sizeEdges(), and gum::DiscreteGraphicalModel::variable().

Here is the call graph for this function:

idFromName()

INLINE NodeId gum::DiscreteGraphicalModel::idFromName ( std::string_view name ) const

overridevirtualinherited

Returns the NodeId of a variable given its name.

Exceptions

NotFound

if no such name exists in the model.

Implements gum::GraphicalModel.

Reimplemented in gum::InfluenceDiagram< GUM_SCALAR >, and gum::prm::InstanceBayesNet< GUM_SCALAR >.

Definition at line 61 of file discreteGraphicalModel_inl.h.

                                                                     {
    return varMap_.idFromName(name);
  }

References varMap_.

Referenced by gum::ASTposteriorProba< GUM_SCALAR >::_compute_knw_from_bn(), gum::DAGmodel::ancestors(), gum::InfluenceDiagram< GUM_SCALAR >::clear(), gum::ASTjointProba< GUM_SCALAR >::eval(), gum::ASTposteriorProba< GUM_SCALAR >::eval(), gum::ASTsum< GUM_SCALAR >::eval(), gum::UGmodel::exists(), gum::DAGmodel::existsArc(), gum::UGmodel::existsEdge(), gum::DAGmodel::family(), gum::UGmodel::family(), gum::DAGmodel::hasSameStructure(), gum::MarkovBlanket::hasSameStructure(), gum::UGmodel::hasSameStructure(), gum::DAGmodel::isIndependent(), gum::UGmodel::isIndependent(), gum::DAGmodel::minimalCondSet(), gum::UGmodel::neighbours(), gum::IBayesNet< GUM_SCALAR >::operator==(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::DAGmodel::parents(), and gum::IMarkovRandomField< GUM_SCALAR >::smallestFactorFromNode().

Here is the caller graph for this function:

ids()

INLINE std::vector< NodeId > gum::GraphicalModel::ids ( const std::vector< std::string > & names ) const

inherited

transform a vector of names into a vector of nodeId

Returns

the vector of names

Definition at line 139 of file graphicalModel_inl.h.

                                                                                   {
    std::vector< NodeId >  res;
    const VariableNodeMap& v = variableNodeMap();
    std::transform(names.cbegin(),
                   names.cend(),
                   std::back_inserter(res),
                   [&v](const std::string& n) { return v.idFromName(n); });
    return res;
  }

References names(), and variableNodeMap().

Referenced by gum::DAGmodel::children(), exists(), names(), names(), and gum::DAGmodel::parents().

Here is the call graph for this function:

Here is the caller graph for this function:

internalGraph()

INLINE const UndiGraph & gum::UGmodel::internalGraph ( ) const

inherited

Returns a const reference to the internal (unnamed) graph. O(1), no copy. Use for stable references or pointers (graph listeners). For named node access, use graph() instead.

Definition at line 58 of file UGmodel_inl.h.

{ return graph_; }

References graph_.

isIndependent() [1/4]

INLINE bool gum::UGmodel::isIndependent ( const NodeSet & X, const NodeSet & Y, const NodeSet & Z ) const

finalvirtualinherited

check if nodes X and nodes Y are independent given nodes Z

Implements gum::GraphicalModel.

Definition at line 105 of file UGmodel_inl.h.

                                                                                               {
    return !graph_.hasUndirectedPath(X, Y, Z);
  }

References graph_.

isIndependent() [2/4]

INLINE bool gum::UGmodel::isIndependent ( const std::vector< std::string > & Xnames, const std::vector< std::string > & Ynames, const std::vector< std::string > & Znames ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 127 of file UGmodel_inl.h.

                                                                                 {
    return isIndependent(nodeset(Xnames), nodeset(Ynames), nodeset(Znames));
  }

References isIndependent(), and gum::GraphicalModel::nodeset().

Here is the call graph for this function:

isIndependent() [3/4]

INLINE bool gum::UGmodel::isIndependent ( NodeId X, NodeId Y, const NodeSet & Z ) const

finalvirtualinherited

check if X and Y are independent given Z

Implements gum::GraphicalModel.

Definition at line 101 of file UGmodel_inl.h.

                                                                               {
    return !graph_.hasUndirectedPath(X, Y, Z);
  }

References graph_.

Referenced by isIndependent(), and isIndependent().

Here is the caller graph for this function:

isIndependent() [4/4]

INLINE bool gum::UGmodel::isIndependent ( std::string_view Xname, std::string_view Yname, const std::vector< std::string > & Znames ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 121 of file UGmodel_inl.h.

                                                                                 {
    return isIndependent(idFromName(Xname), idFromName(Yname), nodeset(Znames));
  }

References gum::DiscreteGraphicalModel::idFromName(), isIndependent(), and gum::GraphicalModel::nodeset().

Here is the call graph for this function:

log10DomainSize()

INLINE double gum::GraphicalModel::log10DomainSize ( ) const

inherited

Definition at line 93 of file graphicalModel_inl.h.

                                               {
    double dSize = 0.0;
 
    for (const auto node: nodes()) {
      dSize += std::log10(variable(node).domainSize());
    }
 
    return dSize;
  }

References nodes().

Referenced by gum::IMarkovRandomField< GUM_SCALAR >::toString(), and gum::InfluenceDiagram< GUM_SCALAR >::toString().

Here is the call graph for this function:

Here is the caller graph for this function:

maxNonOneParam()

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::IMarkovRandomField< GUM_SCALAR >::maxNonOneParam

(

)

const

Returns

the biggest value (not equal to 1) in the CPTs of *this

Definition at line 140 of file IMarkovRandomField_tpl.h.

                                                                    {
    GUM_SCALAR res = 0.0;
    for (auto elt: factors()) {
      auto v = elt.second->maxNonOne();
      if (v > res) { res = v; }
    }
    return res;
  }

References factors().

Here is the call graph for this function:

maxParam()

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::IMarkovRandomField< GUM_SCALAR >::maxParam

(

)

const

Returns

the biggest value in the CPTs of *this

Definition at line 120 of file IMarkovRandomField_tpl.h.

                                                              {
    GUM_SCALAR res = 1.0;
    for (auto elt: factors()) {
      auto v = elt.second->max();
      if (v > res) { res = v; }
    }
    return res;
  }

References factors().

Here is the call graph for this function:

maxVarDomainSize()

template<GUM_Numeric GUM_SCALAR>

Size gum::IMarkovRandomField< GUM_SCALAR >::maxVarDomainSize

(

)

const

Returns

the biggest domainSize among the variables of *this

Definition at line 100 of file IMarkovRandomField_tpl.h.

                                                                {
    Size res = 0;
    for (auto node: nodes()) {
      auto v = variable(node).domainSize();
      if (v > res) { res = v; }
    }
    return res;
  }

References gum::UGmodel::nodes(), and gum::DiscreteGraphicalModel::variable().

Here is the call graph for this function:

minimalCondSet() [1/2]

template<GUM_Numeric GUM_SCALAR>

NodeSet gum::IMarkovRandomField< GUM_SCALAR >::minimalCondSet	(	const NodeSet &	targets,
		const NodeSet &	soids ) const

Definition at line 349 of file IMarkovRandomField_tpl.h.

                                                                                       {
    NodeSet res;
    for (auto node: targets) {
      res += minimalCondSet(node, soids);
    }
    return res;
  }

References minimalCondSet().

Here is the call graph for this function:

minimalCondSet() [2/2]

template<GUM_Numeric GUM_SCALAR>

NodeSet gum::IMarkovRandomField< GUM_SCALAR >::minimalCondSet	(	NodeId	target,
		const NodeSet &	soids ) const

Definition at line 335 of file IMarkovRandomField_tpl.h.

                                                                                       {
    if (soids.contains(target)) return NodeSet({target});
 
    NodeSet res;
    NodeSet alreadyVisited;
    alreadyVisited << target;
 
    for (auto neig: graph_.neighbours(target))
      _minimalCondSetVisit_(neig, soids, res, alreadyVisited);
    return res;
  }

References _minimalCondSetVisit_(), gum::Set< Key >::contains(), and gum::UGmodel::graph_.

Referenced by minimalCondSet().

Here is the call graph for this function:

Here is the caller graph for this function:

minNonZeroParam()

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::IMarkovRandomField< GUM_SCALAR >::minNonZeroParam

(

)

const

Returns

the smallest value (not equal to 0) in the CPTs of *this

Definition at line 130 of file IMarkovRandomField_tpl.h.

                                                                     {
    GUM_SCALAR res = 1.0;
    for (auto elt: factors()) {
      auto v = elt.second->minNonZero();
      if (v < res) { res = v; }
    }
    return res;
  }

References factors().

Here is the call graph for this function:

minParam()

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::IMarkovRandomField< GUM_SCALAR >::minParam

(

)

const

Returns

the smallest value in the CPTs of *this

Definition at line 110 of file IMarkovRandomField_tpl.h.

                                                              {
    GUM_SCALAR res = 1.0;
    for (auto elt: factors()) {
      auto v = elt.second->min();
      if (v < res) { res = v; }
    }
    return res;
  }

References factors().

Here is the call graph for this function:

names() [1/2]

INLINE std::vector< std::string > gum::GraphicalModel::names ( const NodeSet & ids ) const

inherited

transform a NodeSet in a vector of names

Returns

the vector of names

Definition at line 129 of file graphicalModel_inl.h.

                                                                       {
    const VariableNodeMap&     v = variableNodeMap();
    std::vector< std::string > res;
    for (auto n: ids) {
      res.push_back(v.name(n));
    }
    return res;
  }

References ids(), gum::VariableNodeMap::name(), and variableNodeMap().

Here is the call graph for this function:

names() [2/2]

INLINE std::vector< std::string > gum::GraphicalModel::names ( const std::vector< NodeId > & ids ) const

inherited

transform a vector of NodeId in a vector of names

Returns

the vector of names

Definition at line 117 of file graphicalModel_inl.h.

                                                                                   {
    std::vector< std::string > res;
    const VariableNodeMap&     v = variableNodeMap();
 
    std::ranges::transform(ids, std::back_inserter(res), [&v](const NodeId n) {
      return v[n].name();
    });
 
    return res;
  }

References ids().

Referenced by gum::DAGmodel::children(), exists(), ids(), nodeset(), and gum::DAGmodel::parents().

Here is the call graph for this function:

Here is the caller graph for this function:

neighbours() [1/2]

INLINE const NodeSet & gum::UGmodel::neighbours ( const NodeId id ) const

inherited

returns the neighbours of a node as set of nodes

Note that the set of nodes returned may be empty if no edge within the EdgeGraphPart contains the given node.

Parameters

id	the node toward which the edge returned are pointing

Definition at line 83 of file UGmodel_inl.h.

{ return graph_.neighbours(id); }

References graph_.

Referenced by neighbours(), and gum::IMarkovRandomField< GUM_SCALAR >::toDot().

Here is the caller graph for this function:

neighbours() [2/2]

INLINE const NodeSet & gum::UGmodel::neighbours ( std::string_view name ) const

inherited

return true if the edge node1-node2 exists in the UGModel

Parameters

node1	the nodeId (or the name) of the node1
node2	the nodeId (or the name) of the node2

Returns

true if the edge exists

Definition at line 85 of file UGmodel_inl.h.

                                                                     {
    return neighbours(idFromName(name));
  }

References gum::DiscreteGraphicalModel::idFromName(), and neighbours().

Here is the call graph for this function:

nodeId()

INLINE NodeId gum::DiscreteGraphicalModel::nodeId ( const DiscreteVariable & var ) const

overridevirtualinherited

Returns the NodeId of a variable.

Exceptions

NotFound

if no variable matches var.

Implements gum::GraphicalModel.

Reimplemented in gum::InfluenceDiagram< GUM_SCALAR >, and gum::prm::InstanceBayesNet< GUM_SCALAR >.

Definition at line 56 of file discreteGraphicalModel_inl.h.

                                                                         {
    return varMap_.get(var);
  }

References varMap_.

Referenced by gum::InfluenceDiagram< GUM_SCALAR >::clear(), gum::BayesBall::relevantTensors(), and gum::dSeparationAlgorithm::relevantTensors().

Here is the caller graph for this function:

nodes()

INLINE const NodeGraphPart & gum::UGmodel::nodes ( ) const

finalvirtualinherited

Returns a named copy of the internal undirected graph: each node id is assigned the name of the corresponding variable.

O(n) — allocates a new graph. For a stable reference (listeners, long-lived pointers), use internalGraph().

Implements gum::GraphicalModel.

Definition at line 97 of file UGmodel_inl.h.

                                                   {
    return static_cast< const NodeGraphPart& >(graph_);
  }

References graph_.

Referenced by hasSameStructure(), gum::IMarkovRandomField< GUM_SCALAR >::maxVarDomainSize(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::IMarkovRandomField< GUM_SCALAR >::toDot(), and gum::IMarkovRandomField< GUM_SCALAR >::toDotAsFactorGraph().

Here is the caller graph for this function:

nodeset()

NodeSet gum::GraphicalModel::nodeset ( const std::vector< std::string > & names ) const

inherited

transform a vector of names into a NodeSet

Returns

NodeSet

Definition at line 102 of file graphicalModel.cpp.

                                                                           {
    NodeSet res;
    for (const auto& name: names) {
      res.insert(idFromName(name));
    }
    return res;
  }

References idFromName(), gum::Set< Key >::insert(), and names().

Referenced by gum::BayesNet< double >::ancestors(), gum::DAGmodel::children(), gum::DAGmodel::isIndependent(), gum::UGmodel::isIndependent(), gum::UGmodel::isIndependent(), gum::DAGmodel::minimalCondSet(), and gum::DAGmodel::moralizedAncestralGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

template<GUM_Numeric GUM_SCALAR>

IMarkovRandomField< GUM_SCALAR > & gum::IMarkovRandomField< GUM_SCALAR >::operator=

(

const IMarkovRandomField< GUM_SCALAR > &

source

)

Copy operator.

Definition at line 79 of file IMarkovRandomField_tpl.h.

                                                                                              {
    if (this != &source) { UGmodel::operator=(source); }
 
    return *this;
  }

References IMarkovRandomField(), and gum::UGmodel::operator=().

Here is the call graph for this function:

operator==()

template<GUM_Numeric GUM_SCALAR>

bool gum::IMarkovRandomField< GUM_SCALAR >::operator==

(

const IMarkovRandomField< GUM_SCALAR > &

from

)

const

This operator compares 2 BNs !

Warning

To identify nodes between BNs, it is assumed that they share the same name.

Returns

true if the src and this are equal.

Definition at line 257 of file IMarkovRandomField_tpl.h.

                                                                                      {
    if (size() != from.size()) { return false; }
 
    if (sizeEdges() != from.sizeEdges()) { return false; }
 
    // alignment of variables between the 2 BNs
    Bijection< const DiscreteVariable*, const DiscreteVariable* > alignment;
 
    for (auto node: nodes()) {
      const auto& v1 = variable(node);
      if (!from.exists(v1.name())) return false;
      const auto& v2 = from.variableFromName(v1.name());
      if (v1 != v2) return false;
 
      alignment.insert(&variable(node), &from.variableFromName(v1.name()));
    }
 
    for (const auto& elt: factors()) {
      const auto& key    = elt.first;
      const auto& factor = *elt.second;
 
      NodeSet fromkey;
      for (const auto n: key)
        fromkey.insert(from.idFromName(variable(n).name()));
 
      if (!from.factors().exists(fromkey)) { return false; }
 
      const auto& fromfactor = from.factor(fromkey);
 
      Instantiation i(factor);
      Instantiation j(fromfactor);
      for (i.setFirst(); !i.end(); i.inc()) {
        for (Idx indice = 0; indice < factor.nbrDim(); ++indice) {
          const DiscreteVariable* p = &(i.variable(indice));
          j.chgVal(*(alignment.second(p)), i.val(*p));
        }
 
        if (std::pow(factor.get(i) - fromfactor.get(j), (GUM_SCALAR)2) > (GUM_SCALAR)1e-6) {
          return false;
        }
      }
    }
    return true;
  }

References IMarkovRandomField(), gum::Instantiation::chgVal(), gum::Instantiation::end(), gum::UGmodel::exists(), factor(), factors(), gum::DiscreteGraphicalModel::idFromName(), gum::Instantiation::inc(), gum::BijectionImplementation< T1, T2, Gen >::insert(), gum::Set< Key >::insert(), gum::UGmodel::nodes(), gum::BijectionImplementation< T1, T2, Gen >::second(), gum::Instantiation::setFirst(), gum::UGmodel::size(), gum::UGmodel::sizeEdges(), gum::Instantiation::val(), gum::DiscreteGraphicalModel::variable(), gum::Instantiation::variable(), and gum::DiscreteGraphicalModel::variableFromName().

Here is the call graph for this function:

properties()

INLINE std::vector< std::string > gum::GraphicalModel::properties ( ) const

inherited

List of all the names of property in the Graphical model.

Definition at line 79 of file graphicalModel_inl.h.

                                                          {
    std::vector< std::string > prop;
    for (const auto& [p, v]: _propertiesMap_)
      prop.push_back(p);
    return prop;
  }

References _propertiesMap_.

property()

INLINE const std::string & gum::GraphicalModel::property ( std::string_view name ) const

inherited

Return the value of the property name of this GraphicalModel.

Exceptions

NotFound

Raised if no name property is found.

Definition at line 60 of file graphicalModel_inl.h.

                                                                     {
    auto p = _properties_().tryGet(name);
    if (!p) { GUM_ERROR(NotFound, "The following property does not exists: " << name) }
    return *p;
  }

References _properties_(), GUM_ERROR, and gum::HashTable< Key, Val >::tryGet().

Here is the call graph for this function:

propertyWithDefault()

INLINE const std::string & gum::GraphicalModel::propertyWithDefault ( std::string_view name, const std::string & byDefault ) const

inherited

Return the value of the property name of this GraphicalModel.

return byDefault if the property name is not found

Definition at line 72 of file graphicalModel_inl.h.

                                                                                           {
    auto p = _propertiesMap_.tryGet(name);
    return p ? *p : byDefault;
  }

References _propertiesMap_.

Referenced by gum::IBayesNet< GUM_SCALAR >::toDot(), gum::IMarkovRandomField< GUM_SCALAR >::toDot(), gum::InfluenceDiagram< GUM_SCALAR >::toDot(), and gum::IMarkovRandomField< GUM_SCALAR >::toDotAsFactorGraph().

Here is the caller graph for this function:

setProperty()

INLINE void gum::GraphicalModel::setProperty ( std::string_view name, std::string_view value )

inherited

Add or change a property of this GraphicalModel.

Definition at line 87 of file graphicalModel_inl.h.

                                                                            {
    if (auto p = _propertiesMap_.tryGet(name)) *p = value;
    else _propertiesMap_.insert(std::string(name), std::string(value));
  }

References _propertiesMap_.

Referenced by gum::IBayesNet< GUM_SCALAR >::IBayesNet(), gum::IMarkovRandomField< GUM_SCALAR >::IMarkovRandomField(), gum::BayesNet< GUM_SCALAR >::fastPrototype(), and gum::InfluenceDiagram< GUM_SCALAR >::fastPrototype().

Here is the caller graph for this function:

size()

INLINE Size gum::UGmodel::size ( ) const

finalvirtualinherited

Returns the number of variables in this Directed Graphical Model.

Implements gum::GraphicalModel.

Definition at line 68 of file UGmodel_inl.h.

{ return graph_.size(); }

References graph_.

Referenced by hasSameStructure(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::IMarkovRandomField< GUM_SCALAR >::toDot(), and gum::IMarkovRandomField< GUM_SCALAR >::toString().

Here is the caller graph for this function:

sizeEdges()

INLINE Size gum::UGmodel::sizeEdges ( ) const

inherited

Returns the number of arcs in this Directed Graphical Model.

Definition at line 71 of file UGmodel_inl.h.

{ return graph_.sizeEdges(); }

References graph_.

Referenced by hasSameStructure(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), and gum::IMarkovRandomField< GUM_SCALAR >::toString().

Here is the caller graph for this function:

smallestFactorFromNode() [1/2]

template<GUM_Numeric GUM_SCALAR>

virtual const NodeSet & gum::IMarkovRandomField< GUM_SCALAR >::smallestFactorFromNode ( NodeId node ) const

pure virtual

Returns the smallest factor that contains this variable.

Exceptions

NotFound

If no variable's id matches varId.

Referenced by smallestFactorFromNode().

Here is the caller graph for this function:

smallestFactorFromNode() [2/2]

template<GUM_Numeric GUM_SCALAR>

const NodeSet & gum::IMarkovRandomField< GUM_SCALAR >::smallestFactorFromNode ( std::string_view name ) const

virtual

Returns the smallest factor that contains this variable.

Exceptions

NotFound

If no variable's id matches varId.

Definition at line 310 of file IMarkovRandomField_tpl.h.

                                                                                        {
    if (!this->exists(name)) {
      GUM_ERROR(NotFound, "No factor containing the variable <" << name << ">")
    }
    return smallestFactorFromNode(idFromName(name));
  }

References gum::UGmodel::exists(), GUM_ERROR, gum::DiscreteGraphicalModel::idFromName(), and smallestFactorFromNode().

Here is the call graph for this function:

spaceCplxToString()

std::string gum::GraphicalModel::spaceCplxToString ( double dSize, int dim, Size usedMem )

staticinherited

send to the stream the space complexity with 3 parametrs

Parameters

s	the stream
dSize	the log10domainSize
dim	the dimension
usedMem	the memory needed for the params

Definition at line 110 of file graphicalModel.cpp.

                                                                                 {
    std::string result;
    if (dSize > 6) result = std::format("domainSize: 10^{:.6g}", dSize);
    else result = std::format("domainSize: {}", (long long)std::round(std::pow(10.0, dSize)));
 
    result += std::format(", dim: {}, mem: ", dim);
 
    if (const Size go = usedMem / (1024 * 1024 * 1024); go > 0) result += std::format("{}Go ", go);
    if (const Size mo = (usedMem / (1024 * 1024)) % 1024; mo > 0)
      result += std::format("{}Mo ", mo);
    if (const Size ko = (usedMem / 1024) % 1024; ko > 0) result += std::format("{}Ko ", ko);
    result += std::format("{}o", usedMem % 1024);
    return result;
  }

toDot()

template<GUM_Numeric GUM_SCALAR>

std::string gum::IMarkovRandomField< GUM_SCALAR >::toDot ( ) const

virtual

Returns

Returns a dot representation of this IMarkovRandomField.

Definition at line 169 of file IMarkovRandomField_tpl.h.

                                                          {
    std::stringstream output;
 
    std::string mn_name = this->propertyWithDefault("name", "no_name");
 
    output << std::format("graph \"{}\" {{\n", mn_name);
    output << std::format("  graph [bgcolor=transparent,label=\"{}\"];\n", mn_name);
    output << "  node [style=filled fillcolor=\"#ffffaa\"];" << std::endl << std::endl;
 
    for (auto node: nodes())
      output << std::format("  \"{}\" [comment=\"{}:{}\"];\n",
                            variable(node).name(),
                            node,
                            variable(node).toStringWithDescription());
 
    output << std::endl;
 
    std::string tab = "  ";
 
    for (auto node: nodes()) {
      if (neighbours(node).size() > 0) {
        for (auto nei: neighbours(node)) {
          if (variable(node).name() < variable(nei).name()) {
            output << std::format("  \"{}\" -- \"{}\";\n",
                                  variable(node).name(),
                                  variable(nei).name());
          }
        }
      } else {
        output << std::format("  \"{}\";\n", variable(node).name());
      }
    }
 
    output << "}" << std::endl;
 
    return output.str();
  }

References gum::UGmodel::neighbours(), gum::UGmodel::nodes(), gum::GraphicalModel::propertyWithDefault(), gum::UGmodel::size(), and gum::DiscreteGraphicalModel::variable().

Here is the call graph for this function:

toDotAsFactorGraph()

template<GUM_Numeric GUM_SCALAR>

std::string gum::IMarkovRandomField< GUM_SCALAR >::toDotAsFactorGraph ( ) const

virtual

Returns

Returns a dot representation of this IMarkovRandomField.

Definition at line 208 of file IMarkovRandomField_tpl.h.

                                                                       {
    std::stringstream output;
    std::string       mn_name = this->propertyWithDefault("name", "no_name");
 
    output << std::format("graph FG_{} {{\n", mn_name);
    output << "  layout=neato;" << std::endl;
    output << std::format("  graph [bgcolor=transparent,label=\"factor graph for {}\"];\n",
                          mn_name);
 
    // the variables
    output << "  node [shape=rectangle,margin=0.04,width=0,height=0, "
              "style=filled,color=\"coral\"];"
           << std::endl;
    for (auto nod: nodes()) {
      output << std::format("\"{}\";\n", variable(nod).name());
    }
    output << std::endl;
 
    // the factor
    output << "node[shape = point,width = 0.1,height = 0.1,style = filled,color = "
              "\"burlywood\"];"
           << std::endl;
    for (const auto& kv: factors()) {
      output << "  \"f";
      for (NodeId nod: kv.first) {
        output << "#" << variable(nod).name();
      }
      output << "\";" << std::endl;
    }
 
    // the link variable--factors
    output << "  edge[len = 0.7];" << std::endl;
    for (const auto& kv: factors()) {
      std::string clicname = "\"f";
      for (NodeId nod: kv.first) {
        clicname += "#";
        clicname += variable(nod).name();
      }
      clicname += "\"";
 
      for (NodeId nod: kv.first)
        output << std::format("  {} -- \"{}\";\n", clicname, variable(nod).name());
    }
    output << "}" << std::endl;
 
    return output.str();
  }

References factors(), gum::UGmodel::nodes(), gum::GraphicalModel::propertyWithDefault(), and gum::DiscreteGraphicalModel::variable().

Here is the call graph for this function:

toString()

template<GUM_Numeric GUM_SCALAR>

std::string gum::IMarkovRandomField< GUM_SCALAR >::toString

(

)

const

Returns

Returns a string representation of this IMarkovRandomField.

Definition at line 150 of file IMarkovRandomField_tpl.h.

                                                             {
    Size   param = 0;
    double dSize = log10DomainSize();
 
    for (auto factor: factors())
      param += factor.second->content()->realSize();
 
    std::stringstream s;
    s << std::format("MRF{{nodes: {}, edges: {}, ", size(), graph().sizeEdges());
 
    if (dSize > 6) s << std::format("domainSize: 10^{}", dSize);
    else s << std::format("domainSize: {}", std::round(std::pow(10.0, dSize)));
 
    s << std::format(", dim: {}}}", param);
 
    return s.str();
  }

References factor(), factors(), gum::UGmodel::graph(), gum::GraphicalModel::log10DomainSize(), gum::UGmodel::size(), and gum::UGmodel::sizeEdges().

Referenced by gum::operator<<().

Here is the call graph for this function:

Here is the caller graph for this function:

updateMetaData()

void gum::GraphicalModel::updateMetaData ( )

inherited

update the meta data of this Graphical Model (version, creation date, last modification date) This method is called by the writers ONLY before writing the model to a file.

Definition at line 81 of file graphicalModel.cpp.

                                      {
    auto const time = std::chrono::time_point_cast< std::chrono::milliseconds >(
        std::chrono::system_clock::now());
    auto const currentdate = std::format("{:%Y-%m-%d %T}", time);
 
    const std::string currentSoftware = "aGrUM " GUM_VERSION;
    if (auto software = _propertiesMap_.tryGet("software")) {
      *software = currentSoftware;
    } else {
      _propertiesMap_.insert("software", currentSoftware);
    }
 
    if (!_propertiesMap_.tryGet("creation")) { _propertiesMap_.insert("creation", currentdate); }
 
    if (auto lastModification = _propertiesMap_.tryGet("lastModification")) {
      *lastModification = currentdate;
    } else {
      _propertiesMap_.insert("lastModification", currentdate);
    }
  }

References _propertiesMap_.

variable()

INLINE const DiscreteVariable & gum::DiscreteGraphicalModel::variable ( NodeId id ) const

overridevirtualinherited

Returns a constant reference over a variable given its node id.

Exceptions

NotFound

if no variable's id matches id.

Implements gum::GraphicalModel.

Reimplemented in gum::InfluenceDiagram< GUM_SCALAR >, and gum::prm::InstanceBayesNet< GUM_SCALAR >.

Definition at line 51 of file discreteGraphicalModel_inl.h.

                                                                          {
    return varMap_.get(id);
  }

References varMap_.

Referenced by gum::Estimator< GUM_SCALAR >::Estimator(), gum::ASTposteriorProba< GUM_SCALAR >::_compute_knw_from_bn(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_insertEvidence_(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_verticesSampling_(), gum::IBayesNet< GUM_SCALAR >::check(), gum::InfluenceDiagram< GUM_SCALAR >::clear(), gum::IBayesNet< GUM_SCALAR >::dim(), gum::ASTsum< GUM_SCALAR >::eval(), gum::DAGmodel::hasSameStructure(), gum::UGmodel::hasSameStructure(), gum::IBayesNet< GUM_SCALAR >::maxVarDomainSize(), gum::IMarkovRandomField< GUM_SCALAR >::maxVarDomainSize(), gum::IBayesNet< GUM_SCALAR >::operator==(), gum::IMarkovRandomField< GUM_SCALAR >::operator==(), gum::Estimator< GUM_SCALAR >::setFromBN(), gum::IMarkovRandomField< GUM_SCALAR >::toDot(), and gum::IMarkovRandomField< GUM_SCALAR >::toDotAsFactorGraph().

Here is the caller graph for this function:

variableFromName()

INLINE const DiscreteVariable & gum::DiscreteGraphicalModel::variableFromName ( std::string_view name ) const

overridevirtualinherited

Returns a constant reference over a variable given its name.

Exceptions

NotFound

if no such name exists in the model.

Implements gum::GraphicalModel.

Reimplemented in gum::InfluenceDiagram< GUM_SCALAR >, and gum::prm::InstanceBayesNet< GUM_SCALAR >.

Definition at line 66 of file discreteGraphicalModel_inl.h.

                                                                                            {
    return varMap_.variableFromName(name);
  }

References varMap_.

Referenced by gum::InfluenceDiagram< GUM_SCALAR >::clear(), gum::IBayesNet< GUM_SCALAR >::evEq(), gum::IBayesNet< GUM_SCALAR >::evGt(), gum::IBayesNet< GUM_SCALAR >::evIn(), gum::IBayesNet< GUM_SCALAR >::evLt(), gum::IBayesNet< GUM_SCALAR >::operator==(), and gum::IMarkovRandomField< GUM_SCALAR >::operator==().

Here is the caller graph for this function:

variableNodeMap()

INLINE const VariableNodeMap & gum::DiscreteGraphicalModel::variableNodeMap ( ) const

overridevirtualinherited

Returns a constant reference to the VariableNodeMap of this model.

Implements gum::GraphicalModel.

Reimplemented in gum::InfluenceDiagram< GUM_SCALAR >, and gum::prm::InstanceBayesNet< GUM_SCALAR >.

Definition at line 48 of file discreteGraphicalModel_inl.h.

{ return varMap_; }

References varMap_.

Referenced by gum::InfluenceDiagram< GUM_SCALAR >::clear().

Here is the caller graph for this function:

variables() [1/2]

INLINE VariableSet gum::GraphicalModel::variables ( const NodeSet & ids ) const

inherited

transform a vector of NodeId into a VariableeSet

Returns

NodeSet

Definition at line 160 of file graphicalModel_inl.h.

                                                              {
    VariableSet            s;
    const VariableNodeMap& v = variableNodeMap();
    for (const auto& node: l) {
      s.insert(&v.get(node));
    }
    return s;
  }

variables() [2/2]

INLINE VariableSet gum::GraphicalModel::variables ( const std::vector< std::string > & l ) const

inherited

transform a vector of names into a VariableeSet

Returns

NodeSet

Definition at line 150 of file graphicalModel_inl.h.

                                                                             {
    VariableSet            s;
    const VariableNodeMap& v = variableNodeMap();
    for (const auto& name: l) {
      s.insert(&v.variableFromName(name));
    }
    return s;
  }

References gum::Set< Key >::insert(), gum::VariableNodeMap::variableFromName(), and variableNodeMap().

Here is the call graph for this function:

Member Data Documentation

_propertiesMap_

HashTable< std::string, std::string > gum::GraphicalModel::_propertiesMap_

privateinherited

The properties of this Directed Graphical Model.

Definition at line 262 of file graphicalModel.h.

Referenced by GraphicalModel(), GraphicalModel(), _properties_(), existsProperty(), operator=(), operator=(), properties(), propertyWithDefault(), setProperty(), and updateMetaData().

graph_

UndiGraph gum::UGmodel::graph_

protectedinherited

The DAG of this Directed Graphical Model.

Definition at line 195 of file UGmodel.h.

Referenced by UGmodel(), UGmodel(), gum::IMarkovRandomField< GUM_SCALAR >::_minimalCondSetVisit_(), connectedComponents(), edges(), exists(), existsEdge(), graph(), internalGraph(), isIndependent(), isIndependent(), gum::IMarkovRandomField< GUM_SCALAR >::minimalCondSet(), neighbours(), nodes(), operator=(), operator=(), size(), and sizeEdges().

varMap_

VariableNodeMap gum::DiscreteGraphicalModel::varMap_

protectedinherited

Mapping between NodeIds and discrete variables.

Definition at line 119 of file discreteGraphicalModel.h.

Referenced by DiscreteGraphicalModel(), DiscreteGraphicalModel(), gum::BayesNet< GUM_SCALAR >::add(), gum::InfluenceDiagram< GUM_SCALAR >::addNode_(), gum::InfluenceDiagram< GUM_SCALAR >::changeVariableName(), gum::BayesNet< GUM_SCALAR >::erase(), gum::BayesNet< GUM_SCALAR >::erase(), gum::InfluenceDiagram< GUM_SCALAR >::erase(), gum::InfluenceDiagram< GUM_SCALAR >::erase(), gum::BayesNet< GUM_SCALAR >::eraseArc(), idFromName(), nodeId(), operator=(), operator=(), gum::BayesNet< GUM_SCALAR >::reverseArc(), variable(), variableFromName(), and variableNodeMap().

---

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

• agrum/MRF/IMarkovRandomField.h
• agrum/MRF/IMarkovRandomField_tpl.h