Class representing an Influence Diagram. More...

#include <agrum/ID/influenceDiagram.h>

Inheritance diagram for gum::InfluenceDiagram< GUM_SCALAR >:

Collaboration diagram for gum::InfluenceDiagram< GUM_SCALAR >:

Public Member Functions
std::string	toDot () const

std::string	toString () const

void	clear ()

bool	hasSameStructure (const DAGmodel &other)

double	log10DomainSize () const

Constructors / Destructors
	InfluenceDiagram ()
	Default constructor. More...

	~InfluenceDiagram () override
	Destructor. More...

	InfluenceDiagram (const InfluenceDiagram< GUM_SCALAR > &source)
	Copy Constructor. More...

InfluenceDiagram< GUM_SCALAR > &	operator= (const InfluenceDiagram< GUM_SCALAR > &source)
	Copy Operator. More...

Variable manipulation methods.
virtual const Potential< GUM_SCALAR > &	cpt (NodeId varId) const
	Returns the CPT of a potential variable. More...

virtual const Potential< GUM_SCALAR > &	cpt (std::string name) const final
	Returns the CPT of a potential variable. More...

virtual const Potential< GUM_SCALAR > &	utility (NodeId varId) const
	Returns the utility table of a utility node. More...

virtual const Potential< GUM_SCALAR > &	utility (std::string name) const final
	Returns the CPT of a potential variable. More...

const VariableNodeMap &	variableNodeMap () const final
	Returns a constant reference to the VariableNodeMap of this Influence Diagram. More...

bool	isUtilityNode (NodeId varId) const
	Returns true if node is a utility one. More...

bool	isUtilityNode (const std::string &name) const
	Returns the CPT of a potential variable. More...

bool	isDecisionNode (NodeId varId) const
	Returns true if node is a decision one. More...

bool	isDecisionNode (const std::string &name) const
	Returns the CPT of a potential variable. More...

bool	isChanceNode (NodeId varId) const
	Returns true if node is a chance one. More...

bool	isChanceNode (const std::string &name) const
	Returns the CPT of a potential variable. More...

Size	utilityNodeSize () const
	Returns the number of utility nodes. More...

Size	chanceNodeSize () const
	Returns the number of chance nodes. More...

Size	decisionNodeSize () const
	Returns the number of decision nodes. More...

const DiscreteVariable &	variable (NodeId id) const final
	Returns a constant reference over a variable given it's node id. More...

NodeId	nodeId (const DiscreteVariable &var) const final
	Return id node from discrete var pointer. More...

NodeId	idFromName (const std::string &name) const final
	Getter by name. More...

const DiscreteVariable &	variableFromName (const std::string &name) const final
	Getter by name. More...

NodeId	add (const DiscreteVariable &variable, NodeId id=0)
	Add a chance variable, it's associate node and it's CPT. More...

NodeId	addChanceNode (const DiscreteVariable &variable, NodeId id=0)
	Add a chance variable, it's associate node and it's CPT. More...

NodeId	addUtilityNode (const DiscreteVariable &variable, NodeId id=0)
	Add a utility variable, it's associate node and it's UT. More...

NodeId	addDecisionNode (const DiscreteVariable &variable, NodeId id=0)
	Add a decision variable. More...

NodeId	addChanceNode (const DiscreteVariable &variable, MultiDimImplementation< GUM_SCALAR > *aContent, NodeId id=0)
	Add a chance variable, it's associate node and it's CPT. More...

NodeId	addUtilityNode (const DiscreteVariable &variable, MultiDimImplementation< GUM_SCALAR > *aContent, NodeId id=0)
	Add a chance variable, it's associate node and it's CPT. More...

void	erase (NodeId id)
	Erase a Variable from the network and remove the variable from all his children. More...

void	erase (const std::string &name)
	Returns the CPT of a potential variable. More...

void	erase (const DiscreteVariable &var)
	Erase a Variable from the network and remove the variable from all his children. More...

void	changeVariableName (NodeId id, const std::string &new_name)
	we allow the user to change the name of a variable More...

void	changeVariableName (const std::string &name, const std::string &new_name)
	Returns the CPT of a potential variable. More...

Arc manipulation methods.
void	addArc (NodeId tail, NodeId head)
	Add an arc in the ID, and update diagram's potential nodes cpt if necessary. More...

void	addArc (const std::string &tail, const std::string &head)
	Add an arc in the ID, and update diagram's potential nodes cpt if necessary. More...

void	eraseArc (const Arc &arc)
	Removes an arc in the ID, and update diagram's potential nodes cpt if necessary. More...

void	eraseArc (NodeId tail, NodeId head)
	Removes an arc in the ID, and update diagram's potential nodes cpt if necessary. More...

void	eraseArc (const std::string &tail, const std::string &head)
	Add an arc in the ID, and update diagram's potential nodes cpt if necessary. More...

Decisions methods
bool	decisionOrderExists () const
	True if a directed path exist with all decision nodes. More...

gum::DAG *	getDecisionGraph () const
	Returns the temporal Graph. More...

std::vector< NodeId >	decisionOrder () const
	Returns the sequence of decision nodes in the directed path. More...

bool	existsPathBetween (NodeId src, NodeId dest) const
	Returns true if a path exists between two nodes. More...

bool	existsPathBetween (const std::string &src, const std::string &dest) const
	True if a directed path exist with all decision nodes. More...

const List< NodeSet > &	getPartialTemporalOrder (bool clear=true) const
	Returns partial temporal ordering. More...

Variable manipulation methods.
const DAG &	dag () const
	Returns a constant reference to the dag of this Bayes Net. More...

virtual Size	size () const final
	Returns the number of variables in this Directed Graphical Model. More...

Size	sizeArcs () const
	Returns the number of arcs in this Directed Graphical Model. More...

const NodeGraphPart &	nodes () const final
	Returns a constant reference to the dag of this Bayes Net. More...

bool	exists (NodeId node) const final
	Return true if this node exists in this graphical model. More...

Variable manipulation methods.
bool	exists (const std::string &name) const
	Return true if this graphical model is empty. More...

virtual bool	empty () const
	Return true if this graphical model is empty. More...

std::vector< std::string >	names (const std::vector< NodeId > &ids) const
	transform a vector of NodeId in a vector of names More...

std::vector< std::string >	names (const NodeSet &ids) const
	transform a NodeSet in a vector of names More...

std::vector< NodeId >	ids (const std::vector< std::string > &names) const
	transform a vector of names into a vector of nodeId More...

NodeSet	nodeset (const std::vector< std::string > &names) const
	transform a vector of names into a NodeSet More...

Instantiation	completeInstantiation () const
	Get an instantiation over all the variables of the model. More...

Arc manipulation methods.
const ArcSet &	arcs () const
	return true if the arc tail->head exists in the DAGmodel More...

bool	existsArc (const NodeId tail, const NodeId head) const
	return true if the arc tail->head exists in the DAGmodel More...

bool	existsArc (const std::string &nametail, const std::string &namehead) const
	return true if the arc tail->head exists in the DAGmodel More...

const NodeSet &	parents (const NodeId id) const
	returns the set of nodes with arc ingoing to a given node More...

const NodeSet &	parents (const std::string &name) const
	return true if the arc tail->head exists in the DAGmodel More...

NodeSet	parents (const NodeSet &ids) const
	returns the parents of a set of nodes More...

NodeSet	parents (const std::vector< std::string > &names) const
	return true if the arc tail->head exists in the DAGmodel More...

NodeSet	family (const NodeId id) const
	returns the parents of a node and the node More...

NodeSet	family (const std::string &name) const
	return true if the arc tail->head exists in the DAGmodel More...

const NodeSet &	children (const NodeId id) const
	returns the set of nodes with arc outgoing from a given node More...

const NodeSet &	children (const std::string &name) const
	return true if the arc tail->head exists in the DAGmodel More...

NodeSet	children (const NodeSet &ids) const
	returns the children of a set of nodes More...

NodeSet	children (const std::vector< std::string > &names) const
	return true if the arc tail->head exists in the DAGmodel More...

NodeSet	descendants (const NodeId id) const
	returns the set of nodes with directed path outgoing from a given node More...

NodeSet	descendants (const std::string &name) const
	return true if the arc tail->head exists in the DAGmodel More...

NodeSet	ancestors (const NodeId id) const
	returns the set of nodes with directed path ingoing to a given node More...

NodeSet	ancestors (const std::string &name) const
	return true if the arc tail->head exists in the DAGmodel More...

Graphical methods
UndiGraph	moralizedAncestralGraph (const NodeSet &nodes) const
	build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes More...

UndiGraph	moralizedAncestralGraph (const std::vector< std::string > &nodenames) const
	build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes More...

bool	isIndependent (NodeId X, NodeId Y, const NodeSet &Z) const final
	check if node X and node Y are independent given nodes Z More...

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 More...

bool	isIndependent (const std::string &Xname, const std::string &Yname, const std::vector< std::string > &Znames) const
	build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes More...

bool	isIndependent (const std::vector< std::string > &Xnames, const std::vector< std::string > &Ynames, const std::vector< std::string > &Znames) const
	build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes More...

const UndiGraph &	moralGraph (bool clear=true) const
	The node's id are coherent with the variables and nodes of the topology. More...

const Sequence< NodeId > &	topologicalOrder (bool clear=true) const
	The topological order stays the same as long as no variable or arcs are added or erased src the topology. More...

Getter and setters
const std::string &	property (const std::string &name) const
	Return the value of the property name of this GraphicalModel. More...

const std::string &	propertyWithDefault (const std::string &name, const std::string &byDefault) const
	Return the value of the property name of this GraphicalModel. More...

void	setProperty (const std::string &name, const std::string &value)
	Add or change a property of this GraphicalModel. More...

Static Public Member Functions
static InfluenceDiagram< GUM_SCALAR >	fastPrototype (const std::string &dotlike, Size domainSize=2)
	Create an Influence Diagram with a dot-like syntax which specifies: More...

Protected Attributes
DAG	dag_
	The DAG of this Directed Graphical Model. More...

Protected Member Functions
virtual void	moralGraph_ (UndiGraph &graph) const
	Returns the moral graph of this InfluenceDiagram. More...

void	removeTables_ ()
	Removing ancient table. More...

void	copyStructureAndTables_ (const InfluenceDiagram< GUM_SCALAR > &IDsource)
	Copying tables from another influence diagram. More...

NodeId	addNode_ (const DiscreteVariable &variableType, NodeId DesiredId)
	Add a node. More...

Sequence< NodeId >	getChildrenDecision_ (NodeId parentDecision) const
	Returns the list of children decision for a given nodeId. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::InfluenceDiagram< GUM_SCALAR >

Class representing an Influence Diagram.

Definition at line 53 of file influenceDiagram.h.

Constructor & Destructor Documentation

◆ InfluenceDiagram() [1/2]

template<typename GUM_SCALAR >

INLINE gum::InfluenceDiagram< GUM_SCALAR >::InfluenceDiagram ( )

Default constructor.

Definition at line 204 of file influenceDiagram_tpl.h.

                                                           : DAGmodel() {
     GUM_CONSTRUCTOR(InfluenceDiagram);
   }

◆ ~InfluenceDiagram()

template<typename GUM_SCALAR >

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

override

Destructor.

Definition at line 212 of file influenceDiagram_tpl.h.

                                                     {
     GUM_DESTRUCTOR(InfluenceDiagram);
     removeTables_();
   }

◆ InfluenceDiagram() [2/2]

template<typename GUM_SCALAR >

gum::InfluenceDiagram< GUM_SCALAR >::InfluenceDiagram ( const InfluenceDiagram< GUM_SCALAR > & source )

Copy Constructor.

Definition at line 221 of file influenceDiagram_tpl.h.

                                                    {
     GUM_CONS_CPY(InfluenceDiagram);
     copyStructureAndTables_(source);
   }

Member Function Documentation

◆ add()

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::add	(	const DiscreteVariable &	variable,
		NodeId	id = `0`
	)

Add a chance variable, it's associate node and it's CPT.

The id of the new variable is automatically generated.

The implementation of the Potential is by default a MultiDimArray.

Parameters

variable	The variable added by copy.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Returns: the id of the added variable.

Exceptions

DuplicateElement if id(<>0) is already used

Definition at line 501 of file influenceDiagram_tpl.h.

                                                                             {
     return addChanceNode(var, varId);
   }

◆ addArc() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::InfluenceDiagram< GUM_SCALAR >::addArc	(	NodeId	tail,
		NodeId	head
	)

Add an arc in the ID, and update diagram's potential nodes cpt if necessary.

Parameters

head	and
tail	as NodeId

Exceptions

InvalidEdge	If arc.tail and/or arc.head are not in the ID.
InvalidEdge	if tail is a utility node

Definition at line 681 of file influenceDiagram_tpl.h.

                                                                              {
     if (isUtilityNode(tail)) {
       GUM_ERROR(InvalidArc, "Tail cannot be a utility node")
     }
 
     dag_.addArc(tail, head);
 
     if (isChanceNode(head))
       // Add parent in the child's CPT
       (*(potentialMap__[head])) << variable(tail);
     else if (isUtilityNode(head)) {
       // Add parent in the child's UT
       (*(utilityMap__[head])) << variable(tail);
     }
   }

◆ addArc() [2/2]

template<typename GUM_SCALAR>

void gum::InfluenceDiagram< GUM_SCALAR >::addArc	(	const std::string &	tail,
		const std::string &	head
	)

inline

Add an arc in the ID, and update diagram's potential nodes cpt if necessary.

Parameters

head	and
tail	as NodeId

Exceptions

InvalidEdge	If arc.tail and/or arc.head are not in the ID.
InvalidEdge	if tail is a utility node

Definition at line 346 of file influenceDiagram.h.

                                                               {
       addArc(idFromName(tail), idFromName(head));
     }

◆ addChanceNode() [1/2]

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addChanceNode	(	const DiscreteVariable &	variable,
		NodeId	id = `0`
	)

Add a chance variable, it's associate node and it's CPT.

The id of the new variable is automatically generated.

The implementation of the Potential is by default a MultiDimArray.

Parameters

variable	The variable added by copy.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Returns: the id of the added variable.

Exceptions

DuplicateElement if id(<>0) is already used

Definition at line 544 of file influenceDiagram_tpl.h.

                                                                      {
     auto   newMultiDim = new MultiDimArray< GUM_SCALAR >();
     NodeId res;
 
     try {
       res = addChanceNode(var, newMultiDim, varId);
     } catch (Exception&) {
       delete newMultiDim;
       throw;
     }
 
     return res;
   }

◆ addChanceNode() [2/2]

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addChanceNode	(	const DiscreteVariable &	variable,
		MultiDimImplementation< GUM_SCALAR > *	aContent,
		NodeId	id = `0`
	)

Add a chance variable, it's associate node and it's CPT.

The id of the new variable is automatically generated.

Parameters

variable	The variable added by copy.
aContent	The content used for the variable potential.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Returns: the id of the added variable.

Exceptions

DuplicateElement if id(<>0) is already used

Definition at line 564 of file influenceDiagram_tpl.h.

                                                       {
     NodeId proposedId = addNode_(var, DesiredId);
 
     auto varcpt = new Potential< GUM_SCALAR >(aContent);
     (*varcpt) << variable(proposedId);
     potentialMap__.insert(proposedId, varcpt);
 
     return proposedId;
   }

◆ addDecisionNode()

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addDecisionNode	(	const DiscreteVariable &	variable,
		NodeId	id = `0`
	)

Add a decision variable.

The id of the new variable is automatically generated.

Parameters

variable	The variable added by copy.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Returns: the id of the added variable.

Exceptions

DuplicateElement if id(<>0) is already used

Definition at line 534 of file influenceDiagram_tpl.h.

                                                                    {
     return addNode_(var, varId);
   }

◆ addNode_()

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addNode_	(	const DiscreteVariable &	variableType,
		NodeId	DesiredId
	)

protected

Add a node.

Definition at line 609 of file influenceDiagram_tpl.h.

                                                                                  {
     // None thread safe code!
     NodeId proposedId;
 
     if (DesiredId == 0)
       proposedId = dag_.nextNodeId();
     else
       proposedId = DesiredId;
 
     variableMap__.insert(proposedId, variableType);
 
     dag_.addNodeWithId(proposedId);
 
     // end critical section
     return proposedId;
   }

◆ addUtilityNode() [1/2]

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addUtilityNode	(	const DiscreteVariable &	variable,
		NodeId	id = `0`
	)

Add a utility variable, it's associate node and it's UT.

The id of the new variable is automatically generated.

The implementation of the Utility is by default a MultiDimArray.

Parameters

variable	The variable added by copy.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Returns: the id of the added variable.

Exceptions

InvalidArgument	If variable has more than one label
DuplicateElement	if id(<>0) is already used

Definition at line 513 of file influenceDiagram_tpl.h.

                                                                   {
     auto   newMultiDim = new MultiDimArray< GUM_SCALAR >();
     NodeId res;
 
     try {
       res = addUtilityNode(var, newMultiDim, varId);
     } catch (Exception&) {
       if (newMultiDim != nullptr) delete newMultiDim;
       throw;
     }
 
     return res;
   }

◆ addUtilityNode() [2/2]

template<typename GUM_SCALAR >

NodeId gum::InfluenceDiagram< GUM_SCALAR >::addUtilityNode	(	const DiscreteVariable &	variable,
		MultiDimImplementation< GUM_SCALAR > *	aContent,
		NodeId	id = `0`
	)

Add a chance variable, it's associate node and it's CPT.

The id of the new variable is automatically generated.

Parameters

variable	The variable added by copy.
aContent	The content used for the variable utility.
id	The chosen id. If 0, the NodeGraphPart will choose.

Warning: give an id (not 0) should be reserved for rare and specific situations !!!

Exceptions

InvalidArgument	If variable has more than one label
DuplicateElement	if id(<>0) is already used

Definition at line 583 of file influenceDiagram_tpl.h.

                                                       {
     if (var.domainSize() != 1) {
       GUM_ERROR(InvalidArgument,
                 "Utility var have no state ( which implicates a "
                 "single label for data output reasons ).")
     }
 
     NodeId proposedId = addNode_(var, DesiredId);
 
     auto varut = new Potential< GUM_SCALAR >(aContent);
 
     (*varut) << variable(proposedId);
 
     utilityMap__.insert(proposedId, varut);
 
     return proposedId;
   }

◆ ancestors() [1/2]

INLINE NodeSet gum::DAGmodel::ancestors ( const NodeId id ) const

inherited

returns the set of nodes with directed path ingoing to a given node

Note that the set of nodes returned may be empty if no path within the ArcGraphPart is ingoing to the given node.

Parameters

id	the node which is the head of a directed path with the returned nodes
name	the name of the node which is the head of a directed path with the returned nodes

Definition at line 112 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                           {
     return dag().ancestors(id);
   }

Here is the call graph for this function:

◆ ancestors() [2/2]

INLINE NodeSet gum::DAGmodel::ancestors ( const std::string & name ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 116 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
     return ancestors(idFromName(name));
   }

Here is the call graph for this function:

◆ arcs()

INLINE const ArcSet & gum::DAGmodel::arcs ( ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 43 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

43 { return dag_.arcs(); }

gum::DAGmodel::dag_

DAG dag_

The DAG of this Directed Graphical Model.

Definition: DAGmodel.h:225

gum::ArcGraphPart::arcs

const ArcSet & arcs() const

returns the set of arcs stored within the ArcGraphPart

Definition: arcGraphPart_inl.h:38

Here is the call graph for this function:

◆ chanceNodeSize()

template<typename GUM_SCALAR >

INLINE Size gum::InfluenceDiagram< GUM_SCALAR >::chanceNodeSize ( ) const

Returns the number of chance nodes.

Definition at line 442 of file influenceDiagram_tpl.h.

                                                                    {
     return potentialMap__.size();
   }

◆ changeVariableName() [1/2]

template<typename GUM_SCALAR >

INLINE void gum::InfluenceDiagram< GUM_SCALAR >::changeVariableName	(	NodeId	id,
		const std::string &	new_name
	)

we allow the user to change the name of a variable

Exceptions

DuplicateLabel	if this name already exists
NotFound	Raised if no nodes matches id.

Definition at line 668 of file influenceDiagram_tpl.h.

                                 {
     variableMap__.changeName(id, new_name);
   }

◆ changeVariableName() [2/2]

template<typename GUM_SCALAR>

void gum::InfluenceDiagram< GUM_SCALAR >::changeVariableName	(	const std::string &	name,
		const std::string &	new_name
	)

inline

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 326 of file influenceDiagram.h.

                                                                               {
       changeVariableName(idFromName(name), new_name);
     }

◆ children() [1/4]

INLINE const NodeSet & gum::DAGmodel::children ( const NodeId id ) const

inherited

returns the set of nodes with arc outgoing from a given node

Note that the set of nodes returned may be empty if no node is outgoing from the given node.

Parameters

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

Definition at line 70 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
     return dag_.children(id);
   }

Here is the call graph for this function:

◆ children() [2/4]

INLINE const NodeSet & gum::DAGmodel::children ( const std::string & name ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 73 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                       {
     return dag_.children(idFromName(name));
   }

Here is the call graph for this function:

◆ children() [3/4]

INLINE NodeSet gum::DAGmodel::children ( const NodeSet & ids ) const

inherited

returns the children of a set of nodes

Definition at line 77 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                             {
     return dag_.children(ids);
   }

Here is the call graph for this function:

◆ children() [4/4]

INLINE NodeSet gum::DAGmodel::children ( const std::vector< std::string > & names ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 82 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                  {
     return children(nodeset(names));
   }

Here is the call graph for this function:

◆ clear()

template<typename GUM_SCALAR>

void gum::InfluenceDiagram< GUM_SCALAR >::clear ( )

◆ completeInstantiation()

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

inherited

Get an instantiation over all the variables of the model.

Definition at line 86 of file graphicalModel_inl.h.

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

◆ copyStructureAndTables_()

template<typename GUM_SCALAR >

void gum::InfluenceDiagram< GUM_SCALAR >::copyStructureAndTables_ ( const InfluenceDiagram< GUM_SCALAR > & IDsource )

protected

Copying tables from another influence diagram.

Definition at line 269 of file influenceDiagram_tpl.h.

                                                      {
     for (auto node: IDsource.nodes()) {
       if (IDsource.isChanceNode(node))
         addChanceNode(IDsource.variable(node), node);
       else if (IDsource.isUtilityNode(node))
         addUtilityNode(IDsource.variable(node), node);
       else   // decision node
         addDecisionNode(IDsource.variable(node), node);
     }
     // we add arc in the same order of the potentials
     for (auto node: IDsource.nodes()) {
       const auto& s = IDsource.variable(node).name();
       if (IDsource.isChanceNode(node)) {
         for (Idx par = 1; par <= IDsource.parents(node).size(); par++)
           addArc(IDsource.cpt(node).variable(par).name(), s);
       } else if (IDsource.isUtilityNode(node)) {
         for (Idx par = 1; par <= IDsource.parents(node).size(); par++)
           addArc(IDsource.utility(node).variable(par).name(), s);
       } else {   // decision node
         // here the order does not depends on a Potential
         for (NodeId par: IDsource.parents(node))
           addArc(par, node);
       }
     }
 
     // Copying potentials
     for (auto node: IDsource.nodes()) {
       const auto& s = IDsource.variable(node).name();
       if (IDsource.isChanceNode(node)) {
         cpt(node).fillWith(IDsource.cpt(s));
       } else if (IDsource.isUtilityNode(node)) {
         utility(node).fillWith(IDsource.utility(s));
       }
     }
   }

◆ cpt() [1/2]

template<typename GUM_SCALAR >

INLINE const Potential< GUM_SCALAR > & gum::InfluenceDiagram< GUM_SCALAR >::cpt ( NodeId varId ) const

virtual

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 389 of file influenceDiagram_tpl.h.

                                                                      {
     return *(potentialMap__[varId]);
   }

◆ cpt() [2/2]

template<typename GUM_SCALAR>

virtual const Potential< GUM_SCALAR >& gum::InfluenceDiagram< GUM_SCALAR >::cpt ( std::string name ) const

inlinefinalvirtual

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 131 of file influenceDiagram.h.

                                                                            {
       return cpt(idFromName(name));
     };

◆ dag()

INLINE const DAG & gum::DAGmodel::dag ( ) const

inherited

Returns a constant reference to the dag of this Bayes Net.

Definition at line 35 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

35 { return dag_; }

gum::DAGmodel::dag_

DAG dag_

The DAG of this Directed Graphical Model.

Definition: DAGmodel.h:225

Here is the call graph for this function:

◆ decisionNodeSize()

template<typename GUM_SCALAR >

INLINE Size gum::InfluenceDiagram< GUM_SCALAR >::decisionNodeSize ( ) const

Returns the number of decision nodes.

Definition at line 450 of file influenceDiagram_tpl.h.

                                                                      {
     return (size() - utilityMap__.size() - potentialMap__.size());
   }

◆ decisionOrder()

template<typename GUM_SCALAR >

std::vector< NodeId > gum::InfluenceDiagram< GUM_SCALAR >::decisionOrder ( ) const

Returns the sequence of decision nodes in the directed path.

Exceptions

NotFound if such a path does not exist

Definition at line 883 of file influenceDiagram_tpl.h.

                                                                           {
     if (!decisionOrderExists()) { GUM_ERROR(NotFound, "No decision path exists") }
 
     std::vector< NodeId > decisionSequence;
 
     for (const auto elt: topologicalOrder(false))
       if (isDecisionNode(elt)) decisionSequence.push_back(elt);
 
     return decisionSequence;
   }

◆ decisionOrderExists()

template<typename GUM_SCALAR >

bool gum::InfluenceDiagram< GUM_SCALAR >::decisionOrderExists ( ) const

True if a directed path exist with all decision nodes.

Definition at line 754 of file influenceDiagram_tpl.h.

                                                                  {
     const Sequence< NodeId >& order = topologicalOrder(true);
 
     // Finding first decision node
     Sequence< NodeId >::const_iterator orderIter = order.begin();
 
     while ((orderIter != order.end()) && (!isDecisionNode(*orderIter)))
       ++orderIter;
 
     if (orderIter == order.end()) return true;
 
     NodeId parentDecision = (*orderIter);
     ++orderIter;
 
     // Checking path between decisions nodes
     while (orderIter != order.end()) {
       if (isDecisionNode(*orderIter)) {
         if (!existsPathBetween(parentDecision, *orderIter)) return false;
 
         parentDecision = *orderIter;
       }
 
       ++orderIter;
     }
 
     return true;
   }

◆ descendants() [1/2]

INLINE NodeSet gum::DAGmodel::descendants ( const NodeId id ) const

inherited

returns the set of nodes with directed path outgoing from a given node

Note that the set of nodes returned may be empty if no path within the ArcGraphPart is outgoing from the given node.

Parameters

id	the node which is the tail of a directed path with the returned nodes
name	the name of the node which is the tail of a directed path with the returned nodes

Definition at line 104 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                             {
     return dag().descendants(id);
   }

Here is the call graph for this function:

◆ descendants() [2/2]

INLINE NodeSet gum::DAGmodel::descendants ( const std::string & name ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 108 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                   {
     return descendants(idFromName(name));
   }

Here is the call graph for this function:

◆ empty()

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

virtualinherited

Return true if this graphical model is empty.

Definition at line 96 of file graphicalModel_inl.h.

96 { return size() == 0; }

gum::GraphicalModel::size

virtual Size size() const =0

Returns the number of variables in this Directed Graphical Model.

◆ erase() [1/3]

template<typename GUM_SCALAR >

void gum::InfluenceDiagram< GUM_SCALAR >::erase ( NodeId id )

Erase a Variable from the network and remove the variable from all his children.

If no variable matches the id, then nothing is done.

Parameters

id	The id of the variable to erase.

Definition at line 633 of file influenceDiagram_tpl.h.

                                                          {
     if (variableMap__.exists(varId)) {
       // Reduce the variable child's CPT or Utility Table if necessary
       for (const auto chi: dag_.children(varId))
         if (isChanceNode(chi))
           potentialMap__[chi]->erase(variable(varId));
         else if (isUtilityNode(chi))
           utilityMap__[chi]->erase(variable(varId));
 
       if (isChanceNode(varId)) {
         delete potentialMap__[varId];
         potentialMap__.erase(varId);
       } else if (isUtilityNode(varId)) {
         delete utilityMap__[varId];
         utilityMap__.erase(varId);
       }
 
       variableMap__.erase(varId);
       dag_.eraseNode(varId);
     }
   }

◆ erase() [2/3]

template<typename GUM_SCALAR>

void gum::InfluenceDiagram< GUM_SCALAR >::erase ( const std::string & name )

inline

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 310 of file influenceDiagram.h.

310 { erase(idFromName(name)); };

gum::InfluenceDiagram::idFromName

NodeId idFromName(const std::string &name) const final

Getter by name.

Definition: influenceDiagram_tpl.h:485

gum::InfluenceDiagram::erase

void erase(NodeId id)

Erase a Variable from the network and remove the variable from all his children.

Definition: influenceDiagram_tpl.h:633

◆ erase() [3/3]

template<typename GUM_SCALAR >

INLINE void gum::InfluenceDiagram< GUM_SCALAR >::erase ( const DiscreteVariable & var )

Erase a Variable from the network and remove the variable from all his children.

If no variable matches, then nothing is done.

Parameters

var	The reference on the variable to remove.

Definition at line 661 of file influenceDiagram_tpl.h.

                                                                                {
     erase(variableMap__.get(var));
   }

◆ eraseArc() [1/3]

template<typename GUM_SCALAR >

INLINE void gum::InfluenceDiagram< GUM_SCALAR >::eraseArc ( const Arc & arc )

Removes an arc in the ID, and update diagram's potential nodes cpt if necessary.

If (tail, head) doesn't exist, the nothing happens.

Parameters

arc	The arc removed.

Definition at line 703 of file influenceDiagram_tpl.h.

                                                                      {
     if (dag_.existsArc(arc)) {
       NodeId head = arc.head(), tail = arc.tail();
       dag_.eraseArc(arc);
 
       if (isChanceNode(head))
         // Removes parent in the child's CPT
         (*(potentialMap__[head])) >> variable(tail);
       else if (isUtilityNode(head))
         // Removes parent in the child's UT
         (*(utilityMap__[head])) >> variable(tail);
     }
   }

◆ eraseArc() [2/3]

template<typename GUM_SCALAR >

INLINE void gum::InfluenceDiagram< GUM_SCALAR >::eraseArc	(	NodeId	tail,
		NodeId	head
	)

Removes an arc in the ID, and update diagram's potential nodes cpt if necessary.

If (tail, head) doesn't exist, the nothing happens.

Parameters

head	and
tail	as NodeId

Definition at line 723 of file influenceDiagram_tpl.h.

                                                                                {
     eraseArc(Arc(tail, head));
   }

◆ eraseArc() [3/3]

template<typename GUM_SCALAR>

void gum::InfluenceDiagram< GUM_SCALAR >::eraseArc	(	const std::string &	tail,
		const std::string &	head
	)

inline

Add an arc in the ID, and update diagram's potential nodes cpt if necessary.

Parameters

head	and
tail	as NodeId

Exceptions

InvalidEdge	If arc.tail and/or arc.head are not in the ID.
InvalidEdge	if tail is a utility node

Definition at line 368 of file influenceDiagram.h.

                                                                 {
       eraseArc(idFromName(tail), idFromName(head));
     }

◆ exists() [1/2]

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

finalvirtualinherited

Return true if this node exists in this graphical model.

Implements gum::GraphicalModel.

Definition at line 94 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

94 { return dag_.exists(node); }

gum::NodeGraphPart::exists

bool exists(const NodeId id) const

alias for existsNode

Definition: nodeGraphPart_inl.h:291

gum::DAGmodel::dag_

DAG dag_

The DAG of this Directed Graphical Model.

Definition: DAGmodel.h:225

Here is the call graph for this function:

◆ exists() [2/2]

bool gum::GraphicalModel::exists ( const std::string & name ) const

inlineinherited

Return true if this graphical model is empty.

Definition at line 112 of file graphicalModel.h.

                                                      {
       return exists(idFromName(name));
     };

◆ existsArc() [1/2]

INLINE bool gum::DAGmodel::existsArc	(	const NodeId	tail,
		const NodeId	head
	)		const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 45 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                             {
     return dag_.existsArc(tail, head);
   }

Here is the call graph for this function:

◆ existsArc() [2/2]

INLINE bool gum::DAGmodel::existsArc	(	const std::string &	nametail,
		const std::string &	namehead
	)		const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 49 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                    {
     return existsArc(idFromName(nametail), idFromName(namehead));
   }

Here is the call graph for this function:

◆ existsPathBetween() [1/2]

template<typename GUM_SCALAR >

bool gum::InfluenceDiagram< GUM_SCALAR >::existsPathBetween	(	NodeId	src,
		NodeId	dest
	)		const

Returns true if a path exists between two nodes.

Definition at line 786 of file influenceDiagram_tpl.h.

                                                                             {
     List< NodeId > nodeFIFO;
     // mark[node] contains 0 if not visited
     // mark[node] = predecessor if visited
     NodeProperty< int > mark = dag_.nodesProperty((int)-1);
     NodeId              current;
 
     mark[src] = (int)src;
     nodeFIFO.pushBack(src);
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       for (const auto new_one: dag_.children(current)) {
         if (mark[new_one] != -1)
           continue;   // if this node is already marked, continue
 
         mark[new_one] = (int)current;
 
         if (new_one == dest) break;   // if we reach *orderIter, stop.
 
         nodeFIFO.pushBack(new_one);
       }
     }
 
     if (mark[dest] == -1) return false;
 
     return true;
   }

◆ existsPathBetween() [2/2]

template<typename GUM_SCALAR>

bool gum::InfluenceDiagram< GUM_SCALAR >::existsPathBetween	(	const std::string &	src,
		const std::string &	dest
	)		const

inline

True if a directed path exist with all decision nodes.

Definition at line 399 of file influenceDiagram.h.

                                                                               {
       return existsPathBetween(idFromName(src), idFromName(dest));
     }

◆ family() [1/2]

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

inherited

returns the parents of a node and the node

Note that the set of nodes returned may be empty if no arc within the ArcGraphPart is ingoing into the given node.

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

Definition at line 62 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                        {
     return dag_.family(id);
   }

Here is the call graph for this function:

◆ family() [2/2]

INLINE NodeSet gum::DAGmodel::family ( const std::string & name ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 66 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                              {
     return dag_.family(idFromName(name));
   }

Here is the call graph for this function:

◆ fastPrototype()

template<typename GUM_SCALAR >

InfluenceDiagram< GUM_SCALAR > gum::InfluenceDiagram< GUM_SCALAR >::fastPrototype	(	const std::string &	dotlike,
		Size	domainSize = `2`
	)

static

Create an Influence Diagram with a dot-like syntax which specifies:

the structure "a->*b->$c;b->d<-*e;".
the prefix of a variable can be :
- nothing : chance node (a,d)
- * : decision node (*b)
- $ : utility node ($c) *
the type of the chance or decision variables with different syntax:
- by default, a variable is a gum::RangeVariable using the default domainSize (second argument)
- with "a[10]", the variable is a gum::RangeVariable using 10 as domainSize (from 0 to 9)
- with "a[3,7]", the variable is a gum::RangeVariable using a domainSize from 3 to 7
- with "a[1,3.14,5,6.2]", the variable is a gum::DiscretizedVariable using the given ticks (at least 3 values)
- with "a{top|middle|bottom}", the variable is a gum::LabelizedVariable using the given labels.

Note that if the dot-like string contains such a specification more than once for a variable, the first specification will be used.

Parameters

dotlike	the string containing the specification
domainSize	the default domain size for chance and decision variables

Returns: the resulting influence diagram

Definition at line 158 of file influenceDiagram_tpl.h.

                                                                                   {
     gum::InfluenceDiagram< GUM_SCALAR > infdiag;
 
     for (const auto& chaine: split(dotlike, ";")) {
       NodeId lastId   = 0;
       bool   notfirst = false;
       for (const auto& souschaine: split(chaine, "->")) {
         bool forward = true;
         for (const auto& node: split(souschaine, "<-")) {
           auto idVar = build_node_for_ID(infdiag, node, domainSize);
           if (notfirst) {
             if (forward) {
               infdiag.addArc(lastId, idVar);
               forward = false;
             } else {
               infdiag.addArc(idVar, lastId);
             }
           } else {
             notfirst = true;
             forward  = false;
           }
           lastId = idVar;
         }
       }
     }
 
     for (const auto n: infdiag.nodes()) {
       if (infdiag.isChanceNode(n))
         infdiag.cpt(n).randomCPT();
       else if (infdiag.isUtilityNode(n)) {
         infdiag.utility(n).random().scale(50).translate(-10);
       }
     }
 
     infdiag.setProperty("name", "fastPrototype");
     return infdiag;
   }

◆ getChildrenDecision_()

template<typename GUM_SCALAR >

Sequence< NodeId > gum::InfluenceDiagram< GUM_SCALAR >::getChildrenDecision_ ( NodeId parentDecision ) const

protected

Returns the list of children decision for a given nodeId.

Definition at line 844 of file influenceDiagram_tpl.h.

                                   {
     Sequence< NodeId > childrenSeq;
 
     List< NodeId > nodeFIFO;
     NodeId         current;
 
     // mark[node] contains false if not visited
     // mark[node] contains true if visited
     NodeProperty< bool > mark = dag_.nodesProperty(false);
 
     mark[parentDecision] = true;
 
     nodeFIFO.pushBack(parentDecision);
 
     while (!nodeFIFO.empty()) {
       current = nodeFIFO.front();
       nodeFIFO.popFront();
 
       for (const auto new_one: dag_.children(current)) {
         if (mark[new_one]) continue;   // if this node is already marked, continue
 
         mark[new_one] = true;
 
         if (!isDecisionNode(new_one))
           nodeFIFO.pushBack(new_one);
         else
           childrenSeq.insert(new_one);
       }
     }
 
     return childrenSeq;
   }

◆ getDecisionGraph()

template<typename GUM_SCALAR >

gum::DAG * gum::InfluenceDiagram< GUM_SCALAR >::getDecisionGraph ( ) const

Returns the temporal Graph.

Definition at line 822 of file influenceDiagram_tpl.h.

                                                                  {
     auto temporalGraph = new gum::DAG();
 
     for (const auto node: dag_.nodes()) {
       if (isDecisionNode(node)) {
         if (!temporalGraph->existsNode(node)) temporalGraph->addNodeWithId(node);
 
         for (const auto chi: getChildrenDecision_(node)) {
           if (!temporalGraph->existsNode(chi)) temporalGraph->addNodeWithId(chi);
 
           temporalGraph->addArc(node, chi);
         }
       }
     }
 
     return temporalGraph;
   }

◆ getPartialTemporalOrder()

template<typename GUM_SCALAR >

const List< NodeSet > & gum::InfluenceDiagram< GUM_SCALAR >::getPartialTemporalOrder ( bool clear = true ) const

Returns partial temporal ordering.

Exceptions

NotFound if such a sequence does not exist

Definition at line 900 of file influenceDiagram_tpl.h.

                                                                              {
     if (clear) {
       temporalOrder__.clear();
 
       std::vector< NodeId > order    = decisionOrder();
       NodeSet               nodeList = dag_.asNodeSet();
 
       for (auto i: order) {
         NodeSet partialOrderedSet;
 
         for (const auto par: dag_.parents(i)) {
           if (nodeList.contains(par) && isChanceNode(par)) {
             partialOrderedSet.insert(par);
             nodeList.erase(par);
           }
         }
 
         if (!partialOrderedSet.empty())
           temporalOrder__.pushFront(partialOrderedSet);
 
         NodeSet decisionSet;
 
         decisionSet.insert(i);
 
         temporalOrder__.pushFront(decisionSet);
       }
 
       NodeSet lastSet;   //= new gum::NodeSet();
 
       for (const auto node: nodeList)
         if (isChanceNode(node)) lastSet.insert(node);
 
       if (!lastSet.empty()) temporalOrder__.pushFront(lastSet);
     }
 
     return temporalOrder__;
   }

◆ hasSameStructure()

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

inherited

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

Definition at line 74 of file DAGmodel.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                        {
     if (this == &other) return true;
 
     if (size() != other.size()) return false;
 
     if (sizeArcs() != other.sizeArcs()) return false;
 
     for (const auto& nid: nodes()) {
       try {
         other.idFromName(variable(nid).name());
       } catch (NotFound) { return false; }
     }
 
     for (const auto& arc: arcs()) {
       if (!other.arcs().exists(Arc(other.idFromName(variable(arc.tail()).name()),
                                    other.idFromName(variable(arc.head()).name()))))
         return false;
     }
 
     return true;
   }

Here is the call graph for this function:

◆ idFromName()

template<typename GUM_SCALAR >

INLINE NodeId gum::InfluenceDiagram< GUM_SCALAR >::idFromName ( const std::string & name ) const

finalvirtual

Getter by name.

Exceptions

NotFound if no such name exists in the graph.

Implements gum::GraphicalModel.

Definition at line 485 of file influenceDiagram_tpl.h.

                                                                            {
     return variableMap__.idFromName(name);
   }

◆ 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 122 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;
   }

◆ isChanceNode() [1/2]

template<typename GUM_SCALAR >

INLINE bool gum::InfluenceDiagram< GUM_SCALAR >::isChanceNode ( NodeId varId ) const

Returns true if node is a chance one.

Definition at line 426 of file influenceDiagram_tpl.h.

                                                                              {
     return potentialMap__.exists(varId);
   }

◆ isChanceNode() [2/2]

template<typename GUM_SCALAR>

bool gum::InfluenceDiagram< GUM_SCALAR >::isChanceNode ( const std::string & name ) const

inline

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 169 of file influenceDiagram.h.

                                                    {
       return isChanceNode(idFromName(name));
     };

◆ isDecisionNode() [1/2]

template<typename GUM_SCALAR >

INLINE bool gum::InfluenceDiagram< GUM_SCALAR >::isDecisionNode ( NodeId varId ) const

Returns true if node is a decision one.

Definition at line 414 of file influenceDiagram_tpl.h.

                                                                                {
     bool ret = true;
 
     if (isUtilityNode(varId) || isChanceNode(varId)) ret = false;
 
     return ret;
   }

◆ isDecisionNode() [2/2]

template<typename GUM_SCALAR>

bool gum::InfluenceDiagram< GUM_SCALAR >::isDecisionNode ( const std::string & name ) const

inline

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 161 of file influenceDiagram.h.

                                                      {
       return isDecisionNode(idFromName(name));
     };

◆ isIndependent() [1/4]

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

finalvirtualinherited

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

Implements gum::GraphicalModel.

Definition at line 131 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
     return dag().dSeparation(X, Y, Z);
   }

Here is the call graph for this function:

◆ isIndependent() [2/4]

INLINE bool gum::DAGmodel::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 135 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                               {
     return dag().dSeparation(X, Y, Z);
   }

Here is the call graph for this function:

◆ isIndependent() [3/4]

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

inlineinherited

build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes

Parameters

nodes	the set of nodeId
nodenames	the vector of names of nodes

Returns: the moralized ancestral graph

Definition at line 188 of file DAGmodel.h.

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

◆ isIndependent() [4/4]

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

inlineinherited

build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes

Parameters

nodes	the set of nodeId
nodenames	the vector of names of nodes

Returns: the moralized ancestral graph

Definition at line 194 of file DAGmodel.h.

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

◆ isUtilityNode() [1/2]

template<typename GUM_SCALAR >

INLINE bool gum::InfluenceDiagram< GUM_SCALAR >::isUtilityNode ( NodeId varId ) const

Returns true if node is a utility one.

Definition at line 406 of file influenceDiagram_tpl.h.

                                                                               {
     return utilityMap__.exists(varId);
   }

◆ isUtilityNode() [2/2]

template<typename GUM_SCALAR>

bool gum::InfluenceDiagram< GUM_SCALAR >::isUtilityNode ( const std::string & name ) const

inline

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 154 of file influenceDiagram.h.

                                                     {
       return isUtilityNode(idFromName(name));
     };

◆ log10DomainSize()

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

inherited

Definition at line 75 of file graphicalModel_inl.h.

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

◆ moralGraph()

const UndiGraph & gum::DAGmodel::moralGraph ( bool clear = true ) const

inherited

The node's id are coherent with the variables and nodes of the topology.

Parameters

clear If false returns the previously created moral graph.

Definition at line 58 of file DAGmodel.cpp.

References gum::Set< Key, Alloc >::emplace().

                                                         {
     if (clear
         || (mutableMoralGraph__
             == nullptr)) {   // we have to call dag().moralGraph()
       if (mutableMoralGraph__ == nullptr) {
         mutableMoralGraph__ = new UndiGraph();
       } else {
         // clear is True ,__mutableMoralGraph exists
         mutableMoralGraph__->clear();
       }
       *mutableMoralGraph__ = dag().moralGraph();
     }
 
     return *mutableMoralGraph__;
   }

Here is the call graph for this function:

◆ moralGraph_()

template<typename GUM_SCALAR >

void gum::InfluenceDiagram< GUM_SCALAR >::moralGraph_ ( UndiGraph & graph ) const

protectedvirtual

Returns the moral graph of this InfluenceDiagram.

Definition at line 735 of file influenceDiagram_tpl.h.

                                                                          {
     for (const auto node: dag_.nodes())
       if (!isUtilityNode(node)) graph.addNodeWithId(node);
 
     for (const auto node: dag_.nodes()) {
       if (!isDecisionNode(node))
         for (const auto par: dag_.parents(node)) {
           if (isChanceNode(node)) graph.addEdge(node, par);
 
           for (const auto par2: dag_.parents(node))
             if (par != par2) graph.addEdge(par, par2);
         }
     }
   }

◆ moralizedAncestralGraph() [1/2]

INLINE UndiGraph gum::DAGmodel::moralizedAncestralGraph ( const NodeSet & nodes ) const

inherited

build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes

Parameters

nodes	the set of nodeId
nodenames	the vector of names of nodes

Returns: the moralized ancestral graph

Definition at line 127 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
     return dag().moralizedAncestralGraph(nodes);
   }

Here is the call graph for this function:

◆ moralizedAncestralGraph() [2/2]

INLINE UndiGraph gum::DAGmodel::moralizedAncestralGraph ( const std::vector< std::string > & nodenames ) const

inherited

build a UndiGraph by moralizing the Ancestral Graph of a set of Nodes

Parameters

nodes	the set of nodeId
nodenames	the vector of names of nodes

Returns: the moralized ancestral graph

Definition at line 121 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                     {
     return moralizedAncestralGraph(nodeset(nodenames));
   }

Here is the call graph for this function:

◆ names() [1/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 100 of file graphicalModel_inl.h.

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

◆ names() [2/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 111 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;
   }

◆ nodeId()

template<typename GUM_SCALAR >

INLINE NodeId gum::InfluenceDiagram< GUM_SCALAR >::nodeId ( const DiscreteVariable & var ) const

finalvirtual

Return id node from discrete var pointer.

Exceptions

NotFound If no variable matches var.

Implements gum::GraphicalModel.

Definition at line 478 of file influenceDiagram_tpl.h.

                                                                              {
     return variableMap__.get(var);
   }

◆ nodes()

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

finalvirtualinherited

Returns a constant reference to the dag of this Bayes Net.

Implements gum::GraphicalModel.

Definition at line 96 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                     {
     return (NodeGraphPart&)dag_;
   }

Here is the call 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 63 of file graphicalModel.cpp.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

◆ operator=()

template<typename GUM_SCALAR >

InfluenceDiagram< GUM_SCALAR > & gum::InfluenceDiagram< GUM_SCALAR >::operator= ( const InfluenceDiagram< GUM_SCALAR > & source )

Copy Operator.

Definition at line 231 of file influenceDiagram_tpl.h.

                                                    {
     if (this != &source) {
       clear();
       // Copying tables and structure
       copyStructureAndTables_(source);
     }
 
     return *this;
   }

◆ parents() [1/4]

INLINE const NodeSet & gum::DAGmodel::parents ( const NodeId id ) const

inherited

returns the set of nodes with arc ingoing to a given node

Note that the set of nodes returned may be empty if no arc within the ArcGraphPart is ingoing into the given node.

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

Definition at line 54 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                {
     return dag_.parents(id);
   }

Here is the call graph for this function:

◆ parents() [2/4]

INLINE const NodeSet & gum::DAGmodel::parents ( const std::string & name ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 58 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                      {
     return parents(idFromName(name));
   }

Here is the call graph for this function:

◆ parents() [3/4]

INLINE NodeSet gum::DAGmodel::parents ( const NodeSet & ids ) const

inherited

returns the parents of a set of nodes

Definition at line 86 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                            {
     return dag_.children(ids);
   }

Here is the call graph for this function:

◆ parents() [4/4]

INLINE NodeSet gum::DAGmodel::parents ( const std::vector< std::string > & names ) const

inherited

return true if the arc tail->head exists in the DAGmodel

Parameters

tail	the nodeId (or the name) of the tail in tail->head
head	the nodeId (or the name) of the head in tail->head

Returns: true if the arc exists

Definition at line 90 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                             {
     return parents(nodeset(names));
   }

Here is the call graph for this function:

◆ property()

INLINE const std::string & gum::GraphicalModel::property ( const std::string & 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 38 of file graphicalModel_inl.h.

                                                                        {
     try {
       return properties__()[name];
     } catch (NotFound&) {
       std::string msg = "The following property does not exists: ";
       GUM_ERROR(NotFound, msg + name);
     }
   }

◆ propertyWithDefault()

INLINE const std::string & gum::GraphicalModel::propertyWithDefault	(	const std::string &	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 58 of file graphicalModel_inl.h.

                                                                            {
     try {
       return properties__()[name];
     } catch (NotFound&) { return byDefault; }
   }

◆ removeTables_()

template<typename GUM_SCALAR >

void gum::InfluenceDiagram< GUM_SCALAR >::removeTables_ ( )

protected

Removing ancient table.

Definition at line 256 of file influenceDiagram_tpl.h.

                                                      {
     for (const auto node: dag_.nodes()) {
       if (isChanceNode(node))
         delete &cpt(node);
       else if (isUtilityNode(node))
         delete &utility(node);
     }
   }

◆ setProperty()

INLINE void gum::GraphicalModel::setProperty	(	const std::string &	name,
		const std::string &	value
	)

inherited

Add or change a property of this GraphicalModel.

Definition at line 66 of file graphicalModel_inl.h.

                                                            {
     try {
       properties__()[name] = value;
     } catch (NotFound&) { properties__().insert(name, value); }
   }

◆ size()

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

finalvirtualinherited

Returns the number of variables in this Directed Graphical Model.

Implements gum::GraphicalModel.

Definition at line 38 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

38 { return dag().size(); }

gum::NodeGraphPart::size

Size size() const

alias for sizeNodes

Definition: nodeGraphPart_inl.h:283

gum::DAGmodel::dag

const DAG & dag() const

Returns a constant reference to the dag of this Bayes Net.

Definition: DAGmodel_inl.h:35

Here is the call graph for this function:

◆ sizeArcs()

INLINE Size gum::DAGmodel::sizeArcs ( ) const

inherited

Returns the number of arcs in this Directed Graphical Model.

Definition at line 41 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

41 { return dag_.sizeArcs(); }

gum::ArcGraphPart::sizeArcs

Size sizeArcs() const

indicates the number of arcs stored within the ArcGraphPart

Definition: arcGraphPart_inl.h:36

gum::DAGmodel::dag_

DAG dag_

The DAG of this Directed Graphical Model.

Definition: DAGmodel.h:225

Here is the call graph for this function:

◆ toDot()

template<typename GUM_SCALAR >

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

Returns: Returns a dot representation of this Influence Diagram.

Definition at line 307 of file influenceDiagram_tpl.h.

                                                         {
     std::stringstream output;
     std::stringstream decisionNode;
     std::stringstream utilityNode;
     std::stringstream chanceNode;
     std::stringstream arcstream;
     output << "digraph \"";
 
     try {
       output << this->property("name") << "\" {" << std::endl;
     } catch (NotFound&) { output << "no_name\" {" << std::endl; }
 
     output << "  node [bgcolor=\"#AAAAAA\", style=filled, height=0];" << std::endl;
 
     decisionNode << "node [shape = box];" << std::endl;
 
     utilityNode << "node [shape =  hexagon, margin=0];" << std::endl;
     chanceNode << "node [shape = ellipse];" << std::endl;
     std::string tab = "  ";
 
     for (const auto node: dag_.nodes()) {
       if (isChanceNode(node))
         chanceNode << tab << "\"" << node << "-" << variable(node).name() << "\""
                    << ";";
       else if (isUtilityNode(node))
         utilityNode << tab << "\"" << node << "-" << variable(node).name() << "\""
                     << ";";
       else
         decisionNode << tab << "\"" << node << "-" << variable(node).name() << "\""
                      << ";";
 
       if (dag_.children(node).size() > 0)
         for (const auto chi: dag_.children(node)) {
           arcstream << "\"" << node << "-" << variable(node).name() << "\""
                     << " -> "
                     << "\"" << chi << "-" << variable(chi).name() << "\"";
           if (isDecisionNode(chi)) { arcstream << " [style=\"tapered, bold\"]"; }
           arcstream << ";" << std::endl;
         }
     }
 
     output << decisionNode.str() << std::endl
            << utilityNode.str() << std::endl
            << chanceNode.str() << std::endl
            << std::endl
            << arcstream.str() << std::endl
            << "}" << std::endl;
 
     return output.str();
   }

◆ topologicalOrder()

INLINE const Sequence< NodeId > & gum::DAGmodel::topologicalOrder ( bool clear = true ) const

inherited

The topological order stays the same as long as no variable or arcs are added or erased src the topology.

Parameters

clear If false returns the previously created topology.

Definition at line 100 of file DAGmodel_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                               {
     return dag().topologicalOrder(clear);
   }

Here is the call graph for this function:

◆ toString()

template<typename GUM_SCALAR >

std::string gum::InfluenceDiagram< GUM_SCALAR >::toString ( ) const

Returns: Returns a string representation of this Influence Diagram.

Definition at line 359 of file influenceDiagram_tpl.h.

                                                            {
     std::stringstream output;
 
     output << "Influence Diagram{" << std::endl;
     output << "  chance: " << chanceNodeSize() << "," << std::endl;
     output << "  utility: " << utilityNodeSize() << "," << std::endl;
     output << "  decision: " << decisionNodeSize() << "," << std::endl;
     output << "  arcs: " << dag().sizeArcs() << "," << std::endl;
 
     double dSize = log10DomainSize();
 
     if (dSize > 6)
       output << "  domainSize: 10^" << dSize;
     else
       output << "  domainSize: " << std::round(std::pow(10.0, dSize));
 
     output << std::endl << "}";
 
     return output.str();
   }

◆ utility() [1/2]

template<typename GUM_SCALAR >

INLINE const Potential< GUM_SCALAR > & gum::InfluenceDiagram< GUM_SCALAR >::utility ( NodeId varId ) const

virtual

Returns the utility table of a utility node.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 398 of file influenceDiagram_tpl.h.

                                                                          {
     return *(utilityMap__[varId]);
   }

◆ utility() [2/2]

template<typename GUM_SCALAR>

virtual const Potential< GUM_SCALAR >& gum::InfluenceDiagram< GUM_SCALAR >::utility ( std::string name ) const

inlinefinalvirtual

Returns the CPT of a potential variable.

Exceptions

NotFound If no variable's id matches varId.

Definition at line 140 of file influenceDiagram.h.

                                                                                {
       return utility(idFromName(name));
     };

◆ utilityNodeSize()

template<typename GUM_SCALAR >

INLINE Size gum::InfluenceDiagram< GUM_SCALAR >::utilityNodeSize ( ) const

Returns the number of utility nodes.

Definition at line 434 of file influenceDiagram_tpl.h.

                                                                     {
     return utilityMap__.size();
   }

◆ variable()

template<typename GUM_SCALAR >

INLINE const DiscreteVariable & gum::InfluenceDiagram< GUM_SCALAR >::variable ( NodeId id ) const

finalvirtual

Returns a constant reference over a variable given it's node id.

Exceptions

NotFound If no variable's id matches varId.

Implements gum::GraphicalModel.

Definition at line 469 of file influenceDiagram_tpl.h.

                                                                        {
     return variableMap__[id];
   }

◆ variableFromName()

template<typename GUM_SCALAR >

INLINE const DiscreteVariable & gum::InfluenceDiagram< GUM_SCALAR >::variableFromName ( const std::string & name ) const

finalvirtual

Getter by name.

Exceptions

NotFound if no such name exists in the graph.

Implements gum::GraphicalModel.

Definition at line 491 of file influenceDiagram_tpl.h.

                                   {
     return variableMap__.variableFromName(name);
   }

◆ variableNodeMap()

template<typename GUM_SCALAR >

INLINE const VariableNodeMap & gum::InfluenceDiagram< GUM_SCALAR >::variableNodeMap ( ) const

finalvirtual

Returns a constant reference to the VariableNodeMap of this Influence Diagram.

Implements gum::GraphicalModel.

Definition at line 460 of file influenceDiagram_tpl.h.

                                                                      {
     return variableMap__;
   }

Member Data Documentation

◆ dag_

DAG gum::DAGmodel::dag_

protectedinherited

The DAG of this Directed Graphical Model.

Definition at line 225 of file DAGmodel.h.

◆ potentialMap__

template<typename GUM_SCALAR>

NodeProperty< Potential< GUM_SCALAR >* > gum::InfluenceDiagram< GUM_SCALAR >::potentialMap__

private

Mapping between potential variable's id and their CPT.

Definition at line 440 of file influenceDiagram.h.

◆ temporalOrder__

template<typename GUM_SCALAR>

List< NodeSet > gum::InfluenceDiagram< GUM_SCALAR >::temporalOrder__

mutableprivate

The temporal order.

Definition at line 445 of file influenceDiagram.h.

◆ utilityMap__

template<typename GUM_SCALAR>

NodeProperty< Potential< GUM_SCALAR >* > gum::InfluenceDiagram< GUM_SCALAR >::utilityMap__

private

Mapping between utility variable's id and their utility table.

Definition at line 442 of file influenceDiagram.h.

◆ variableMap__

template<typename GUM_SCALAR>

VariableNodeMap gum::InfluenceDiagram< GUM_SCALAR >::variableMap__

private

Mapping between id and variable.

Definition at line 437 of file influenceDiagram.h.

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

agrum/ID/influenceDiagram.h
agrum/ID/influenceDiagram_tpl.h

Public Member Functions

Static Public Member Functions

Protected Attributes

Protected Member Functions

Detailed Description

template<typename GUM_SCALAR> class gum::InfluenceDiagram< GUM_SCALAR >

Constructor & Destructor Documentation

◆ InfluenceDiagram() [1/2]

◆ ~InfluenceDiagram()

◆ InfluenceDiagram() [2/2]

Member Function Documentation

◆ add()

◆ addArc() [1/2]

◆ addArc() [2/2]

◆ addChanceNode() [1/2]

◆ addChanceNode() [2/2]

◆ addDecisionNode()

◆ addNode_()

◆ addUtilityNode() [1/2]

◆ addUtilityNode() [2/2]

◆ ancestors() [1/2]

◆ ancestors() [2/2]

◆ arcs()

◆ chanceNodeSize()

◆ changeVariableName() [1/2]

◆ changeVariableName() [2/2]

◆ children() [1/4]

◆ children() [2/4]

◆ children() [3/4]

◆ children() [4/4]

◆ clear()

◆ completeInstantiation()

◆ copyStructureAndTables_()

◆ cpt() [1/2]

◆ cpt() [2/2]

◆ dag()

◆ decisionNodeSize()

◆ decisionOrder()

◆ decisionOrderExists()

◆ descendants() [1/2]

◆ descendants() [2/2]

◆ empty()

◆ erase() [1/3]

◆ erase() [2/3]

◆ erase() [3/3]

◆ eraseArc() [1/3]

◆ eraseArc() [2/3]

◆ eraseArc() [3/3]

◆ exists() [1/2]

◆ exists() [2/2]

◆ existsArc() [1/2]

◆ existsArc() [2/2]

◆ existsPathBetween() [1/2]

◆ existsPathBetween() [2/2]

◆ family() [1/2]

◆ family() [2/2]

◆ fastPrototype()

◆ getChildrenDecision_()

◆ getDecisionGraph()

◆ getPartialTemporalOrder()

◆ hasSameStructure()

◆ idFromName()

◆ ids()

◆ isChanceNode() [1/2]

◆ isChanceNode() [2/2]

◆ isDecisionNode() [1/2]

◆ isDecisionNode() [2/2]

◆ isIndependent() [1/4]

◆ isIndependent() [2/4]

◆ isIndependent() [3/4]

◆ isIndependent() [4/4]

◆ isUtilityNode() [1/2]

◆ isUtilityNode() [2/2]

◆ log10DomainSize()

◆ moralGraph()

◆ moralGraph_()

◆ moralizedAncestralGraph() [1/2]

◆ moralizedAncestralGraph() [2/2]

◆ names() [1/2]

◆ names() [2/2]

template<typename GUM_SCALAR>
class gum::InfluenceDiagram< GUM_SCALAR >